Selles artiklis näitame teile, kuidas lugeda ja kirjutada C ++ programmeerimiskeeles faili, kasutades mitmeid näiteid. Et mõista C ++ failitoiminguid, nagu lugemine ja kirjutamine, peame kõigepealt mõistma voo mõistet C ++ -is.
Mis on voog?
Oja on lihtsalt andmete või märkide voog. Ohte on kahte tüüpi: sisendvoog ja väljundvoog. Sisendvoogu kasutatakse andmete lugemiseks välisest sisendseadmest, näiteks klaviatuurilt, väljundvoogu aga andmete kirjutamiseks välisele väljundseadmele, näiteks monitorile. Faili võib pidada nii sisend- kui ka väljundallikaks.
C ++ puhul kasutame voogu, et saata või vastu võtta andmeid välisallikast või sealt.
Sisend-/väljundvoole, s.o ios, pääsemiseks saame kasutada sisseehitatud klasse.
Siin on C ++ programmeerimiskeele vooklasside hierarhia:
Cin ja cout objekte kasutatakse andmete lugemiseks klaviatuurilt ja väljundi kuvamiseks vastavalt monitorile. Lisaks kasutatakse failivoolu andmevoo lugemiseks ifstream, mis tähistab sisendfailivoogu, ja andmevoo failiks kirjutamiseks ofstream, mis tähistab väljundfaili voogu.
Fail iostram.h sisaldab kõiki nõutavaid standardseid sisend-/väljundvoo klasse C ++ programmeerimiskeeles.
Näited
Nüüd, kui saate aru voogude põhitõdedest, arutame järgmisi näiteid, mis aitavad teil C ++ failitoiminguid paremini mõista:
- Näide 1: faili avamine ja sulgemine
- Näide 2: Kirjutage faili
- Näide 3: lugege failist
- Näide 4: lugege ja kirjutage faili
- Näide 5: lugege ja kirjutage binaarfaili
Näide 1: faili avamine ja sulgemine
Selles näidisprogrammis demonstreerime, kuidas faili avada/luua ja faili C ++ sulgeda. Nagu näete allolevas programmis, oleme lisanud failitoimingute jaoks vajaliku kogu.
Faili avamiseks ja sulgemiseks vajame objekti ofstream. Seejärel peame faili lugemiseks või sinna kirjutamiseks faili avama. Oleme lisanud fstream päisefaili reale number 1, et pääseda juurde voolu klassile.
Oleme kuulutanud myFile_Handler põhifunktsiooni sees voolu objektiks. Seejärel saame tühja faili loomiseks kasutada funktsiooni open () ja faili sulgemiseks funktsiooni close ().
#kaasakekasutades nimeruumtundi;
intpeamine()
{
offstream myFile_Handler;
// Fail avatud
myFile_Handler.lahti(„File_1.txt”);
// Fail Sulge
myFile_Handler.Sulge();
tagasi 0;
}
Nüüd koostame programmi ja uurime väljundit. Nagu näete alloleval väljundaknal, loodi fail File_1.txt pärast programmi käivitamist. Faili suurus on null, kuna me ei ole faili sisu kirjutanud.
Näide 2: Kirjutage faili
Eelmises näidisprogrammis näitasime teile, kuidas faili avada ja kuidas faili sulgeda. Nüüd näitame teile, kuidas faili midagi kirjutada.
Võime faili kirjutada voo sisestamise operaatori abil, st<<. 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.
#kaasakekasutades nimeruumtundi;
intpeamine()
{
offstream myFile_Handler;
// Fail avatud
myFile_Handler.lahti(„File_1.txt”);
// Kirjutage faili
myFile_Handler<< 'See on proovifaili näidis. ' <<endl;
myFile_Handler<< 'See on faili teine rida. ' <<endl;
// Fail Sulge
myFile_Handler.Sulge();
tagasi 0;
}
Nüüd koostame ülaltoodud programmi ja käivitame selle. Nagu näete allpool, oleme edukalt kirjutanud faili File_1.txt.
Näide 3: lugege failist
Eelmistes näidetes näitasime teile, kuidas faili faili kirjutada. Nüüd loeme näites 2 loodud faili failist sisu ja kuvame selle tavalisel väljundseadmel, st monitoril.
Me kasutame funktsiooni getline (), et lugeda failist kogu rida ja seejärel cout, et printida rida monitorile.
#kaasake#kaasake
#kaasake
kasutades nimeruumtundi;
intpeamine()
{
ifstream myFile_Handler;
string myLine;
// Fail on avatud lugemisrežiimis
myFile_Handler.lahti(„File_1.txt”);
kui(myFile_Handler.on avatud())
{
// Jätkake faili lugemist
samas(getline(myFile_Handler, myLine))
{
// prindi rida standardväljundile
maksma <<myLine<<endl;
}
// Fail Sulge
myFile_Handler.Sulge();
}
muidu
{
maksma << 'Faili ei saa avada!';
}
tagasi 0;
}
Nüüd prindime faili_1.txt sisu järgmise käsuga: cat File_1.txt. Kui oleme programmi koostanud ja käivitanud, on selge, et väljund vastab faili sisule. Seetõttu oleme faili edukalt läbi lugenud ja faili sisu monitorile printinud.
Näide 4: lugege ja kirjutage faili
Siiani oleme näidanud, kuidas faili avada, lugeda, kirjutada ja sulgeda. C ++ - s saame ka faili korraga lugeda ja kirjutada. Faili lugemiseks ja kirjutamiseks peame hankima fstream -objekti ja avama faili režiimis ios :: in ja ios :: out.
Selles näites kirjutame faili kõigepealt sisu. Seejärel loeme failist saadud andmed ja prindime need monitorile.
#kaasake#kaasake
#kaasake
kasutades nimeruumtundi;
intpeamine()
{
fstream myFile_Handler;
string myLine;
// Fail avatud
myFile_Handler.lahti(„File_1.txt”, ios::sisse |ios::välja);
// Kontrollige, kas fail on avatud
kui(!myFile_Handler)
{
maksma << 'Fail ei avane!';
väljumine(1);
}
// Kirjutage faili
myFile_Handler<< „1. See on veel üks proovifaili näidis. ' <<endl;
myFile_Handler<< „2. See on faili teine rida. ' <<endl;
myFile_Handler.otsima(ios::paluma);
// Loe faili
kui(myFile_Handler.on avatud())
{
// Jätkake faili lugemist
samas(getline(myFile_Handler, myLine))
{
// prindi rida standardväljundile
maksma <<myLine<<endl;
}
// Fail Sulge
myFile_Handler.Sulge();
}
muidu
{
maksma << 'Faili ei saa avada!';
}
myFile_Handler.Sulge();
tagasi 0;
}
Nüüd koostame ja käivitame programmi.
Näide 5: lugege ja kirjutage binaarfaili
Selles näites deklareerime klassi ja kirjutame objekti seejärel binaarfaili. Selle näite lihtsustamiseks oleme deklareerinud klassi Töötaja avaliku muutujaga emp_id. Seejärel loeme binaarfaili ja prindime väljundi monitorile.
#kaasake#kaasake
kasutades nimeruumtundi;
klassiTöötaja
{
avalik:
intemp_id;
};
intpeamine()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Töötaja empObj_W, empObj_R;
// Fail avatud
binOutFile_Handler.lahti('töötaja.andmed', ios::välja |ios::binaarne);
// Kontrollige, kas fail on avatud
kui(!binOutFile_Handler)
{
maksma << 'Fail ei avane!';
väljumine(1);
}
// Initsialiseeri empObj_W
empObj_W.emp_id = 1512;
// Kirjutage faili
binOutFile_Handler.kirjutada((süsi *) &empObj_W,suurus(Töötaja));
binOutFile_Handler.Sulge();
kui(!binOutFile_Handler.hea())
{
maksma << 'Binaarfaili kirjutamisel ilmnes viga!' <<endl;
väljumine(2);
}
// Nüüd loeme faili töötaja.dat
binInFile_Handler.lahti('töötaja.andmed', ios::sisse |ios::binaarne);
// Kontrollige, kas fail on avatud
kui(!binInFile_Handler)
{
maksma << 'Fail ei avane!';
väljumine(3);
}
// Binaarfaili sisu lugemine
binInFile_Handler.loe((süsi *) &empObj_R,suurus(Töötaja));
binInFile_Handler.Sulge();
kui(!binInFile_Handler.hea())
{
maksma << 'Binaarfaili lugemisel ilmnes viga!' <<endl;
väljumine(4);
}
// Prindi empObj_R väljund
maksma << 'Töötaja andmed:' <<endl;
maksma << 'Töötaja ID : ' <<empObj_R.emp_id <<endl;
tagasi 0;
}
Järeldus
Faile kasutatakse peamiselt andmete salvestamiseks ja neil on oluline roll reaalses programmeerimises. Selles artiklis näitasime teile mitmeid näiteid, kuidas C ++ programmeerimiskeelega erinevaid failitoiminguid kasutada. Lisaks näitasime teile, kuidas lugeda ja kirjutada andmeid nii teksti- kui ka binaarfailidesse.