Hvordan lese og skrive til en fil i C ++

How Read Write File C



I denne artikkelen skal vi vise deg hvordan du leser og skriver til en fil i programmeringsspråket C ++ 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 strøm av data eller tegn. Det er to typer strømmer: inngangsstrømmer og utgangsstrømmer. En inngangsstrøm brukes til å lese data fra en ekstern inndataenhet, 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 input/output-strøm, dvs. ios.





Her er strømklassens hierarki for programmeringsspråket C ++:



Cin- og cout -objektene brukes til henholdsvis å lese dataene fra tastaturet og vise utgangen på skjermen. 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.

Filen iostram.h inneholder alle nødvendige standard input/output stream -klasser 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/lager 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 ofstream. For å lese eller skrive til en fil må vi åpne filen. Vi har inkludert fstream header-filen på linje nummer 1, slik at vi kan få tilgang til ofstream-klassen.

Vi har erklært en myFile_Handler som et objekt for strøm inne i hovedfunksjonen. Vi kan deretter bruke funksjonen open () til å lage en tom fil og lukke () -funksjonen for å lukke filen.

#inkludere

ved hjelp av navneområdetimer;

inthoved-()
{
ofstream myFile_Handler;

// Fil åpen
myFile_Handler.åpen('File_1.txt');

// Fil Lukk
myFile_Handler.Lukk();
komme tilbake 0;
}

Nå skal vi kompilere programmet og undersøke resultatet. Som du kan se i utgangsvinduet nedenfor, ble File_1.txt -filen 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 det forrige eksempelprogrammet viste vi deg hvordan du åpner en fil og hvordan du lukker filen. Nå viser vi deg hvordan du skriver noe i en fil.

Vi kan skrive til en fil ved hjelp av operatøren for innsetting av strømmer, 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.

#inkludere

ved hjelp av navneområdetimer;

inthoved-()
{
ofstream myFile_Handler;
// Fil åpen
myFile_Handler.åpen('File_1.txt');

// Skriv til filen
myFile_Handler<< 'Dette er en prøvetestfil. ' <<endl;
myFile_Handler<< 'Dette er den andre linjen i filen. ' <<endl;

// Fil Lukk
myFile_Handler.Lukk();
komme tilbake 0;
}

Nå vil vi kompilere programmet ovenfor og utføre det. Som du kan se nedenfor, har vi skrevet til filen File_1.txt.

Eksempel 3: Les fra en fil

I de foregående 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å standardutdataenheten, dvs. skjermen.

Vi bruker funksjonen getline () til å lese hele linjen fra filen og deretter skrive ut linjen på skjermen.

#inkludere
#inkludere
#inkludere

ved hjelp av navneområdetimer;

inthoved-()
{
ifstream myFile_Handler;
streng myLine;

// Filåpning i lesemodus
myFile_Handler.åpen('File_1.txt');

hvis(myFile_Handler.er åpen())
{
// Fortsett å lese filen
samtidig som(getline(myFile_Handler, myLine))
{
// skriv ut linjen på standardutgangen
koste <<myLine<<endl;
}
// Fil Lukk
myFile_Handler.Lukk();
}
ellers
{
koste << 'Kan ikke åpne filen!';
}
komme tilbake 0;
}

Nå vil vi skrive ut innholdet i File_1.txt ved å bruke følgende kommando: cat File_1.txt. Når vi kompilerer og kjører programmet, er det klart at utdataene samsvarer med innholdet i filen. Derfor har vi lest filen og skrevet ut innholdet i filen til 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

ved hjelp av navneområdetimer;

inthoved-()
{
fstream myFile_Handler;
streng myLine;

// Fil åpen
myFile_Handler.åpen('File_1.txt', ios::i |ios::ute);

// Sjekk om filen har åpnet seg
hvis(!myFile_Handler)
{
koste << 'Filen åpnet seg ikke!';
exit(1);
}

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

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

// Les filen
hvis(myFile_Handler.er åpen())
{
// Fortsett å lese filen
samtidig som(getline(myFile_Handler, myLine))
{
// skriv ut linjen på standardutgangen
koste <<myLine<<endl;
}

// Fil Lukk
myFile_Handler.Lukk();
}
ellers
{
koste << 'Kan ikke åpne filen!';
}
myFile_Handler.Lukk();
komme tilbake 0;
}

Nå skal vi kompilere og kjøre programmet.

Eksempel 5: Les og skriv til en binær fil

I dette eksemplet skal vi deklarere en klasse og deretter skrive objektet til en binær fil. For å forenkle dette eksemplet har vi erklært Employee -klassen med en offentlig variabel emp_id. Deretter vil vi lese den binære filen og skrive ut utgangen til skjermen.

#inkludere
#inkludere

ved hjelp av navneområdetimer;

klasseAnsatt
{
offentlig:
intemp_id;
};

inthoved-()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;

Ansatt empObj_W, empObj_R;

// Fil åpen
binOutFile_Handler.åpen('employee.dat', ios::ute |ios::binær);

// Sjekk om filen har åpnet seg
hvis(!binOutFile_Handler)
{
koste << 'Filen åpnet seg ikke!';
exit(1);
}

// Initialiser empObj_W
empObj_W.emp_id = 1512;

// Skriv til filen
binOutFile_Handler.skrive((røye *) &empObj_W,størrelsen av(Ansatt));
binOutFile_Handler.Lukk();

hvis(!binOutFile_Handler.god())
{
koste << 'Det oppstod en feil under skriving av den binære filen!' <<endl;
exit(2);
}

// La oss lese filen medarbeider.dat
binInFile_Handler.åpen('employee.dat', ios::i |ios::binær);
// Sjekk om filen har åpnet seg
hvis(!binInFile_Handler)
{
koste << 'Filen åpnet seg ikke!';
exit(3);
}

// Les innholdet i den binære filen
binInFile_Handler.lese((røye *) &empObj_R,størrelsen av(Ansatt));
binInFile_Handler.Lukk();

hvis(!binInFile_Handler.god())
{
koste << 'Det oppstod en feil under lesing av den binære filen!' <<endl;
exit(4);
}

// Skriv ut utdataene fra empObj_R
koste << 'Detaljer om den ansatte:' <<endl;
koste << 'Ansatt ID : ' <<empObj_R.emp_id <<endl;

komme tilbake 0;
}

Konklusjon

Filer brukes hovedsakelig til å lagre data, 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 å gå gjennom flere eksempler. Videre viste vi deg hvordan du leser og skriver data i både tekstfiler og binære filer.