Šajā rakstā mēs parādīsim, kā lasīt un rakstīt failā C ++ programmēšanas valodā, izmantojot vairākus piemērus. Lai saprastu C ++ failu darbības, piemēram, lasīšanu un rakstīšanu, mums vispirms ir jāsaprot straumes jēdziens C ++.
Kas ir straume?
Straume ir vienkārši datu vai rakstzīmju plūsma. Ir divu veidu straumes: ievades plūsmas un izejas plūsmas. Ievades plūsma tiek izmantota, lai nolasītu datus no ārējas ievades ierīces, piemēram, tastatūras, savukārt izejas plūsma tiek izmantota, lai ierakstītu datus ārējā izvadierīcē, piemēram, monitorā. Failu var uzskatīt gan par ievades, gan izvades avotu.
C ++ mēs izmantojam straumi, lai nosūtītu vai saņemtu datus uz ārēju avotu vai no tā.
Mēs varam izmantot iebūvētās klases, lai piekļūtu ievades/izvades straumei, t.i., ios.
Šeit ir C ++ programmēšanas valodas straumes klases hierarhija:
Cin un cout objekti tiek izmantoti, lai nolasītu datus no tastatūras un attiecīgi parādītu izvadi monitorā. Turklāt ifstream, kas apzīmē ievades failu plūsmu, tiek izmantots, lai nolasītu datu plūsmu no faila, un ofstream, kas apzīmē izejas failu straumi, tiek izmantots, lai ierakstītu failā datu plūsmu.
Fails iostram.h satur visas nepieciešamās standarta ievades/izvades plūsmas klases C ++ programmēšanas valodā.
Piemēri
Tagad, kad jūs saprotat straumju pamatus, mēs apspriedīsim šādus piemērus, lai palīdzētu jums labāk izprast failu darbības C ++:
- 1. piemērs: atveriet un aizveriet failu
- 2. piemērs: rakstiet failā
- 3. piemērs: lasiet no faila
- 4. piemērs: lasiet un ierakstiet failā
- 5. piemērs: lasiet un rakstiet binārajā failā
1. piemērs: atveriet un aizveriet failu
Šajā programmas paraugā mēs parādīsim, kā atvērt/izveidot failu un kā aizvērt failu C ++. Kā redzat zemāk esošajā programmā, mēs esam iekļāvuši bibliotēku, kas nepieciešama failu operācijām.
Lai atvērtu un aizvērtu failu, mums ir nepieciešams straumes objekts. Pēc tam, lai lasītu vai rakstītu failā, mums tas ir jāatver. Mēs esam iekļāvuši fstream galvenes failu rindas numurā 1, lai mēs varētu piekļūt straumes klasei.
Mēs esam deklarējuši myFile_Handler kā plūsmas objektu galvenajā funkcijā. Pēc tam mēs varam izmantot funkciju open (), lai izveidotu tukšu failu, un close () funkciju, lai aizvērtu failu.
#iekļautizmantojot vārda telpastundas;
intgalvenais()
{
no straumes myFile_Handler;
// Fails atvērts
myFile_Handler.atvērts('File_1.txt');
// Fails Aizvērt
myFile_Handler.aizvērt();
atgriezties 0;
}
Tagad mēs apkoposim programmu un pārbaudīsim rezultātu. Kā redzat izvades logā zemāk, fails File_1.txt tika izveidots pēc programmas izpildes. Faila lielums ir nulle, jo failā neesam ierakstījuši nekādu saturu.
2. piemērs: rakstiet failā
Iepriekšējā piemēra programmā mēs parādījām, kā atvērt failu un kā to aizvērt. Tagad mēs parādīsim, kā kaut ko ierakstīt failā.
Mēs varam rakstīt failā, izmantojot straumes ievietošanas operatoru, t.i.<<. 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.
#iekļautizmantojot vārda telpastundas;
intgalvenais()
{
no straumes myFile_Handler;
// Fails atvērts
myFile_Handler.atvērts('File_1.txt');
// Rakstiet failā
myFile_Handler<< 'Šis ir pārbaudes faila paraugs. ' <<endl;
myFile_Handler<< 'Šī ir faila otrā rinda. ' <<endl;
// Fails Aizvērt
myFile_Handler.aizvērt();
atgriezties 0;
}
Tagad mēs apkoposim iepriekš minēto programmu un izpildīsim to. Kā redzat zemāk, mēs esam veiksmīgi ierakstījuši failā File_1.txt.
3. piemērs: lasiet no faila
Iepriekšējos piemēros mēs parādījām, kā rakstīt saturu failā. Tagad lasīsim saturu no faila, ko izveidojām 2. piemērā, un parādīsim saturu standarta izvadierīcē, ti, monitorā.
Mēs izmantojam funkciju getline (), lai nolasītu visu rindu no faila, un pēc tam cout, lai drukātu līniju monitorā.
#iekļaut#iekļaut
#iekļaut
izmantojot vārda telpastundas;
intgalvenais()
{
ifstream myFile_Handler;
virkne myLine;
// Fails atvērts lasīšanas režīmā
myFile_Handler.atvērts('File_1.txt');
ja(myFile_Handler.is_open())
{
// Turpiniet lasīt failu
kamēr(getline(myFile_Handler, myLine))
{
// izdrukāt rindu uz standarta izvadi
izmaksas <<myLine<<endl;
}
// Fails Aizvērt
myFile_Handler.aizvērt();
}
citādi
{
izmaksas << 'Nevar atvērt failu!';
}
atgriezties 0;
}
Tagad mēs izdrukāsim File_1.txt saturu, izmantojot šādu komandu: cat File_1.txt. Kad mēs apkopojam un izpildām programmu, ir skaidrs, ka izvade atbilst faila saturam. Tāpēc mēs esam veiksmīgi izlasījuši failu un monitoram izdrukājuši faila saturu.
4. piemērs: lasiet un ierakstiet failā
Līdz šim mēs parādījām, kā atvērt, lasīt, rakstīt un aizvērt failu. Izmantojot C ++, vienlaikus varam arī lasīt un rakstīt failā. Lai gan lasītu, gan rakstītu failā, mums ir jāiegūst fstream objekts un jāatver fails režīmā ios :: in un ios :: out.
Šajā piemērā mēs vispirms ierakstām failā kādu saturu. Pēc tam mēs nolasām datus no faila un izdrukājam tos monitorā.
#iekļaut#iekļaut
#iekļaut
izmantojot vārda telpastundas;
intgalvenais()
{
fstream myFile_Handler;
virkne myLine;
// Fails atvērts
myFile_Handler.atvērts('File_1.txt', ios::iekšā |ios::ārā);
// Pārbaudiet, vai fails ir atvērts
ja(!myFile_Handler)
{
izmaksas << 'Fails netika atvērts!';
Izeja(1);
}
// Rakstiet failā
myFile_Handler<< “1. Šis ir vēl viens pārbaudes faila paraugs. ' <<endl;
myFile_Handler<< “2. Šī ir faila otrā rinda. ' <<endl;
myFile_Handler.meklēt(ios::ubagot);
// Lasīt failu
ja(myFile_Handler.is_open())
{
// Turpiniet lasīt failu
kamēr(getline(myFile_Handler, myLine))
{
// izdrukāt rindu uz standarta izvadi
izmaksas <<myLine<<endl;
}
// Fails Aizvērt
myFile_Handler.aizvērt();
}
citādi
{
izmaksas << 'Nevar atvērt failu!';
}
myFile_Handler.aizvērt();
atgriezties 0;
}
Tagad mēs apkoposim un izpildīsim programmu.
5. piemērs: lasiet un rakstiet binārajā failā
Šajā piemērā mēs deklarēsim klasi un pēc tam ierakstīsim objektu binārā failā. Lai vienkāršotu šo piemēru, esam deklarējuši darbinieku klasi ar publisku mainīgo emp_id. Pēc tam mēs nolasīsim bināro failu un izdrukāsim izvadi monitorā.
#iekļaut#iekļaut
izmantojot vārda telpastundas;
klaseDarbinieks
{
publiski:
intemp_id;
};
intgalvenais()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Darbinieku empObj_W, empObj_R;
// Fails atvērts
binOutFile_Handler.atvērts('darbinieks.dat', ios::ārā |ios::binārs);
// Pārbaudiet, vai fails ir atvērts
ja(!binOutFile_Handler)
{
izmaksas << 'Fails netika atvērts!';
Izeja(1);
}
// Inicializēt empObj_W
empObj_W.emp_id = 1512;
// Rakstiet failā
binOutFile_Handler.rakstīt((char *) &empObj_W,izmērs(Darbinieks));
binOutFile_Handler.aizvērt();
ja(!binOutFile_Handler.labi())
{
izmaksas << 'Rakstot bināro failu, radās kļūda!' <<endl;
Izeja(2);
}
// Tagad lasīsim failu.dat
binInFile_Handler.atvērts('darbinieks.dat', ios::iekšā |ios::binārs);
// Pārbaudiet, vai fails ir atvērts
ja(!binInFile_Handler)
{
izmaksas << 'Fails netika atvērts!';
Izeja(3);
}
// Lasīt binārā faila saturu
binInFile_Handler.lasīt((char *) &empObj_R,izmērs(Darbinieks));
binInFile_Handler.aizvērt();
ja(!binInFile_Handler.labi())
{
izmaksas << 'Lasot bināro failu, radās kļūda!' <<endl;
Izeja(4);
}
// Izdrukāt empObj_R izvadi
izmaksas << 'Informācija par darbinieku:' <<endl;
izmaksas << 'Darbinieka ID : ' <<empObj_R.emp_id <<endl;
atgriezties 0;
}
Secinājums
Faili galvenokārt tiek izmantoti datu glabāšanai, un tiem ir svarīga loma reālās pasaules programmēšanā. Šajā rakstā mēs parādījām, kā izmantot dažādas failu darbības ar C ++ programmēšanas valodu, izmantojot vairākus piemērus. Turklāt mēs parādījām, kā lasīt un ierakstīt datus gan teksta failos, gan bināros failos.