I denne artikel vil vi vise dig, hvordan du læser og skriver til en fil på C ++ programmeringssproget ved hjælp af flere eksempler. For at forstå C ++ filhandlinger som læse og skrive, skal vi først forstå konceptet med en stream i C++.
Hvad er en strøm?
En stream er simpelthen en strøm af data eller tegn. Der er to typer streams: input streams og output streams. En inputstrøm bruges til at læse dataene fra en ekstern inputenhed, såsom et tastatur, mens en outputstrøm bruges til at skrive data til den eksterne outputenhed, såsom 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 stream, dvs.e., “Ios”.
Her er streamklassehierarkiet i C ++ programmeringssprog:
Objekterne "cin" og "cout" bruges til at læse dataene fra tastaturet og til at vise output på henholdsvis skærmen. Derudover bruges "ifstream", som står for "input file stream", til at læse en datastrøm fra en fil, og "ofstream", som står for "output file stream", bruges til at skrive en datastrøm til en fil.
"Iostram.h ”-filen indeholder alle de krævede standard input / output streamklasser i programmeringssprog 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 filhandlinger.
For at åbne og lukke en fil har vi brug for et objekt fra ofstream. Derefter skal vi åbne filen for at læse eller skrive til en fil. Vi har inkluderet fstream-headerfilen på linje nummer 1, så vi kan få adgang til ofstream-klassen.
Vi har erklæret en myFile_Handler som et objekt for ofstream inde i hovedfunktionen. Vi kan derefter bruge den åbne () funktion til at oprette en tom fil og lukke () funktionen til at lukke filen.
#omfatteved hjælp af namespace std;
int main ()
ofstream myFile_Handler;
// Fil åben
myFile_Handler.åben ("File_1.txt ");
// File Close
myFile_Handler.tæt();
returnere 0;
Nu vil vi kompilere programmet og undersøge output. Som du kan se i outputvinduet nedenfor, “File_1.txt ”-fil blev 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ættelsesoperatøren, i.e., “<<”. 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.
#omfatteved hjælp af namespace std;
int main ()
ofstream myFile_Handler;
// Fil åben
myFile_Handler.åben ("File_1.txt ");
// Skriv til filen
myFile_Handler << "This is a sample test File. " << endl;
myFile_Handler << "This is the second line of the file. " << endl;
// File Close
myFile_Handler.tæt();
returnere 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 filen, som vi oprettede i eksempel 2, og vise indholdet på standardoutputenheden, dvs.e., skærmen.
Vi bruger getline () -funktionen til at læse hele linjen fra filen og derefter "cout" for at udskrive linjen på skærmen.
#omfatte#omfatte
#omfatte
ved hjælp af namespace std;
int main ()
ifstream myFile_Handler;
streng myLine;
// Fil Åbn i læsetilstand
myFile_Handler.åben ("File_1.txt ");
hvis (myFile_Handler.er åben())
// Bliv ved med at læse filen
while (getline (myFile_Handler, myLine))
// udskriv linjen på standardoutput
cout << myLine << endl;
// File Close
myFile_Handler.tæt();
andet
cout << "Unable to open the file!";
returnere 0;
Nu udskriver vi indholdet af File_1.txt ved hjælp af følgende kommando: cat File_1.txt. Når vi først har kompileret og udført programmet, er det klart, at output matcher indholdet af filen. Derfor har vi med succes læst filen og udskrevet indholdet af filen 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 er vi nødt til at få 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 hjælp af namespace std;
int main ()
fstream myFile_Handler;
streng myLine;
// Fil åben
myFile_Handler.åben ("File_1.txt ", ios :: in | ios :: out);
// Kontroller, om filen er åbnet
hvis(!myFile_Handler)
cout << "File did not open!";
udgang (1);
// Skriv til filen
myFile_Handler << "1. This is another sample test File. " << endl;
myFile_Handler << "2. This is the second line of the file. " << endl;
myFile_Handler.seekg (ios :: beg);
// Læs filen
hvis (myFile_Handler.er åben())
// Bliv ved med at læse filen
while (getline (myFile_Handler, myLine))
// udskriv linjen på standardoutput
cout << myLine << endl;
// File Close
myFile_Handler.tæt();
andet
cout << "Unable to open the file!";
myFile_Handler.tæt();
returnere 0;
Nu vil vi kompilere og udføre programmet.
Eksempel 5: Læs og skriv til en binær fil
I dette eksempel skal 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 hjælp af namespace std;
klasse medarbejder
offentlig:
int emp_id;
;
int main ()
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Medarbejder empObj_W, empObj_R;
// Fil åben
binOutFile_Handler.åben ("Medarbejder.dat ", ios :: out | ios :: binær);
// Kontroller, om filen er åbnet
hvis(!binOutFile_Handler)
cout << "File did not open!";
udgang (1);
// Initialiser empObj_W
empObj_W.emp_id = 1512;
// Skriv til filen
binOutFile_Handler.skriv ((char *) & empObj_W, sizeof (Medarbejder));
binOutFile_Handler.tæt();
hvis(!binOutFile_Handler.godt())
cout << "Error occured during writing the binary file!" << endl;
udgang (2);
// Lad os nu læse medarbejderen.dat-fil
binInFile_Handler.åben ("Medarbejder.dat ", ios :: i | ios :: binær);
// Kontroller, om filen er åbnet
hvis(!binInFile_Handler)
cout << "File did not open!";
udgang (3);
// Læs indholdet af den binære fil
binInFile_Handler.læse ((char *) & empObj_R, sizeof (Medarbejder));
binInFile_Handler.tæt();
hvis(!binInFile_Handler.godt())
cout << "Error occured during reading the binary file!" << endl;
udgang (4);
// Udskriv output fra empObj_R
cout << "Details of the Employee : " << endl;
cout << "Employee ID : " << empObj_R.emp_id << endl;
returnere 0;
Konklusion
Filer bruges hovedsageligt til at gemme dataene, og de spiller en vigtig rolle i den virkelige programmering. I denne artikel viste vi dig, hvordan du bruger forskellige filhandlinger med C ++ programmeringssproget ved at arbejde gennem flere eksempler. Desuden viste vi dig, hvordan du læser og skriver data i både tekstfiler og binære filer.