Sådan læses og skrives til en fil i C ++

How Read Write File C



I denne artikel vil vi vise dig, hvordan du læser og skriver til en fil i programmeringssproget C ++ ved hjælp af flere eksempler. For at forstå C ++ filoperationer som læse og skrive, skal vi først forstå konceptet med en strøm i C ++.

Hvad er en Stream?

En strøm er simpelthen en strøm af data eller tegn. Der er to typer strømme: inputstrømme og outputstrømme. En inputstrøm bruges til at læse dataene fra en ekstern inputenhed, f.eks. Et tastatur, mens en outputstrøm bruges til at skrive data til den eksterne outputenhed, f.eks. En skærm. En fil kan betragtes som både en input- og outputkilde.









I C ++ bruger vi en stream til at sende eller modtage data til eller fra en ekstern kilde.



Vi kan bruge indbyggede klasser til at få adgang til en input/output-strøm, dvs. ios.





Her er strømklassens hierarki for C ++ programmeringssprog:



Cin- og cout -objekterne bruges til henholdsvis at læse dataene fra tastaturet og vise output på skærmen. Desuden bruges ifstream, som står for inputfilstrøm, til at læse en datastrøm fra en fil, og ofstream, som står for outputfilstrøm, bruges til at skrive en datastrøm til en fil.

Filen iostram.h indeholder alle de krævede standard input/output -strømklasser i programmeringssproget C ++.

Eksempler

Nu hvor du forstår det grundlæggende i streams, vil vi diskutere følgende eksempler for at hjælpe dig med bedre at forstå filoperationer i C ++:

  • Eksempel 1: Åbn og luk en fil
  • Eksempel 2: Skriv til en fil
  • Eksempel 3: Læs fra en fil
  • Eksempel 4: Læs og skriv til en fil
  • Eksempel 5: Læs og skriv til en binær fil

Eksempel 1: Åbn og luk en fil

I dette eksempelprogram vil vi demonstrere, hvordan man åbner/opretter en fil, og hvordan man lukker filen i C ++. Som du kan se i nedenstående program, har vi inkluderet det bibliotek, der kræves til filoperationer.

For at åbne og lukke en fil, har vi brug for et objekt af ofstream. Derefter skal vi åbne filen for at læse eller skrive til en fil. Vi har inkluderet fstream-header-filen på linje nummer-1, så vi kan få adgang til ofstream-klassen.

Vi har erklæret en myFile_Handler som et objekt for strømmen i hovedfunktionen. Vi kan derefter bruge funktionen open () til at oprette en tom fil og funktionen close () til at lukke filen.

#omfatte

ved brug af navnerumtimer;

intvigtigste()
{
ofstream myFile_Handler;

// Fil Åbn
myFile_Handler.åben('File_1.txt');

// Fil Luk
myFile_Handler.tæt();
Vend tilbage 0;
}

Nu vil vi kompilere programmet og undersøge output. Som du kan se i outputvinduet herunder, blev filen_1_1.txt oprettet efter udførelse af programmet. Filens størrelse er nul, da vi ikke har skrevet noget indhold i filen.

Eksempel 2: Skriv til en fil

I det foregående eksempelprogram viste vi dig, hvordan du åbner en fil, og hvordan du lukker filen. Nu viser vi dig, hvordan du skriver noget i en fil.

Vi kan skrive til en fil ved hjælp af strømindsættelsesoperatoren, dvs.<<. In this program, we have used the file handler and insertion operator to write two lines in the file. The insertion operator (<<) indicates that we are inserting the string into the output file stream object.

#omfatte

ved brug af navnerumtimer;

intvigtigste()
{
ofstream myFile_Handler;
// Fil Åbn
myFile_Handler.åben('File_1.txt');

// Skriv til filen
myFile_Handler<< 'Dette er en prøve -testfil. ' <<endl;
myFile_Handler<< 'Dette er den anden linje i filen. ' <<endl;

// Fil Luk
myFile_Handler.tæt();
Vend tilbage 0;
}

Nu vil vi kompilere ovenstående program og udføre det. Som du kan se nedenfor, har vi med succes skrevet til filen File_1.txt.

Eksempel 3: Læs fra en fil

I de foregående eksempler viste vi dig, hvordan du skriver indhold til en fil. Lad os nu læse indholdet fra den fil, som vi oprettede i eksempel-2, og vise indholdet på standardoutputenheden, dvs. skærmen.

Vi bruger funktionen getline () til at læse hele linjen fra filen og derefter skrive til at udskrive linjen på skærmen.

#omfatte
#omfatte
#omfatte

ved brug af navnerumtimer;

intvigtigste()
{
ifstream myFile_Handler;
streng myLine;

// Fil Åbn i læsetilstand
myFile_Handler.åben('File_1.txt');

hvis(myFile_Handler.er åben())
{
// Fortsæt med at læse filen
mens(getline(myFile_Handler, myLine))
{
// udskriv linjen på standardoutput
koste <<myLine<<endl;
}
// Fil Luk
myFile_Handler.tæt();
}
andet
{
koste << 'Filen kunne ikke åbnes!';
}
Vend tilbage 0;
}

Nu vil vi udskrive indholdet i File_1.txt ved hjælp af følgende kommando: cat File_1.txt. Når vi har kompileret og eksekveret programmet, er det klart, at output matcher filens indhold. Derfor har vi med succes læst filen og udskrevet filens indhold til skærmen.

Eksempel 4: Læs og skriv til en fil

Indtil videre har vi vist dig, hvordan du åbner, læser, skriver og lukker en fil. I C ++ kan vi også læse og skrive til en fil på samme tid. For både at læse og skrive til en fil skal vi hente et fstream -objekt og åbne filen i ios :: in og ios :: out -tilstand.

I dette eksempel skriver vi først noget indhold til filen. Derefter læser vi dataene fra filen og udskriver dem til skærmen.

#omfatte
#omfatte
#omfatte

ved brug af navnerumtimer;

intvigtigste()
{
fstream myFile_Handler;
streng myLine;

// Fil Åbn
myFile_Handler.åben('File_1.txt', ios::i |ios::ud);

// Kontroller, om filen er åbnet
hvis(!myFile_Handler)
{
koste << 'Filen åbnede ikke!';
Afslut(1);
}

// Skriv til filen
myFile_Handler<< '1. Dette er en anden prøve test fil. ' <<endl;
myFile_Handler<< '2. Dette er den anden linje i filen. ' <<endl;

myFile_Handler.søger(ios::tigge);

// Læs filen
hvis(myFile_Handler.er åben())
{
// Fortsæt med at læse filen
mens(getline(myFile_Handler, myLine))
{
// udskriv linjen på standardoutput
koste <<myLine<<endl;
}

// Fil Luk
myFile_Handler.tæt();
}
andet
{
koste << 'Filen kunne ikke åbnes!';
}
myFile_Handler.tæt();
Vend tilbage 0;
}

Nu vil vi kompilere og udføre programmet.

Eksempel 5: Læs og skriv til en binær fil

I dette eksempel vil vi erklære en klasse og derefter skrive objektet til en binær fil. For at forenkle dette eksempel har vi erklæret medarbejderklassen med en offentlig variabel emp_id. Derefter læser vi den binære fil og udskriver output til skærmen.

#omfatte
#omfatte

ved brug af navnerumtimer;

klasseMedarbejder
{
offentlig:
intemp_id;
};

intvigtigste()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;

Medarbejder empObj_W, empObj_R;

// Fil Åbn
binOutFile_Handler.åben('medarbejder.dat', ios::ud |ios::binært);

// Kontroller, om filen er åbnet
hvis(!binOutFile_Handler)
{
koste << 'Filen åbnede ikke!';
Afslut(1);
}

// Initialiser empObj_W
empObj_W.emp_id = 1512;

// Skriv til filen
binOutFile_Handler.skrive((forkælelse *) &empObj_W,størrelse på(Medarbejder));
binOutFile_Handler.tæt();

hvis(!binOutFile_Handler.godt())
{
koste << 'Der opstod en fejl under skrivning af den binære fil!' <<endl;
Afslut(2);
}

// Lad os nu læse filen medarbejder.dat
binInFile_Handler.åben('medarbejder.dat', ios::i |ios::binært);
// Kontroller, om filen er åbnet
hvis(!binInFile_Handler)
{
koste << 'Filen åbnede ikke!';
Afslut(3);
}

// Læs indholdet af den binære fil
binInFile_Handler.Læs((forkælelse *) &empObj_R,størrelse på(Medarbejder));
binInFile_Handler.tæt();

hvis(!binInFile_Handler.godt())
{
koste << 'Der opstod en fejl under læsning af den binære fil!' <<endl;
Afslut(4);
}

// Udskriv output fra empObj_R
koste << 'Detaljer om medarbejderen:' <<endl;
koste << 'Medarbejder-ID : ' <<empObj_R.emp_id <<endl;

Vend tilbage 0;
}

Konklusion

Filer bruges hovedsageligt til at gemme data, og de spiller en vigtig rolle i den virkelige verden programmering. I denne artikel viste vi dig, hvordan du bruger forskellige filoperationer med programmeringssproget C ++ ved at gennemgå flere eksempler. Desuden viste vi dig, hvordan du læser og skriver data i både tekstfiler og binære filer.