Phenquestions
Š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 straumes un izvades straumes. Ievades straumi izmanto, lai nolasītu datus no ārējas ievades ierīces, piemēram, tastatūras, savukārt izvades straumi izmanto, lai ierakstītu datus ārējā izvades ierīcē, piemēram, monitorā. Failu var uzskatīt gan par ievades, gan izvades avotu.
Programmā 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.e., “Ios”.
Šeit ir C ++ programmēšanas valodas plūsmas klases hierarhija:
Objektus “cin” un “cout” izmanto, lai attiecīgi nolasītu datus no tastatūras un parādītu izvadi uz monitora. Turklāt “ifstream”, kas nozīmē “ievades failu straume”, tiek izmantots, lai nolasītu datu plūsmu no faila, un “ofstream”, kas nozīmē “izvades failu straume”, tiek izmantots, lai rakstītu datu straumi. uz failu.
“Iostram.h ”fails satur visas nepieciešamās standarta ievades / izvades straumes klases C ++ programmēšanas valodā.
Piemēri
Tagad, kad jūs saprotat plūsmu 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: rakstīšana failā
- 3. piemērs: lasīšana no faila
- 4. piemērs: lasīšana un rakstīšana failā
- 5. piemērs: binārā faila lasīšana un rakstīšana
1. piemērs: atveriet un aizveriet failu
Šajā programmas piemērā 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 darbībām.
Lai atvērtu un aizvērtu failu, mums ir nepieciešams straumes objekts. Tad, lai lasītu vai rakstītu failā, mums ir jāatver fails. Mēs esam iekļāvuši straumes galvenes failu rindā numur-1, lai mēs varētu piekļūt straumes klasei.
Mēs esam pasludinājuši myFile_Handler par straumes objektu galvenās funkcijas iekšpusē. Pēc tam mēs varam izmantot funkciju open (), lai izveidotu tukšu failu, un aizvēršanas () funkciju, lai aizvērtu failu.
# iekļautizmantojot nosaukumvietu std;
int main ()
no plūsmas myFile_Handler;
// Fails atvērts
myFile_Handler.atvērt ("Fails_1.txt ");
// Fails Aizvērt
myFile_Handler.aizvērt ();
atgriešanās 0;
Tagad mēs apkoposim programmu un pārbaudīsim rezultātu. Kā redzat zemāk esošajā izvades logā, “File_1.txt ”fails tika izveidots pēc programmas izpildes. Faila lielums ir nulle, jo failā nav ierakstīts saturs.
2. piemērs: rakstīšana failā
Iepriekšējā paraugprogrammā mēs parādījām, kā atvērt failu un kā aizvērt failu. Tagad mēs parādīsim, kā kaut ko ierakstīt failā.
Mēs varam rakstīt failā, izmantojot straumes ievietošanas operatoru, t.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.
# iekļautizmantojot nosaukumvietu std;
int main ()
no plūsmas myFile_Handler;
// Fails atvērts
myFile_Handler.atvērt ("Fails_1.txt ");
// Rakstiet failā
myFile_Handler << "This is a sample test File. " << endl;
myFile_Handler << "This is the second line of the file. " << endl;
// Fails Aizvērt
myFile_Handler.aizvērt ();
atgriešanās 0;
Tagad mēs apkoposim iepriekš minēto programmu un izpildīsim to. Kā redzat zemāk, mēs esam veiksmīgi rakstījuši failā File_1.txt.
3. piemērs: lasīšana no faila
Iepriekšējos piemēros mēs parādījām, kā rakstīt saturu failā. Tagad lasīsim saturu no faila, kuru izveidojām 2. piemērā, un parādīsim saturu standarta izvades ierīcē, t.e., monitors.
Mēs izmantojam funkciju getline (), lai no faila nolasītu visu rindu un pēc tam “cout”, lai drukātu līniju monitorā.
# iekļaut# iekļaut
# iekļaut
izmantojot nosaukumvietu std;
int main ()
ifstream myFile_Handler;
virkne myLine;
// Fails tiek atvērts lasīšanas režīmā
myFile_Handler.atvērt ("Fails_1.txt ");
ja (myFile_Handler.is_open ()
// Turpiniet lasīt failu
while (getline (myFile_Handler, myLine))
// izdrukājiet līniju uz standarta izejas
cout << myLine << endl;
// Fails Aizvērt
myFile_Handler.aizvērt ();
cits
cout << "Unable to open the file!";
atgriešanās 0;
Tagad mēs izdrukāsim File_1 saturu.txt, izmantojot šādu komandu: cat File_1.txt. Kad mēs esam apkopojuši un izpildījuši programmu, ir skaidrs, ka izvade atbilst faila saturam. Tāpēc mēs esam veiksmīgi izlasījuši failu un izdrukājuši faila saturu monitorā.
4. piemērs: lasīšana un rakstīšana failā
Līdz šim mēs esam parādījuši, kā atvērt, lasīt, rakstīt un aizvērt failu. Programmā C ++ mēs 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ā vispirms failā ierakstām 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 nosaukumvietu std;
int main ()
fstream myFile_Handler;
virkne myLine;
// Fails atvērts
myFile_Handler.atvērt ("Fails_1.txt ", ios :: in | ios :: out);
// Pārbaudiet, vai fails ir atvērts
ja (!myFile_Handler)
cout << "File did not open!";
izeja (1);
// Rakstiet failā
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);
// Izlasiet failu
ja (myFile_Handler.is_open ()
// Turpiniet lasīt failu
while (getline (myFile_Handler, myLine))
// izdrukājiet līniju uz standarta izejas
cout << myLine << endl;
// Fails Aizvērt
myFile_Handler.aizvērt ();
cits
cout << "Unable to open the file!";
myFile_Handler.aizvērt ();
atgriešanās 0;
Tagad mēs apkoposim un izpildīsim programmu.
5. piemērs: binārā faila lasīšana un rakstīšana
Šajā piemērā mēs deklarēsim klasi un pēc tam objektu ierakstīsim binārā failā. Lai vienkāršotu šo piemēru, mēs esam deklarējuši darbinieku klasi ar publisku mainīgo emp_id. Tad mēs nolasīsim bināro failu un izdrukāsim izvadi monitorā.
# iekļaut# iekļaut
izmantojot nosaukumvietu std;
klases Darbinieks
publiski:
int emp_id;
;
int main ()
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Darbinieks empObj_W, empObj_R;
// Fails atvērts
binOutFile_Handler.atvērts ("Darbinieks.dat ", ios :: out | ios :: binārs);
// Pārbaudiet, vai fails ir atvērts
ja (!binOutFile_Handler)
cout << "File did not open!";
izeja (1);
// Inicializējiet empObj_W
empObj_W.emp_id = 1512;
// Rakstiet failā
binOutFile_Handler.rakstīt ((char *) & empObj_W, sizeof (Darbinieks));
binOutFile_Handler.aizvērt ();
ja (!binOutFile_Handler.labi ())
cout << "Error occured during writing the binary file!" << endl;
izeja (2);
// Tagad lasīsim darbinieku.dat fails
binInFile_Handler.atvērts ("Darbinieks.dat ", ios :: in | ios :: binārs);
// Pārbaudiet, vai fails ir atvērts
ja (!binInFile_Handler)
cout << "File did not open!";
izeja (3);
// Izlasiet binārā faila saturu
binInFile_Handler.lasīt ((char *) & empObj_R, sizeof (Darbinieks));
binInFile_Handler.aizvērt ();
ja (!binInFile_Handler.labs ())
cout << "Error occured during reading the binary file!" << endl;
izeja (4);
// Izdrukājiet empObj_R izvadi
cout << "Details of the Employee : " << endl;
cout << "Employee ID : " << empObj_R.emp_id << endl;
atgriešanās 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, izskatot vairākus piemērus. Turklāt mēs parādījām, kā lasīt un rakstīt datus gan teksta failos, gan bināros failos.
