Sa artikulong ito, ipapakita namin sa iyo kung paano magbasa at sumulat sa isang file sa C ++ na wika ng programa sa pamamagitan ng paggamit ng maraming mga halimbawa. Upang maunawaan ang mga pagpapatakbo ng C ++ file tulad ng pagbasa at pagsulat, dapat muna nating maunawaan ang konsepto ng isang stream sa C ++.
Ano ang isang Stream?
Ang isang stream ay simpleng daloy ng data o mga character. Mayroong dalawang uri ng mga stream: input stream at output stream. Ginagamit ang isang input stream upang basahin ang data mula sa isang panlabas na aparato ng pag-input tulad ng isang keyboard, habang ginagamit ang isang stream ng output upang magsulat ng data sa panlabas na aparato ng output tulad ng isang monitor. Ang isang file ay maaaring isaalang-alang bilang parehong isang mapagkukunan ng pag-input at output.
Sa C ++, gumagamit kami ng isang stream upang magpadala o tumanggap ng data sa o mula sa isang panlabas na mapagkukunan.
Maaari kaming gumamit ng mga built-in na klase upang ma-access ang isang input / output stream, ibig sabihin, ios.
Narito ang hierarchy ng klase ng stream ng wika ng pagprograma ng C ++:
Ang mga cin at cout na bagay ay ginagamit upang basahin ang data mula sa keyboard at upang ipakita ang output sa monitor, ayon sa pagkakabanggit. Bilang karagdagan, ang ifstream, na nangangahulugang input file stream, ay ginagamit upang basahin ang isang stream ng data mula sa isang file, at ang ofstream, na nangangahulugang output stream ng file, ay ginagamit upang sumulat ng isang stream ng data sa isang file.
Naglalaman ang file na iostram.h ng lahat ng kinakailangang karaniwang mga klase ng input / output stream sa wika ng pagprograma ng C ++.
Mga halimbawa
Ngayon na naiintindihan mo ang mga pangunahing kaalaman sa mga stream, tatalakayin namin ang mga sumusunod na halimbawa upang matulungan kang higit na maunawaan ang mga pagpapatakbo ng file sa C ++:
- Halimbawa 1: Buksan at Isara ang isang File
- Halimbawa 2: Sumulat sa isang File
- Halimbawa 3: Basahin mula sa isang File
- Halimbawa 4: Basahin at Sumulat sa isang File
- Halimbawa 5: Basahin at Sumulat sa isang Binary File
Halimbawa 1: Buksan at Isara ang isang File
Sa halimbawang programa na ito, ipapakita namin kung paano buksan / lumikha ng isang file at kung paano isara ang file sa C ++. Tulad ng nakikita mo sa program sa ibaba, isinama namin ang aklatan na kinakailangan para sa pagpapatakbo ng file.
Upang buksan at isara ang isang file, kailangan namin ng isang bagay ng daloy ng agos. Pagkatapos, upang mabasa o sumulat sa isang file, kailangan nating buksan ang file. Isinama namin ang file ng fstream header sa linya numero-1 upang ma-access namin ang ofstream na klase.
Kami ay idineklara ng isang myFile_Handler bilang isang bagay ng daloy ng daloy ng loob ng pangunahing pagpapaandar. Maaari naming magamit ang bukas na () pagpapaandar upang lumikha ng isang walang laman na file at ang isara () na function upang isara ang file.
# isamagamit namespaceoras;
intpangunahing()
{
ofstream myFile_Handler;
// File Open
myFile_Handler.buksan('File_1.txt');
// File Close
myFile_Handler.malapit na();
bumalik ka 0;
}
Ngayon, isasama namin ang programa at susuriin ang output. Tulad ng nakikita mo sa window ng output sa ibaba, ang file na File_1.txt ay nilikha pagkatapos ipatupad ang programa. Ang laki ng file ay zero dahil wala kaming naisulat na anumang nilalaman sa file.
Halimbawa 2: Sumulat sa isang File
Sa nakaraang halimbawa ng programa, ipinakita namin sa iyo kung paano magbukas ng isang file at kung paano isara ang file. Ngayon, ipapakita namin sa iyo kung paano magsulat ng isang bagay sa isang file.
Maaari kaming sumulat sa isang file gamit ang stream insertion operator, ibig sabihin,<<. 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.
# isamagamit namespaceoras;
intpangunahing()
{
ofstream myFile_Handler;
// File Open
myFile_Handler.buksan('File_1.txt');
// Sumulat sa file
myFile_Handler<< 'Ito ay isang sample na File ng pagsubok. ' <<endl;
myFile_Handler<< 'Ito ang pangalawang linya ng file. ' <<endl;
// File Close
myFile_Handler.malapit na();
bumalik ka 0;
}
Ngayon, isasama namin ang program sa itaas at isagawa ito. Tulad ng nakikita mo sa ibaba, matagumpay kaming nakasulat sa file na File_1.txt.
Halimbawa 3: Basahin mula sa isang File
Sa mga nakaraang halimbawa, ipinakita namin sa iyo kung paano magsulat ng nilalaman sa isang file. Ngayon, basahin natin ang nilalaman mula sa file na nilikha namin sa Halimbawa-2 at ipakita ang nilalaman sa karaniwang aparato ng output, ibig sabihin, ang monitor.
Ginagamit namin ang pagpapaandar ng getline () upang basahin ang kumpletong linya mula sa file at pagkatapos ay cout upang mai-print ang linya sa monitor.
# isama# isama
# isama
gamit namespaceoras;
intpangunahing()
{
ifstream myFile_Handler;
string myLine;
// File Open sa Read Mode
myFile_Handler.buksan('File_1.txt');
kung(myFile_Handler.ay bukas())
{
// Patuloy na basahin ang file
habang(getline(myFile_Handler, myLine))
{
// i-print ang linya sa karaniwang output
gastos <<aking linya<<endl;
}
// File Close
myFile_Handler.malapit na();
}
iba pa
{
gastos << 'Hindi mabuksan ang file!';
}
bumalik ka 0;
}
Ngayon, mai-print namin ang nilalaman ng File_1.txt gamit ang sumusunod na utos: cat File_1.txt. Kapag naipagsama namin at naisagawa ang programa, malinaw na ang output ay tumutugma sa nilalaman ng file. Samakatuwid, matagumpay naming nabasa ang file at nai-print ang nilalaman ng file sa monitor.
Halimbawa 4: Basahin at Sumulat sa isang File
Sa ngayon, ipinakita namin sa iyo kung paano magbukas, magbasa, magsulat, at magsara ng isang file. Sa C ++, maaari din nating basahin at isulat ang isang file nang sabay. Upang parehong basahin at isulat sa isang file, kailangan naming makakuha ng isang fstream na bagay at buksan ang file sa ios :: in at ios :: out mode.
Sa halimbawang ito, nagsusulat muna kami ng ilang nilalaman sa file. Pagkatapos, binasa namin ang data mula sa file at nai-print ito sa monitor.
# isama# isama
# isama
gamit namespaceoras;
intpangunahing()
{
fstream myFile_Handler;
string myLine;
// File Open
myFile_Handler.buksan('File_1.txt', ios::sa |ios::palabas);
// Suriin kung nagbukas ang file
kung(!myFile_Handler)
{
gastos << 'Ang file ay hindi binuksan!';
labasan(1);
}
// Sumulat sa file
myFile_Handler<< '1. Ito ay isa pang sample na File ng pagsubok. ' <<endl;
myFile_Handler<< '2. Ito ang pangalawang linya ng file. ' <<endl;
myFile_Handler.seekg(ios::magmamakaawa);
// Basahin ang File
kung(myFile_Handler.ay bukas())
{
// Patuloy na basahin ang file
habang(getline(myFile_Handler, myLine))
{
// i-print ang linya sa karaniwang output
gastos <<aking linya<<endl;
}
// File Close
myFile_Handler.malapit na();
}
iba pa
{
gastos << 'Hindi mabuksan ang file!';
}
myFile_Handler.malapit na();
bumalik ka 0;
}
Ngayon, isasama namin at isasagawa ang programa.
Halimbawa 5: Basahin at Sumulat sa isang Binary File
Sa halimbawang ito, magdedeklara kami ng isang klase at pagkatapos isulat ang bagay sa isang binary file. Upang gawing simple ang halimbawang ito, idineklara namin ang klase ng empleyado na may isang pampublikong variable na emp_id. Pagkatapos, babasahin namin ang binary file at mai-print ang output sa monitor.
# isama# isama
gamit namespaceoras;
klaseEmpleado
{
pampubliko:
intemp_id;
};
intpangunahing()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
EmpObj_W ng empleyado, empObj_R;
// File Open
binOutFile_Handler.buksan('empleyado.dat', ios::palabas |ios::binary);
// Suriin kung nagbukas ang file
kung(!binOutFile_Handler)
{
gastos << 'Ang file ay hindi binuksan!';
labasan(1);
}
// Initialize empObj_W
empObj_W.emp_id = 1512;
// Sumulat sa file
binOutFile_Handler.sumulat((char *) &empObj_W,sukat ng(Empleado));
binOutFile_Handler.malapit na();
kung(!binOutFile_Handler.mabuti())
{
gastos << 'Nagkaroon ng error sa pagsulat ng binary file!' <<endl;
labasan(2);
}
// Ngayon, basahin natin ang file ng empleyado.dat
binInFile_Handler.buksan('empleyado.dat', ios::sa |ios::binary);
// Suriin kung nagbukas ang file
kung(!binInFile_Handler)
{
gastos << 'Ang file ay hindi binuksan!';
labasan(3);
}
// Basahin ang nilalaman ng binary file
binInFile_Handler.basahin((char *) &empObj_R,sukat ng(Empleado));
binInFile_Handler.malapit na();
kung(!binInFile_Handler.mabuti())
{
gastos << 'Nagkaroon ng error habang binabasa ang binary file!' <<endl;
labasan(4);
}
// I-print ang output ng empObj_R
gastos << 'Mga Detalye ng Empleyado:' <<endl;
gastos << 'ID ng empleyado:' <<empObj_R.emp_id <<endl;
bumalik ka 0;
}
Konklusyon
Pangunahing ginagamit ang mga file upang maiimbak ang data, at may mahalagang papel ang ginagampanan sa real-world program. Sa artikulong ito, ipinakita namin sa iyo kung paano gamitin ang iba't ibang mga pagpapatakbo ng file sa wikang C + + ng programa sa pamamagitan ng pagtatrabaho sa maraming mga halimbawa. Bukod dito, ipinakita namin sa iyo kung paano basahin at isulat ang data sa parehong mga file ng teksto at mga binary file.