I den här artikeln kommer vi att visa dig hur du läser och skriver till en fil i programmeringsspråket C ++ med hjälp av flera exempel. För att förstå C ++ - filoperationer som att läsa och skriva måste vi först förstå konceptet med 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: inmatningsströmmar och utmatningsströmmar. En ingångsström används för att läsa data från en extern inmatningsenhet, t.ex. ett tangentbord, medan en utmatningsström används för att skriva data till den externa utmatningsenheten, till exempel en bildskärm. En fil kan betraktas som både en ingångs- 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 input/output-ström, dvs ios.
Här är strömklasshierarkin för programmeringsspråket C ++:
Cin- och cout -objekten används för att läsa data från tangentbordet respektive för att visa utdata på monitorn. Dessutom används ifstream, som står för inmatningsfilström, för att läsa en dataström från en fil, och ofstream, som står för utdatafilström, används för att skriva en dataström till en fil.
Filen iostram.h innehåller alla nödvändiga standardinmatning/utdataströmsklasser i programmeringsspråket C ++.
Exempel
Nu när du förstår grunderna i strömmar kommer vi att diskutera följande exempel för att hjälpa dig att bättre förstå filoperationer 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 av ofstream. För att läsa eller skriva till en fil måste vi öppna filen. Vi har inkluderat fstream-header-filen på rad nummer 1 så att vi kan komma åt ofstream-klassen.
Vi har deklarerat en myFile_Handler som ett objekt för strömmen i 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 sig av namnrymdtimmar;
inthuvud()
{
ofstream myFile_Handler;
// Filöppen
myFile_Handler.öppen('File_1.txt');
// File Close
myFile_Handler.stänga();
lämna tillbaka 0;
}
Nu kommer vi att sammanställa programmet och undersöka resultatet. Som du kan se i utmatningsfönstret nedan skapades File_1.txt -filen efter att programmet körts. 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 kommer vi att visa dig hur du skriver något i en fil.
Vi kan skriva till en fil med hjälp av operatören för infogning av ström, 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.
#omfattaanvänder sig av namnrymdtimmar;
inthuvud()
{
ofstream myFile_Handler;
// Filöppen
myFile_Handler.öppen('File_1.txt');
// Skriv till filen
myFile_Handler<< 'Detta är en provtestfil. ' <<endl;
myFile_Handler<< 'Detta är den andra raden i filen. ' <<endl;
// File Close
myFile_Handler.stänga();
lämna tillbaka 0;
}
Nu kommer vi att sammanställa ovanstående program och köra det. Som du kan se nedan har vi framgångsrikt skrivit till filen File_1.txt.
Exempel 3: Läs från en fil
I de tidigare 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, det vill säga bildskärmen.
Vi använder funktionen getline () för att läsa hela raden från filen och sedan skriva ut raden på monitorn.
#omfatta#omfatta
#omfatta
använder sig av namnrymdtimmar;
inthuvud()
{
ifstream myFile_Handler;
string myLine;
// Filöppen i läsläget
myFile_Handler.öppen('File_1.txt');
om(myFile_Handler.är öppen())
{
// Fortsätt läsa filen
medan(getline(myFile_Handler, myLine))
{
// skriv ut raden på standardutmatningen
kosta <<myLine<<endl;
}
// File Close
myFile_Handler.stänga();
}
annan
{
kosta << 'Det gick inte att öppna filen!';
}
lämna tillbaka 0;
}
Nu kommer vi att skriva ut innehållet i File_1.txt med följande kommando: cat File_1.txt. När vi väl har sammanställt och kört programmet är det klart att utmatningen matchar innehållet i filen. Därför har vi läst filen och skrivit ut filens innehåll till bildskärmen.
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 skaffa ett fstream -objekt och öppna filen i ios :: in och ios :: out -läge.
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 dem till bildskärmen.
#omfatta#omfatta
#omfatta
använder sig av namnrymdtimmar;
inthuvud()
{
fstream myFile_Handler;
string myLine;
// Filöppen
myFile_Handler.öppen('File_1.txt', ios::i |ios::ut);
// Kontrollera om filen har öppnats
om(!myFile_Handler)
{
kosta << 'Filen öppnades inte!';
utgång(1);
}
// Skriv till filen
myFile_Handler<< '1. Detta är en annan provtestfil. ' <<endl;
myFile_Handler<< '2. Detta är den andra raden i filen. ' <<endl;
myFile_Handler.sök(ios::tigga);
// Läs filen
om(myFile_Handler.är öppen())
{
// Fortsätt läsa filen
medan(getline(myFile_Handler, myLine))
{
// skriv ut raden på standardutmatningen
kosta <<myLine<<endl;
}
// File Close
myFile_Handler.stänga();
}
annan
{
kosta << 'Det gick inte att öppna filen!';
}
myFile_Handler.stänga();
lämna tillbaka 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 kommer vi att deklarera en klass och sedan skriva objektet till en binär fil. För att förenkla detta exempel har vi deklarerat Employee -klassen med en offentlig variabel emp_id. Sedan läser vi den binära filen och skriver ut utmatningen till bildskärmen.
#omfatta#omfatta
använder sig av namnrymdtimmar;
klassAnställd
{
offentlig:
intemp_id;
};
inthuvud()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Anställd empObj_W, empObj_R;
// Filöppen
binOutFile_Handler.öppen('medarbetare.dat', ios::ut |ios::binär);
// Kontrollera om filen har öppnats
om(!binOutFile_Handler)
{
kosta << 'Filen öppnades inte!';
utgång(1);
}
// Initiera empObj_W
empObj_W.emp_id = 1512;
// Skriv till filen
binOutFile_Handler.skriva((röding *) &empObj_W,storlek av(Anställd));
binOutFile_Handler.stänga();
om(!binOutFile_Handler.Bra())
{
kosta << 'Ett fel uppstod när den binära filen skrevs!' <<endl;
utgång(2);
}
// Låt oss nu läsa filen employee.dat
binInFile_Handler.öppen('medarbetare.dat', ios::i |ios::binär);
// Kontrollera om filen har öppnats
om(!binInFile_Handler)
{
kosta << 'Filen öppnades inte!';
utgång(3);
}
// Läs innehållet i den binära filen
binInFile_Handler.läsa((röding *) &empObj_R,storlek av(Anställd));
binInFile_Handler.stänga();
om(!binInFile_Handler.Bra())
{
kosta << 'Ett fel uppstod vid läsning av den binära filen!' <<endl;
utgång(4);
}
// Skriv ut utmatningen av empObj_R
kosta << 'Uppgifter om den anställde:' <<endl;
kosta << 'Anställnings-ID : ' <<empObj_R.emp_id <<endl;
lämna tillbaka 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 filoperationer 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.