Phenquestions
I den här artikeln kommer vi att visa dig hur du läser och skriver till en fil på C ++ programmeringsspråket med hjälp av flera exempel. För att förstå C ++ - filåtgärder som att läsa och skriva måste vi först förstå begreppet en ström i C++.
Vad är en ström?
En ström är helt enkelt ett flöde av data eller tecken. Det finns två typer av strömmar: ingångsströmmar och utgångsströmmar. En ingångsström används för att läsa data från en extern inmatningsenhet, såsom ett tangentbord, medan en utgångsström används för att skriva data till den externa utmatningsenheten såsom en bildskärm. En fil kan betraktas som både in- och utgångskälla.
I C ++ använder vi en ström för att skicka eller ta emot data till eller från en extern källa.
Vi kan använda inbyggda klasser för att komma åt en in / ut-ström, dvs.e., “Ios”.
Här är strömklasshierarkin för programmeringsspråket C ++:
Objekten "cin" och "cout" används för att läsa data från tangentbordet och för att visa utgången på skärmen respektive. Dessutom används "ifstream", som står för "input file stream", för att läsa en dataström från en fil, och "ofstream", som står för "output file stream", används för att skriva en dataström till en fil.
Den iostram.h ”-filen innehåller alla nödvändiga standardingångs- / utgångsströmklasser i programmeringsspråket C ++.
Exempel
Nu när du förstår grunderna för strömmar kommer vi att diskutera följande exempel för att hjälpa dig att bättre förstå filhantering i C ++:
- Exempel 1: Öppna och stäng en fil
- Exempel 2: Skriv till en fil
- Exempel 3: Läs från en fil
- Exempel 4: Läs och skriv till en fil
- Exempel 5: Läs och skriv till en binär fil
Exempel 1: Öppna och stäng en fil
I detta exempelprogram kommer vi att visa hur man öppnar / skapar en fil och hur man stänger filen i C++. Som du kan se i programmet nedan har vi inkluderat det bibliotek som krävs för filoperationer.
För att öppna och stänga en fil behöver vi ett objekt från ofstream. För att läsa eller skriva till en fil måste vi sedan öppna filen. Vi har inkluderat fstream-huvudfilen på rad nummer 1 så att vi kan komma åt ofstream-klassen.
Vi har förklarat en myFile_Handler som ett objekt för ofstream inom huvudfunktionen. Vi kan sedan använda funktionen open () för att skapa en tom fil och funktionen close () för att stänga filen.
#omfattaanvänder namnrymd std;
int main ()
ofstream myFile_Handler;
// Filen är öppen
myFile_Handler.öppna ("File_1.Text");
// File Close
myFile_Handler.stänga();
returnera 0;
Nu kommer vi att sammanställa programmet och undersöka resultatet. Som du kan se i utdatafönstret nedan, “File_1.txt ”-fil skapades efter körning av programmet. Filens storlek är noll eftersom vi inte har skrivit något innehåll i filen.
Exempel 2: Skriv till en fil
I föregående exempelprogram visade vi dig hur du öppnar en fil och hur du stänger filen. Nu visar vi dig hur du skriver något i en fil.
Vi kan skriva till en fil med hjälp av ströminföringsoperatören, dvs.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.
#omfattaanvänder namnrymd std;
int main ()
ofstream myFile_Handler;
// Filen är öppen
myFile_Handler.öppna ("File_1.Text");
// Skriv till 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.stänga();
returnera 0;
Nu kommer vi att sammanställa ovanstående program och utföra det. Som du kan se nedan har vi framgångsrikt skrivit till filen File_1.Text.
Exempel 3: Läs från en fil
I de föregående exemplen visade vi dig hur du skriver innehåll till en fil. Låt oss nu läsa innehållet från filen som vi skapade i exempel 2 och visa innehållet på standardutmatningsenheten, dvs.e., monitorn.
Vi använder getline () -funktionen för att läsa hela raden från filen och sedan “cout” för att skriva ut raden på skärmen.
#omfatta#omfatta
#omfatta
använder namnrymd std;
int main ()
ifstream myFile_Handler;
sträng myLine;
// Filen är öppen i läsläget
myFile_Handler.öppna ("File_1.Text");
om (myFile_Handler.är öppen())
// Fortsätt läsa filen
while (getline (myFile_Handler, myLine))
// skriv ut raden på standardutmatningen
cout << myLine << endl;
// File Close
myFile_Handler.stänga();
annan
cout << "Unable to open the file!";
returnera 0;
Nu kommer vi att skriva ut innehållet i File_1.txt med följande kommando: cat File_1.Text. När vi väl har kompilerat och kört programmet är det klart att utdata matchar innehållet i filen. Därför har vi framgångsrikt läst filen och skrivit ut innehållet på filen till monitorn.
Exempel 4: Läs och skriv till en fil
Hittills har vi visat dig hur du öppnar, läser, skriver och stänger en fil. I C ++ kan vi också läsa och skriva till en fil samtidigt. För att både läsa och skriva till en fil måste vi få ett fstream-objekt och öppna filen i läget “ios :: in” och “ios :: out”.
I det här exemplet skriver vi först lite innehåll till filen. Sedan läser vi data från filen och skriver ut den till bildskärmen.
#omfatta#omfatta
#omfatta
använder namnrymd std;
int main ()
fstream myFile_Handler;
sträng myLine;
// Filen är öppen
myFile_Handler.öppna ("File_1.txt ", ios :: in | ios :: out);
// Kontrollera om filen har öppnats
om(!myFile_Handler)
cout << "File did not open!";
utgång (1);
// Skriv till 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
om (myFile_Handler.är öppen())
// Fortsätt läsa filen
while (getline (myFile_Handler, myLine))
// skriv ut raden på standardutmatningen
cout << myLine << endl;
// File Close
myFile_Handler.stänga();
annan
cout << "Unable to open the file!";
myFile_Handler.stänga();
returnera 0;
Nu kommer vi att sammanställa och köra programmet.
Exempel 5: Läs och skriv till en binär fil
I det här exemplet ska vi deklarera en klass och sedan skriva objektet till en binär fil. För att förenkla detta exempel har vi förklarat anställdsklassen med en offentlig variabel emp_id. Sedan läser vi den binära filen och skriver ut utgången till monitorn.
#omfatta#omfatta
använder namnrymd std;
klass Anställd
offentlig:
int emp_id;
;
int main ()
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Anställd empObj_W, empObj_R;
// Filen är öppen
binOutFile_Handler.öppen ("Anställd.dat ", ios :: ut | ios :: binärt);
// Kontrollera om filen har öppnats
om(!binOutFile_Handler)
cout << "File did not open!";
utgång (1);
// Initiera empObj_W
empObj_W.emp_id = 1512;
// Skriv till filen
binOutFile_Handler.skriv ((char *) & empObj_W, sizeof (anställd));
binOutFile_Handler.stänga();
om(!binOutFile_Handler.Bra())
cout << "Error occured during writing the binary file!" << endl;
utgång (2);
// Nu ska vi läsa medarbetaren.dat-fil
binInFile_Handler.öppen ("Anställd.dat ", ios :: i | ios :: binärt);
// Kontrollera om filen har öppnats
om(!binInFile_Handler)
cout << "File did not open!";
utgång (3);
// Läs innehållet i den binära filen
binInFile_Handler.läs ((char *) & empObj_R, sizeof (anställd));
binInFile_Handler.stänga();
om(!binInFile_Handler.Bra())
cout << "Error occured during reading the binary file!" << endl;
utgång (4);
// Skriv ut utdata från empObj_R
cout << "Details of the Employee : " << endl;
cout << "Employee ID : " << empObj_R.emp_id << endl;
returnera 0;
Slutsats
Filer används främst för att lagra data, och de spelar en viktig roll i verklig programmering. I den här artikeln visade vi dig hur du använder olika filåtgärder med programmeringsspråket C ++ genom att arbeta igenom flera exempel. Dessutom visade vi dig hur du läser och skriver data i både textfiler och binära filer.
