Hvordan lese og skrive til en fil i C ++

I denne artikkelen skal vi vise deg hvordan du kan lese og skrive til en fil på C ++ programmeringsspråket 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 flyt av data 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 utgangsenheten, 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, i.e., “IOS”.

Her er strømklassehierarkiet til C ++ programmeringsspråket:

"CIN" og "cout" -objektene brukes til å lese dataene fra tastaturet og for å vise utgangen på skjermen. I tillegg brukes "ifstream", som står for "Input File Stream", å lese en strøm av data fra en fil, og "ofStream", som står for "Output File Stream", brukes til å skrive en strøm av data til en fil.

“IOSTRAM.H ”-filen inneholder alle nødvendige standardinngangs-/utgangsstrømsklasser i C ++ programmeringsspråket.

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 inkludert biblioteket som kreves for filoperasjoner.

For å åpne og lukke en fil, trenger vi et objekt av Stream. For å lese eller skrive til en fil, må vi åpne filen. Vi har tatt med Fstream-overskriftsfilen på linje nummer 1 slik at vi får tilgang til avstrømsklasse.

Vi har erklært en myfile_handler som et objekt av avstrøms inne i hovedfunksjonen. Vi kan deretter bruke Open () -funksjonen for å lage en tom fil og lukk () -funksjonen for å lukke filen.

#inkludere
ved hjelp av navneområdet STD;
int main ()

ofstream myfile_handler;
// Fil åpen
myfile_handler.Åpne ("File_1.tekst");
// Filen lukk
myfile_handler.Lukk();
retur 0;

Nå vil vi samle programmet og undersøke utgangen. Som du kan se i utgangsvinduet nedenfor, “File_1.txt ”-fil ble opprettet etter å ha utført programmet. Størrelsen på filen er null siden vi ikke har skrevet noe innhold i filen.

Eksempel 2: Skriv til en fil

I det forrige eksempelprogrammet 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øminnsettingsoperatø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.

#inkludere
ved hjelp av navneområdet STD;
int main ()

ofstream myfile_handler;
// Fil åpen
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;
// Filen lukk
myfile_handler.Lukk();
retur 0;

Nå vil vi samle programmet ovenfor og utføre det. Som du kan se nedenfor, har vi vellykket 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 som vi opprettet i eksempel-2 og vise innholdet på standardutgangsenheten, i.e., skjermen.

Vi bruker getline () -funksjonen for å lese hele linjen fra filen og deretter "cout" for å skrive ut linjen på skjermen.

#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

ifstream myfile_handler;
streng myline;
// Fil åpen i lesemodus
myfile_handler.Åpne ("File_1.tekst");
if (myfile_handler.er åpen())

// Fortsett å lese filen
mens (getline (myfile_handler, myline))

// Skriv ut linjen på standardutgangen
cout << myLine << endl;

// Filen lukk
myfile_handler.Lukk();

ellers

cout << "Unable to open the file!";

retur 0;

Nå skal vi skrive ut innholdet i file_1.txt Bruke følgende kommando: CAT File_1.tekst. Når vi har samlet og utført programmet, er det klart at utdataene samsvarer med innholdet i filen. Derfor har vi lest filen med hell og skrevet ut innholdet i filen til skjermen.

Eksempel 4: Les og skriv til en fil

Så langt har vi vist deg hvordan du skal åpne, lese, skrive og lukke 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 noe innhold til filen. Deretter leser vi dataene fra filen og skriver den ut til skjermen.

#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

fStream myfile_handler;
streng myline;
// Fil åpen
myfile_handler.Åpne ("File_1.txt ", ios :: in | ios :: out);
// sjekk om filen har åpnet
hvis(!myfile_handler)

cout << "File did not open!";
Avslutt (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
if (myfile_handler.er åpen())

// Fortsett å lese filen
mens (getline (myfile_handler, myline))

// Skriv ut linjen på standardutgangen
cout << myLine << endl;

// Filen lukk
myfile_handler.Lukk();

ellers

cout << "Unable to open the file!";

myfile_handler.Lukk();
retur 0;

Nå vil vi samle og utfø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 erklært ansattklassen med en offentlig variabel emp_id. Deretter vil vi lese den binære filen og skrive ut utdataene til skjermen.

#inkludere
#inkludere
ved hjelp av navneområdet STD;
klasseansatt

offentlig:
int emp_id;
;
int main ()

avStream binoutfile_handler;
ifstream bininfile_handler;
Ansatt EMPOBJ_W, EMPOBJ_R;
// Fil åpen
binoutfile_handler.Åpne ("Ansatt.dat ", ios :: out | ios :: binær);
// sjekk om filen har åpnet
hvis(!binoutfile_handler)

cout << "File did not open!";
Avslutt (1);

// Initialiser empobj_w
EMPOBJ_W.emp_id = 1512;
// Skriv til filen
binoutfile_handler.skriv ((char *) & empobj_w, størrelse av (ansatt));
binoutfile_handler.Lukk();
hvis(!binoutfile_handler.flink())

cout << "Error occured during writing the binary file!" << endl;
Avslutt (2);

// Nå, la oss lese den ansatte.Dat -fil
bininfile_handler.Åpne ("Ansatt.dat ", ios :: in | ios :: binær);
// sjekk om filen har åpnet
hvis(!bininfile_handler)

cout << "File did not open!";
Avslutt (3);

// Les innholdet i den binære filen
bininfile_handler.Les ((char *) & empobj_r, størrelse av (ansatt));
bininfile_handler.Lukk();
hvis(!bininfile_handler.flink())

cout << "Error occured during reading the binary file!" << endl;
Avslutt (4);

// Skriv ut utdataene til 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 programmeringsspråket C ++ ved å jobbe gjennom flere eksempler. Videre viste vi deg hvordan du kan lese og skrive data i både tekstfiler og binære filer.