Ebben a cikkben több példa segítségével megmutatjuk, hogyan kell olvasni és írni egy fájlba a C ++ programozási nyelven. Ahhoz, hogy megértsük a C ++ fájlműveleteket, például az olvasást és az írást, először meg kell értenünk a folyam fogalmát a C ++ nyelven.
Mi az a Stream?
A folyam egyszerűen adat- vagy karakteráram. Kétféle adatfolyam létezik: bemeneti és kimeneti adatfolyam. A bemeneti adatfolyamot egy külső beviteli eszközről, például billentyűzetről származó adatok olvasására használjuk, míg a kimeneti adatfolyamot az adatok külső kimeneti eszközre, például monitorra történő írására. A fájlok mind bemeneti, mind kimeneti forrásnak tekinthetők.
A C ++ programban adatfolyamot használunk adatok küldésére vagy fogadására külső forrásból vagy onnan.
Beépített osztályokat használhatunk egy bemeneti/kimeneti adatfolyam eléréséhez, azaz ios.
Íme a C ++ programozási nyelv folyamosztály -hierarchiája:
A cin és a cout objektumok a billentyűzetről származó adatok kiolvasására és a kimenet megjelenítésére szolgálnak a monitoron. Ezenkívül az ifstream, amely a bemeneti fájlfolyamot jelenti, egy adatfolyam olvasására szolgál egy fájlból, és az ofstream, amely a kimeneti fájlfolyamot jelenti, az adatfolyam fájlba írására.
Az iostram.h fájl tartalmazza az összes szükséges szabványos bemeneti/kimeneti adatfolyam osztályt a C ++ programozási nyelven.
Példák
Most, hogy megértette a folyamok alapjait, a következő példákat tárgyaljuk, hogy jobban megértsük a C ++ fájlműveleteket:
- 1. példa: Fájl megnyitása és bezárása
- Példa 2: Írjon fájlba
- Példa 3: Olvasás fájlból
- Példa 4: Olvasás és írás fájlba
- 5. példa: Olvasás és írás bináris fájlba
1. példa: Fájl megnyitása és bezárása
Ebben a példaprogramban bemutatjuk, hogyan kell megnyitni/létrehozni egy fájlt, és hogyan kell bezárni a fájlt a C ++ nyelven. Amint az alábbi programban látható, beillesztettük a fájlműveletekhez szükséges könyvtárat.
Egy fájl megnyitásához és bezárásához szükségünk van egy ofstream objektumra. Ezután egy fájl olvasásához vagy írásához meg kell nyitnunk a fájlt. Az fstream fejlécfájlt az 1-es sorba illesztettük be, hogy hozzáférjünk az ofstream osztályhoz.
A myFile_Handler -t a fő funkció belsejében az áramlás objektumává nyilvánítottuk. Ezután az open () függvénnyel létrehozhatunk egy üres fájlt, a close () függvénnyel pedig bezárhatjuk a fájlt.
#befoglalnisegítségével névtérórák;
intfő-()
{
ofstream myFile_Handler;
// Fájl megnyitva
myFile_Handler.nyisd ki('File_1.txt');
// Fájl bezárása
myFile_Handler.Bezárás();
Visszatérés 0;
}
Most összeállítjuk a programot és megvizsgáljuk a kimenetet. Amint az alábbi kimeneti ablakban látható, a File_1.txt fájl a program végrehajtása után jött létre. A fájl mérete nulla, mivel nem írtunk semmilyen tartalmat a fájlba.
Példa 2: Írjon fájlba
Az előző példaprogramban megmutattuk, hogyan kell megnyitni egy fájlt, és hogyan kell bezárni. Most megmutatjuk, hogyan kell valamit írni egy fájlba.
Írhatunk egy fájlba a folyambeillesztő operátor használatával, azaz<<. 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.
#befoglalnisegítségével névtérórák;
intfő-()
{
ofstream myFile_Handler;
// Fájl megnyitva
myFile_Handler.nyisd ki('File_1.txt');
// Írjon a fájlba
myFile_Handler<< 'Ez egy minta tesztfájl. ' <<endl;
myFile_Handler<< - Ez a fájl második sora. ' <<endl;
// Fájl bezárása
myFile_Handler.Bezárás();
Visszatérés 0;
}
Most összeállítjuk a fenti programot és végrehajtjuk. Mint alább látható, sikeresen írtunk a File_1.txt fájlba.
Példa 3: Olvasás fájlból
Az előző példákban megmutattuk, hogyan kell tartalmat írni egy fájlba. Most olvassuk el a 2. példában létrehozott fájl tartalmát, és jelenítsük meg a tartalmat a szabványos kimeneti eszközön, azaz a monitoron.
A getline () függvény segítségével olvassuk ki a fájlból a teljes sort, majd a cout segítségével nyomtassuk ki a sort a monitoron.
#befoglalni#befoglalni
#befoglalni
segítségével névtérórák;
intfő-()
{
ifstream myFile_Handler;
karakterlánc myLine;
// Fájl Megnyitás olvasási módban
myFile_Handler.nyisd ki('File_1.txt');
ha(myFile_Handler.nyitva van())
{
// Olvassa tovább a fájlt
míg(getline(myFile_Handler, myLine))
{
// a sor nyomtatása a standard kimenetre
költség <<myLine<<endl;
}
// Fájl bezárása
myFile_Handler.Bezárás();
}
más
{
költség << 'Nem sikerült megnyitni a fájlt!';
}
Visszatérés 0;
}
Most kinyomtatjuk a File_1.txt tartalmát a következő paranccsal: cat File_1.txt. Miután összeállítottuk és végrehajtottuk a programot, egyértelmű, hogy a kimenet megfelel a fájl tartalmának. Ezért sikeresen elolvasta a fájlt, és kinyomtatta a fájl tartalmát a monitorra.
Példa 4: Olvasás és írás fájlba
Eddig megmutattuk, hogyan kell megnyitni, olvasni, írni és bezárni egy fájlt. A C ++ nyelvben egyszerre olvashatunk és írhatunk fájlba. Ahhoz, hogy egy fájlba olvassunk és írjunk, egy fstream objektumot kell beszereznünk, és ios :: in és ios :: out módban kell megnyitnunk a fájlt.
Ebben a példában először néhány tartalmat írunk a fájlba. Ezután kiolvassuk az adatokat a fájlból, és kinyomtatjuk a monitorra.
#befoglalni#befoglalni
#befoglalni
segítségével névtérórák;
intfő-()
{
fstream myFile_Handler;
karakterlánc myLine;
// Fájl megnyitva
myFile_Handler.nyisd ki('File_1.txt', ios::ban ben |ios::ki);
// Ellenőrizze, hogy a fájl megnyílt -e
ha(!myFile_Handler)
{
költség << 'A fájl nem nyílt meg!';
kijárat(1);
}
// Írjon a fájlba
myFile_Handler<< „1. Ez egy másik minta tesztfájl. ' <<endl;
myFile_Handler<< „2. Ez a fájl második sora. ' <<endl;
myFile_Handler.seekg(ios::könyörög);
// Olvassa el a fájlt
ha(myFile_Handler.nyitva van())
{
// Olvassa tovább a fájlt
míg(getline(myFile_Handler, myLine))
{
// a sor nyomtatása a standard kimenetre
költség <<myLine<<endl;
}
// Fájl bezárása
myFile_Handler.Bezárás();
}
más
{
költség << 'Nem sikerült megnyitni a fájlt!';
}
myFile_Handler.Bezárás();
Visszatérés 0;
}
Most összeállítjuk és végrehajtjuk a programot.
5. példa: Olvasás és írás bináris fájlba
Ebben a példában deklarálunk egy osztályt, majd írjuk az objektumot egy bináris fájlba. A példa egyszerűsítése érdekében az Employee osztályt az emp_id nyilvános változóval deklaráltuk. Ezután elolvassuk a bináris fájlt, és kinyomtatjuk a kimenetet a monitorra.
#befoglalni#befoglalni
segítségével névtérórák;
osztályMunkavállaló
{
nyilvános:
intemp_id;
};
intfő-()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Alkalmazott empObj_W, empObj_R;
// Fájl megnyitva
binOutFile_Handler.nyisd ki('alkalmazott.adat', ios::ki |ios::bináris);
// Ellenőrizze, hogy a fájl megnyílt -e
ha(!binOutFile_Handler)
{
költség << 'A fájl nem nyílt meg!';
kijárat(1);
}
// Az empObj_W inicializálása
empObj_W.emp_id = 1512;
// Írjon a fájlba
binOutFile_Handler.ír((char *) &empObj_W,mérete(Munkavállaló));
binOutFile_Handler.Bezárás();
ha(!binOutFile_Handler.jó())
{
költség << 'Hiba történt a bináris fájl írásakor!' <<endl;
kijárat(2);
}
// Most olvassuk el az alkalmazott.dat fájlt
binInFile_Handler.nyisd ki('alkalmazott.adat', ios::ban ben |ios::bináris);
// Ellenőrizze, hogy a fájl megnyílt -e
ha(!binInFile_Handler)
{
költség << 'A fájl nem nyílt meg!';
kijárat(3);
}
// Olvassa el a bináris fájl tartalmát
binInFile_Handler.olvas((char *) &empObj_R,mérete(Munkavállaló));
binInFile_Handler.Bezárás();
ha(!binInFile_Handler.jó())
{
költség << 'Hiba történt a bináris fájl olvasása közben!' <<endl;
kijárat(4);
}
// Az empObj_R kimenetének kinyomtatása
költség << 'A munkavállaló adatai:' <<endl;
költség << 'Munkavállalói azonosító : ' <<empObj_R.emp_id <<endl;
Visszatérés 0;
}
Következtetés
A fájlokat elsősorban az adatok tárolására használják, és fontos szerepet játszanak a valós programozásban. Ebben a cikkben számos példán keresztül bemutattuk, hogyan kell használni a különböző fájlműveleteket a C ++ programozási nyelvvel. Továbbá megmutattuk, hogyan kell adatokat olvasni és írni szöveges és bináris fájlokba.