Phenquestions
I denne artikkelen skal vi vise deg hvordan du leser og skriver til en fil i C ++ programmeringsspråk ved å bruke flere eksempler. For å forstå C ++ filoperasjoner som lese og skrive, må vi først forstå konseptet med en strøm i C++.
Hva er en strøm?
En strøm er ganske enkelt en datastrøm eller tegn. Det er to typer strømmer: inngangsstrømmer og utgangsstrømmer. En inngangsstrøm brukes til å lese dataene fra en ekstern inngangsenhet, for eksempel et tastatur, mens en utgangsstrøm brukes til å skrive data til den eksterne utdataenheten, for eksempel en skjerm. En fil kan betraktes som både en inngangs- og utgangskilde.
I C ++ bruker vi en strøm for å sende eller motta data til eller fra en ekstern kilde.
Vi kan bruke innebygde klasser for å få tilgang til en inngangs- / utgangsstrøm, dvs.e., “Ios”.
Her er strømklassehierarkiet til C ++ programmeringsspråk:
Objektene "cin" og "cout" brukes til å lese dataene fra tastaturet og til å vise utdataene på skjermen, henholdsvis. I tillegg brukes "ifstream", som står for "input file stream", for å lese en datastrøm fra en fil, og "ofstream", som står for "output file stream", brukes til å skrive en datastrøm til en fil.
“Iostram.h ”-fil inneholder alle nødvendige standard inngangs- / utgangsstrømklasser i programmeringsspråket C ++.
Eksempler
Nå som du forstår det grunnleggende om strømmer, vil vi diskutere følgende eksempler for å hjelpe deg med å bedre forstå filoperasjoner i C ++:
- Eksempel 1: Åpne og lukk en fil
- Eksempel 2: Skriv til en fil
- Eksempel 3: Les fra en fil
- Eksempel 4: Les og skriv til en fil
- Eksempel 5: Les og skriv til en binær fil
Eksempel 1: Åpne og lukk en fil
I dette eksempelprogrammet vil vi demonstrere hvordan du åpner / oppretter en fil og hvordan du lukker filen i C++. Som du kan se i programmet nedenfor, har vi tatt med biblioteket som kreves for filoperasjoner.
For å åpne og lukke en fil, trenger vi et objekt fra ofstream. For å lese eller skrive til en fil, må vi åpne filen. Vi har tatt med fstream-headerfilen på linje nummer 1, slik at vi får tilgang til ofstream-klassen.
Vi har erklært en myFile_Handler som et objekt for ofstream inne i hovedfunksjonen. Vi kan deretter bruke den åpne () -funksjonen til å opprette en tom fil og lukke () -funksjonen for å lukke filen.
#inkluderebruker navneområde std;
int main ()
ofstream myFile_Handler;
// Fil Åpne
myFile_Handler.åpne ("File_1.tekst");
// Fil lukk
myFile_Handler.Lukk();
retur 0;
Nå skal vi kompilere programmet og undersøke utdataene. Som du kan se i utgangsvinduet nedenfor, "File_1.txt ”-fil ble opprettet etter at programmet ble kjørt. Størrelsen på filen er null siden vi ikke har skrevet noe innhold i filen.
Eksempel 2: Skriv til en fil
I forrige eksempelprogram viste vi deg hvordan du åpner en fil og hvordan du lukker filen. Nå vil vi vise deg hvordan du skriver noe i en fil.
Vi kan skrive til en fil ved hjelp av strøminnføringsoperatø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.
#inkluderebruker navneområde std;
int main ()
ofstream myFile_Handler;
// Fil Åpne
myFile_Handler.åpne ("File_1.tekst");
// Skriv til filen
myFile_Handler << "This is a sample test File. " << endl;
myFile_Handler << "This is the second line of the file. " << endl;
// Fil lukk
myFile_Handler.Lukk();
retur 0;
Nå skal vi kompilere ovennevnte program og utføre det. Som du kan se nedenfor, har vi skrevet til filen File_1.tekst.
Eksempel 3: Les fra en fil
I de forrige eksemplene viste vi deg hvordan du skriver innhold til en fil. La oss nå lese innholdet fra filen vi opprettet i eksempel 2 og vise innholdet på standardutdataenheten, dvs.e., skjermen.
Vi bruker getline () -funksjonen til å lese hele linjen fra filen og deretter "cout" for å skrive ut linjen på skjermen.
#inkludere#inkludere
#inkludere
bruker navneområde std;
int main ()
ifstream myFile_Handler;
streng myLine;
// Fil Åpne i Lesemodus
myFile_Handler.åpne ("File_1.tekst");
hvis (myFile_Handler.er åpen())
// Fortsett å lese filen
while (getline (myFile_Handler, myLine))
// skriv ut linjen på standardutgangen
cout << myLine << endl;
// Fil lukk
myFile_Handler.Lukk();
ellers
cout << "Unable to open the file!";
retur 0;
Nå skal vi skrive ut innholdet i File_1.txt ved hjelp av følgende kommando: cat File_1.tekst. Når vi har samlet og kjørt programmet, er det klart at utdataene samsvarer med innholdet i filen. Derfor har vi lest filen og skrevet innholdet til filen på skjermen.
Eksempel 4: Les og skriv til en fil
Så langt har vi vist deg hvordan du åpner, leser, skriver og lukker en fil. I C ++ kan vi også lese og skrive til en fil samtidig. For å både lese og skrive til en fil, må vi få et fstream-objekt og åpne filen i “ios :: in” og “ios :: out” -modus.
I dette eksemplet skriver vi først innhold til filen. Deretter leser vi dataene fra filen og skriver dem ut til skjermen.
#inkludere#inkludere
#inkludere
bruker navneområde std;
int main ()
fstream myFile_Handler;
streng myLine;
// Fil Åpne
myFile_Handler.åpne ("File_1.txt ", ios :: inn | ios :: ut);
// Sjekk om filen har åpnet
hvis(!myFile_Handler)
cout << "File did not open!";
utgang (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);
// Les filen
hvis (myFile_Handler.er åpen())
// Fortsett å lese filen
while (getline (myFile_Handler, myLine))
// skriv ut linjen på standardutgangen
cout << myLine << endl;
// Fil lukk
myFile_Handler.Lukk();
ellers
cout << "Unable to open the file!";
myFile_Handler.Lukk();
retur 0;
Nå skal vi kompilere og gjennomføre programmet.
Eksempel 5: Les og skriv til en binær fil
I dette eksemplet skal vi erklære en klasse og deretter skrive objektet til en binær fil. For å forenkle dette eksemplet har vi deklarert medarbeiderklassen med en offentlig variabel emp_id. Deretter vil vi lese den binære filen og skrive ut utgangen til skjermen.
#inkludere#inkludere
bruker navneområde std;
klasse Ansatt
offentlig:
int emp_id;
;
int main ()
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Ansatt empObj_W, empObj_R;
// Fil Åpne
binOutFile_Handler.åpen ("Ansatt.dat ", ios :: ut | ios :: binær);
// Sjekk om filen har åpnet
hvis(!binOutFile_Handler)
cout << "File did not open!";
utgang (1);
// Initier empObj_W
empObj_W.emp_id = 1512;
// Skriv til filen
binOutFile_Handler.skriv ((char *) & empObj_W, sizeof (ansatt));
binOutFile_Handler.Lukk();
hvis(!binOutFile_Handler.god())
cout << "Error occured during writing the binary file!" << endl;
utgang (2);
// La oss nå lese den ansatte.dat-fil
binInFile_Handler.åpen ("Ansatt.dat ", ios :: i | ios :: binær);
// Sjekk om filen har åpnet
hvis(!binInFile_Handler)
cout << "File did not open!";
utgang (3);
// Les innholdet i binærfilen
binInFile_Handler.les ((char *) & empObj_R, sizeof (ansatt));
binInFile_Handler.Lukk();
hvis(!binInFile_Handler.god())
cout << "Error occured during reading the binary file!" << endl;
utgang (4);
// Skriv ut utgangen av empObj_R
cout << "Details of the Employee : " << endl;
cout << "Employee ID : " << empObj_R.emp_id << endl;
retur 0;
Konklusjon
Filer brukes hovedsakelig til å lagre dataene, og de spiller en viktig rolle i den virkelige programmeringen. I denne artikkelen viste vi deg hvordan du bruker forskjellige filoperasjoner med C ++ programmeringsspråk ved å jobbe gjennom flere eksempler. Videre viste vi deg hvordan du leser og skriver data i både tekstfiler og binære filer.
