1. Paggawa gamit ang mga file sa C (gumagana rin sa C++)..
#isama
#isama
Walang laman ang pangunahing(walang bisa)
{
FILE *file;
char* file_name = "file.txt";
char load_string = "wala";
File = fopen(file_name, "w");
Fputs("string", file);
File = fopen(file_name, "r");
if(file != 0)
{
fgets(load_string, 50 , file);
cout)
iba pa
{
cout)
fclose(file);
) Ang mga paglalarawan ng mga function para sa pagtatrabaho sa mga file ay nasa library stdio.h
Una kailangan mong lumikha ng isang pointer sa isang variable ng uri ng FILE ( FILE* file;).
Ang pagbubukas ng isang file ay ginagawa sa pamamagitan ng pagtawag sa fopen function ( file = fopen(file_name, "w");)
Ang unang parameter ng function na ito ay ang pangalan ng file, ang pangalawa ay tumutukoy sa kung anong mode ang dapat buksan ang file. "w"- bukas para sa pag-record, "r"- bukas para sa pagbabasa, "a"- pagdaragdag ng file (ito ang pinaka ginagamit na mga mode, kahit na may iba pa). Ang pagsulat at pagbabasa ng data mula sa isang file ay isinasagawa ng mga sumusunod na function: fputc, fputs, fgetc, fgets, fprintf, fscanf(para sa paglalarawan ng mga function na ito, tingnan stdio.h).
Ang pagsasara ng file ay ginagawa sa pamamagitan ng pagtawag sa function na fclose ( fclose(file);).
Kasama sa MFC library ang ilang klase para sa pagtatrabaho sa mga file. Ang mga klase na tinalakay sa ibaba ay nagmamana mula sa batayang klasePaggawa gamit ang mga file gamit ang MFC (mga klase CFile, CStdioFile, ...) at ang karaniwang klase ng MFC na CFileDialog.
Class CF ile
CFileidinisenyo upang gumana sa mga file. Ginagawa nitong mas madaling gamitin ang mga file sa pamamagitan ng pagrepresenta sa isang file bilang isang bagay na maaaring gawin, basahin, isulat, atbp.Upang ma-access ang isang file, kailangan mo munang lumikha ng isang object ng klase ng CFile. Ang tagabuo ng klase ay nagbibigay-daan sa iyo na magbukas ng isang file kaagad pagkatapos lumikha ng isang bagay. Ngunit maaari mong buksan ang file sa ibang pagkakataon gamit ang pamamaraan
Bukas.Pagbubukas at paggawa ng mga file
Matapos malikha ang bagay ng klase CFilemaaari kang magbukas ng file sa pamamagitan ng pagtawag sa pamamaraanBukas. Dapat tukuyin ng pamamaraan ang landas sa file na bubuksan at ang mode ng paggamit nito. Prototype ng pamamaraanBukasay may sumusunod na anyo:
Virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError=NULL); Bilang parameter ng lpszFileName, dapat mong tukuyin ang pangalan ng file na bubuksan. Maaari mong tukuyin lamang ang pangalan ng file o ang buong pangalan ng file na kasama ang buong path dito. Ang pangalawang parameter, nOpenFlags, ay tumutukoy sa pagkilos na ginagawa ng Open method sa file, pati na rin sa mga attribute ng file. Nasa ibaba ang ilang posibleng halaga para sa parameter ng nOpenFlags:
Opsyonal na parameter pError, na isang pointer sa isang object ng klase CFileException, ay ginagamit lamang kung ang pagsasagawa ng operasyon sa file ay magdudulot ng error. Sa kasong ito, isusulat ang karagdagang impormasyon sa bagay na itinuro ng pError.
Pamamaraan Bukasnagbabalik ng non-zero kung ang file ay bukas at zero sa error. Ang isang error kapag binubuksan ang isang file ay maaaring mangyari, halimbawa, kung ang Open na paraan ay tinukoy upang basahin ang isang hindi umiiral na file.
Buksan ang file ID
Ang klase ng CFile ay may kasamang elemento ng data na m_hFile ng uri ng UINT. Iniimbak nito ang identifier ng bukas na file. Kung ang isang bagay ng klase ng CFile ay nagawa na, ngunit ang file ay hindi pa nabubuksan, kung gayon ang hFileNull constant ay nakasulat sa m_hFile variable.
Karaniwan ang open file identifier ay hindi direktang ginagamit. Mga Paraan ng Klase CFilenagbibigay-daan sa iyo na magsagawa ng halos anumang operasyon sa mga file at hindi mo hinihiling na tukuyin ang isang file identifier. Dahil ang m_hFile ay isang elemento ng klase, ang pagpapatupad ng mga pamamaraan nito ay palaging may libreng access dito.
Pagsasara ng mga file
Matapos tapusin ang pagtatrabaho sa file, dapat itong sarado. Klase CFileay may espesyal na paraan ng Close para dito. Dapat tandaan na kung ang isang bagay ng klase ng CFile ay nilikha at ang isang file ay binuksan, at pagkatapos ay ang bagay ay tinanggal, ang nauugnay na file ay awtomatikong isinara gamit ang isang destructor.
Pagbasa at pagsulat ng mga file
Mayroong ilang mga paraan ng klase para sa pag-access ng mga file. CFile: Basahin, ReadHuge, Write, WriteHuge, Flush. Pamamaraan Basahin at Basahin ang Malaki ay idinisenyo upang basahin ang data mula sa isang naunang binuksang file. Sa 32-bit na mga operating system, ang parehong mga pamamaraan ay maaaring sabay na magbasa ng higit sa 65535 byte mula sa isang file. Ang ReadHuge na detalye ay itinuturing na hindi na ginagamit at pinananatili lamang para sa pagiging tugma sa 16-bit na mga operating system.
Ang data na nabasa mula sa file ay nakasulat sa lpBuf buffer. Tinutukoy ng parameter ng nCount ang bilang ng mga byte na babasahin mula sa file. Sa katunayan, mas kaunting mga byte ang maaaring basahin mula sa file kaysa sa hiniling ng parameter ng nCount. Ito ay nangyayari kung ang dulo ng file ay naabot habang nagbabasa. Ibinabalik ng mga pamamaraan ang bilang ng mga byte na nabasa mula sa file.
Ang mga pamamaraan ng Write at WriteHuge ay inilaan para sa pagsulat sa isang file. Sa 32-bit na mga operating system, ang parehong mga pamamaraan ay maaaring sabay na sumulat ng higit sa 65535 bytes sa isang file. Ang mga pamamaraan ay nagsusulat ng mga byte mula sa buffer ng lpBuf hanggang sa bukas na file na nCount. Kung nangyari ang isang error sa pagsusulat, tulad ng isang disk na puno, ang mga pamamaraan ay humihimok ng paghawak ng exception.
Paraan ng flush
Kapag ang paraan ng Write o WriteHuge ay ginamit upang magsulat ng data sa disk, maaari itong manatili sa isang pansamantalang buffer nang ilang panahon. Upang matiyak na ang mga kinakailangang pagbabago ay ginawa sa file sa disk, kailangan mong gamitin ang paraan ng Flush.
Mga Operasyon ng File
Kasama sa klase ang mga pamamaraan na nagbibigay-daan sa iyo na magsagawa ng iba't ibang mga operasyon sa mga file, tulad ng pagkopya, pagpapalit ng pangalan, pagtanggal, pagbabago ng mga katangian.
Upang baguhin ang pangalan ng file, ang klase ng CFile ay may kasamang static na pamamaraan Palitan ang pangalan, na gumaganap ng mga function ng command na ito. Ang pamamaraan ay hindi maaaring gamitin upang palitan ang pangalan ng mga direktoryo. Kung ang isang error ay nangyari, ang pamamaraan ay nagtataas ng isang pagbubukod.
Ang isang static na paraan ay kasama sa klase ng CFile para magtanggal ng mga file Alisin, na nagpapahintulot sa iyo na tanggalin ang tinukoy na file. Ang pamamaraang ito ay hindi nagpapahintulot sa iyo na tanggalin ang mga direktoryo. Kung ang file ay hindi matanggal, ang pamamaraan ay naghagis ng isang pagbubukod.
Upang matukoy ang petsa at oras ng paglikha ng file, ang haba at mga katangian nito, isang static na paraan ang ginagamit GetStatus. Mayroong dalawang uri ng pamamaraan - ang una ay tinukoy bilang isang virtual na pamamaraan at ang pangalawa ay tinukoy bilang isang static na pamamaraan.
Virtual na bersyon ng pamamaraan GetStatustinutukoy ang bukas na estado ng file na nauugnay sa object ng klase ng CFile na ito. Ang pamamaraang ito ay tinatawag lamang kapag ang isang bagay ng klase ng CFile ay nilikha at ang file ay binuksan.
Static na bersyon ng pamamaraan GetStatusnagbibigay-daan sa iyo upang matukoy ang mga katangian ng isang file na hindi nauugnay sa isang bagay ng klase ng CFile. Upang magamit ang pamamaraang ito, hindi kinakailangan na buksan muna ang file.
Hinaharang
Kasama sa klase ang mga pamamaraan LockRange At UnlockRange, na nagpapahintulot sa isa o higit pang mga piraso ng data ng file na mai-lock para ma-access ng ibang mga proseso. Kung ang isang application ay sumusubok na muling i-lock ang data na dati ay na-lock nito o ng isa pang application, isang pagbubukod ang itatapon. Ang pag-lock ay isa sa mga mekanismo na nagpapahintulot sa ilang mga application o proseso na gumana nang sabay-sabay sa parehong file nang hindi nakakasagabal sa isa't isa.
Maaari kang magtakda ng lock gamit ang pamamaraan LockRange. Upang alisin ang mga naka-install na kandado, kailangan mong gamitin ang pamamaraanUnlockRange. Kung ang ilang mga kandado ay nakatakda sa isang file, ang bawat isa sa kanila ay dapat na ilabas sa pamamagitan ng isang hiwalay na tawag sa pamamaraanUnlockRange.
Pagpoposisyon
Upang ilipat ang kasalukuyang pointer ng posisyon ng file sa isang bagong posisyon, maaari mong gamitin ang isa sa mga sumusunod na pamamaraan ng klase CFile - Seek, SeekToBegin, SeekToEnd. Sa klase CFilekasama rin ang mga pamamaraan na nagbibigay-daan sa iyong itakda at baguhin ang haba ng file, -GetLength, SetLength.
Kapag binubuksan ang isang file, ang kasalukuyang tagapagpahiwatig ng posisyon ng file ay matatagpuan sa pinakadulo simula ng file. Kapag ang isang piraso ng data ay nabasa o nakasulat, ang kasalukuyang position pointer ay gumagalaw patungo sa dulo ng file at tumuturo sa data na babasahin o isusulat ng susunod na read o write na operasyon sa file.
Upang ilipat ang kasalukuyang pointer ng posisyon ng file sa anumang lokasyon, maaari mong gamitin ang unibersal na paraan
Humanap. Binibigyang-daan ka nitong ilipat ang pointer sa isang tiyak na bilang ng mga byte na nauugnay sa simula, pagtatapos, o kasalukuyang posisyon ng pointer.Upang ilipat ang pointer sa simula o dulo ng isang file, ito ay pinaka-maginhawang gumamit ng mga espesyal na pamamaraan. Pamamaraan
SeekToBegininililipat ang pointer sa simula ng file, at ang pamamaraanSeekToEnd- sa dulo nito.Ngunit upang matukoy ang haba ng isang bukas na file, hindi kinakailangang ilipat ang pointer nito. Maaari mong gamitin ang pamamaraan
GetLength. Ibinabalik din ng pamamaraang ito ang haba ng bukas na file sa mga byte. PamamaraanSetLengthnagpapahintulot sa iyo na baguhin ang haba ng bukas na file. Kung pinapataas ng pamamaraang ito ang laki ng file, hindi natukoy ang halaga ng mga huling byte.Ang kasalukuyang posisyon ng pointer ng file ay maaaring matukoy gamit ang pamamaraan
GetPosition. Ibinalik sa pamamagitan ng pamamaraanGetPositionAng 32-bit na halaga ay tumutukoy sa pointer offset mula sa simula ng file.Mga katangian ng isang bukas na file
Upang matukoy ang lokasyon ng isang bukas na file sa disk, kailangan mong tawagan ang pamamaraan GetFilePath. Ang pamamaraang ito ay nagbabalik ng isang bagay ng klaseCString, na naglalaman ng buong path ng file, kabilang ang pangalan ng drive, mga direktoryo, pangalan ng file, at extension ng file.
Kung kailangan mo lamang matukoy ang pangalan at extension ng isang bukas na file, maaari mong gamitin ang pamamaraan GetFileName. Nagbabalik ito ng CString object na naglalaman ng pangalan ng file. Sa kaso kung kailan kailangan mong malaman lamang ang pangalan ng isang bukas na file na walang extension, gamitin ang pamamaraanGetFileTitle.
Ang sumusunod na paraan ng klase ng CFile ay nagpapahintulot sa iyo na itakda ang landas ng file. Ang pamamaraang ito ay hindi gumagawa, nagkokopya, o nagpapalit ng pangalan ng file; ito ay nagpupuno lamang ng kaukulang elemento ng data sa object ng klase ng CFile.
Klase C
MemFileKasama sa MFC library ang klase
CMemFile, minana mula sa batayang klaseCFile. Klase CMemFilekumakatawan sa isang file na matatagpuan sa RAM. Gamit ang mga bagay sa klaseCMemFilekatulad ng sa mga bagay sa klaseCFile. Ang pagkakaiba ay ang file na nauugnay sa objectCMemFile, ay hindi matatagpuan sa disk, ngunit sa RAM ng computer. Dahil dito, ang mga operasyon na may ganoong file ay mas mabilis kaysa sa mga regular na file.Paggawa gamit ang Class Objects
CMemFile, maaari mong gamitin ang halos lahat ng mga pamamaraan ng klaseCFilena inilarawan sa itaas. Maaari kang magsulat ng data sa naturang file o basahin ito. Bilang karagdagan sa mga pamamaraang ito, naglalaman ang klaseCMemFilekasama ang mga karagdagang pamamaraan.Mayroong dalawang magkaibang mga konstruktor para sa paglikha ng mga bagay ng klase ng CMemFile. Ang unang tagabuo ng CMemFile ay mayroon lamang isang opsyonal na parameter na nGrowBytes:
CMemFile(UINT nGrowBytes=1024);Ang constructor na ito ay lumilikha ng isang walang laman na file sa RAM. Kapag nalikha na, awtomatikong mabubuksan ang file (hindi na kailangang tawagan ang paraan ng Open
n).Kapag nagsimula ang pagsulat sa naturang file, awtomatikong inilalaan ang isang bloke ng memorya. Upang makakuha ng mga pamamaraan ng klase ng memorya
CMemFiletumawag sa mga karaniwang functionmalloc, realloc At libre. Kung ang inilalaan na bloke ng memorya ay hindi sapat, ang laki nito ay nadagdagan. Ang memory block ng file ay tumaas sa mga bahagi ng nGrowBytes bytes. Matapos tanggalin ang isang bagay ng klaseCMemFileang ginamit na memorya ay awtomatikong ibinalik sa system.Ang pangalawang tagabuo ng klase ng CMemFile ay may mas kumplikadong prototype. Ang constructor na ito ay ginagamit sa mga kaso kung saan ang programmer mismo ay naglalaan ng memorya para sa file:
CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes=0);Tinutukoy ng parameter ng lpBuffer ang buffer na gagamitin para sa file. Ang laki ng buffer ay tinutukoy ng parameter na nBufferSize.
Ang opsyonal na parameter ng nGrowBytes ay ginagamit nang mas komprehensibo kaysa sa first class constructor. Kung ang nGrowBytes ay naglalaman ng zero, ang nabuong file ay maglalaman ng data mula sa lpBuffer. Ang haba ng naturang file ay magiging katumbas ng nBufferSize.
Kung ang nGrowBytes ay mas malaki kaysa sa zero, ang mga nilalaman ng lpBuffer ay hindi papansinin. Bilang karagdagan, kung mas maraming data ang nakasulat sa naturang file kaysa sa maaaring magkasya sa inilalaan na buffer, awtomatikong tumataas ang laki nito. Ang memory block ng file ay nadagdagan sa mga bahagi ng nGrowBytes bytes.
CMemFileay nagbibigay-daan sa iyo upang makakuha ng isang pointer sa lugar ng memorya na ginagamit ng file. Sa pamamagitan ng pointer na ito maaari kang direktang magtrabaho sa mga nilalaman ng file, nang hindi nililimitahan ang iyong sarili sa mga pamamaraan ng klaseCFile. Upang makakuha ng pointer sa isang buffer ng file, maaari mong gamitin ang paraan ng Detach. Bago gawin ito, ito ay kapaki-pakinabang upang matukoy ang haba ng file (at samakatuwid ang laki ng memory buffer) sa pamamagitan ng pagtawag sa pamamaraanGetLength. Maghiwalayisinasara ang ibinigay na file at ibabalik ang isang pointer sa bloke ng memorya na ginagamit nito. Kung kailangan mong buksan muli ang file at iugnay ang isang bloke ng RAM dito, kailangan mong tawagan ang pamamaraanKalakip.Dapat tandaan na upang pamahalaan ang buffer ng file, ang klase
CMemFiletumatawag sa mga karaniwang functionmalloc, realloc At libre. Samakatuwid, upang hindi masira ang mekanismo ng pamamahala ng memorya, ang lpBuffer buffer ay dapat likhain ng mga functionmalloc o calloc.klase ng CstdioFile
Ang mga nakasanayan nang gumamit ng streaming I/O functions mula sa C at C++ standard library ay dapat bigyang pansin ang klase
CstdioFile, minana mula sa batayang klaseCFile. Binibigyang-daan ka ng klase na ito na magsagawa ng buffered I/O sa text at binary mode. Para sa mga bagay sa klaseCstdioFileMaaari mong tawagan ang halos lahat ng mga pamamaraan ng klase ng CFile.CstdioFilekasama ang elemento ng data ng m_pStream, na naglalaman ng isang pointer sa bukas na file. Kung object ng klaseCstdioFilenilikha, ngunit ang file ay hindi pa bukas o sarado, pagkatapos ay naglalaman ang m_pStream ng NULL constant.CstdioFileay may tatlong magkakaibang konstruktor. Ang unang constructor ng klase ng CstdioFile ay walang mga parameter. Ang constructor na ito ay lumilikha lamang ng isang class object, ngunit hindi nagbubukas ng anumang mga file. Upang buksan ang isang file, kailangan mong tawagan ang pamamaraanBukasbatayang klaseCFile.Tagabuo ng pangalawang klase
CstdioFilemaaaring tawagan kung nakabukas na ang file at kailangan mong lumikha ng bagong object ng klase ng CstdioFile at iugnay ang bukas na file dito. Ang constructor na ito ay maaaring gamitin kung ang file ay binuksan gamit ang isang karaniwang functionfopen. Ang parameter ng pamamaraan ay dapat maglaman ng isang pointer sa file na nakuha sa pamamagitan ng pagtawag sa karaniwang functionfopen.Maaaring gamitin ang pangatlong constructor kung kailangan mong lumikha ng object ng klase
CstdioFile, magbukas ng bagong file at iugnay ito sa bagong likhang bagay.Para sa pagbabasa at pagsulat sa isang text file, ang klase ng CstdioFile ay may kasamang dalawang bagong pamamaraan:
ReadString At WriteString. Ang unang paraan ay nagpapahintulot sa iyo na basahin ang isang string ng mga character mula sa isang file, at ang pangalawang paraan ay nagpapahintulot sa iyo na isulat ito.Mga halimbawa ng pagsulat at pagbasa mula sa isang file
Narito ang mga fragment ng code na nagpapakita ng paggamit ng karaniwang mga panel ng dialog ng pagpili ng file at ang pamamaraan para sa pagbabasa at pagsulat sa isang file.
Pagbukas at pagbabasa mula sa isang file
CString m_Text; ……// paggawa ng karaniwang panel ng pagpili ng file Buksan CFileDialog DlgOpen(TRUE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY,(LPCSTR)" Text Files (*.txt) |*.txt||");// ipakita ang karaniwang panel ng pagpili ng file Buksan if(DlgOpen.DoModal()==IDOK) (// lumikha ng isang bagay at buksan ang file para sa pagbabasa CStdioFile File(DlgOpen.GetPathName(),CFile::modeRead|CFile::typeBinary);// pagbabasa ng mga string mula sa file CString& ref=m_Text; File.ReadString(ref); // ang isang reference sa isang string ay naipasa
CString m_Text; m_Text) Pagbubukas at pagsulat mula sa isang file // paglikha ng isang standard na SaveAs file selection panel CFileDialog DlgSaveAs(FALSE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, (LPCSTR)" Text Files (*.txt) |*.txt||"); // ipakita ang standard SaveAs file selection panel if(DlgSaveAs.DoModal()==IDOK) ( // lumikha ng isang bagay at magbukas ng file para sa pagsusulat CStdioFile File(DlgSaveAs.GetPathName(), CFile::modeCreate|CFile::modeWrite|CFile::typeBinary);- // sumulat sa isang string file
File.WriteString((LPCTSTR)m_Text);
)
naglalaman ng gumaganang code ng programa, na idinisenyo para sa pagiging simple bilang isang console application sa ilalim ng MFC. Para gumana ang programa, huwag kalimutang gawin ang sumusunod:
Patakbuhin ang programa - Buuin / Buuin muli ang lahat (magkakaroon ng mga error), piliin ang Bumuo / Itakda ang aktibong pagsasaayos - Win 32 Realise, piliin ang item sa menu na "Proyekto", pagkatapos ay "Mga Setting...", ang tab na "C/C++", Kategorya - Pagbuo ng Code at Sa item na "Gumamit ng run-time library", piliin ang "Multithreaded". Pagkatapos nito, gawin muli ang Build / Rebuild lahat at gagana ang programa.
Mga text file
Tingnan natin ang pagtatrabaho sa isang text file sa C gamit ang isang halimbawa. Gumawa ng text file sa drive C na pinangalanang TextFile.txt. I-type ang mga sumusunod na linya sa file na ito:
String_1 123 String_11, 456
String_2
String_3
At ito ang code para sa isang C program na nagbubukas ng aming file at nagbabasa ng mga linya mula dito:
/* *May-akda: @author Subbotin B.P..h> #include
Ang unang argumento sa fopen function ay tumuturo sa isang file, at ang pangalawa ay nagsasabi na ang file ay bukas para sa pagbabasa mula dito.
Binabasa namin ang mga linya gamit ang fgets function:
fgets(cArray, LEN, pTextFile);
Ang unang argumento ng function ng fgets ay tumuturo sa isang character array kung saan ang mga natanggap na string ay iimbak, ang pangalawang argumento ay ang maximum na bilang ng mga character na babasahin, at ang pangatlo ay ang aming file.
Pagkatapos ng pagtatrabaho sa file, kailangan mong isara ito:
fclose(pTextFile);
Nakukuha namin:
Lumilitaw din ang mga letrang Ruso sa mga linya.
By the way, ginawa ko itong program sa Eclipse. Maaari mong makita kung paano gumana sa C/C++ sa Eclipse.
Kaya, binuksan at binasa namin ang data mula sa isang text file.
Ngayon ay matututunan natin kung paano gumawa ng isang text file sa pamamagitan ng programming at magsulat ng data dito.
/* May-akda: @author Subbotin B.P..h> #include
Lumikha ng isang text file upang isulat ang data sa:
FILE *pTextFile = fopen("C:\\TextFileW.txt", "w");
kung ang file ay mayroon na, ito ay bubuksan at ang lahat ng data mula dito ay tatanggalin.
Ang C-string cString at ang numerong nVal ay isinulat ng programa sa isang text file. Ang cNewLine ay isang bagong linya lamang.
Nagsusulat kami ng data sa isang text file gamit ang fprintf function:
fprintf(pTextFile, "%s%c", cString, cNewLine);
ang unang argument dito ay ang aming file, ang pangalawa ay ang format string, ang pangatlo o higit pa ay ang bilang ng mga argumento na kinakailangan para sa format na ito.
Para sa programmer, ang isang bukas na file ay kinakatawan bilang isang sequence ng data na binabasa o nakasulat. Kapag ang isang file ay binuksan, ito ay nauugnay sa I/O stream . Ang impormasyon ng output ay nakasulat sa stream, ang impormasyon ng input ay binabasa mula sa stream.
Kapag ang isang stream ay binuksan para sa I/O, ito ay nauugnay sa isang karaniwang FILE na istraktura, na tinukoy sa stdio.h. Ang istraktura ng FILE ay naglalaman ng kinakailangang impormasyon tungkol sa file.
Ang pagbubukas ng isang file ay ginagawa gamit ang fopen() function, na nagbabalik ng isang pointer sa isang istraktura ng uri ng FILE na maaaring magamit para sa mga kasunod na operasyon sa file.
FILE *fopen(pangalan, uri);
pangalan – pangalan ng file na bubuksan (kabilang ang landas),
type - pointer sa isang string ng mga character na tumutukoy kung paano naa-access ang file:
· "r" - buksan ang file para sa pagbabasa (dapat umiiral ang file);
· "w" - buksan ang isang walang laman na file para sa pagsusulat; kung umiiral ang file, mawawala ang mga nilalaman nito;
· "a" - buksan ang file para sa pagsusulat hanggang sa dulo (para sa pagdaragdag); ang file ay nilikha kung wala ito;
· "r+" - buksan ang file para sa pagbabasa at pagsusulat (dapat umiiral ang file);
· "w+" - buksan ang isang walang laman na file para sa pagbabasa at pagsusulat; kung umiiral ang file, mawawala ang mga nilalaman nito;
· "a+" - buksan ang file para sa pagbabasa at pagdaragdag kung ang file ay hindi umiiral, ito ay nilikha.
Ang return value ay isang pointer sa open stream. Kung may nakitang error, ibabalik ang NULL.
Isinasara ng fclose() function ang stream o mga stream na nauugnay sa mga file na binuksan gamit ang fopen() function. Ang stream na isasara ay tinutukoy ng argumento ng fclose() function.
Return value: value 0 kung matagumpay na naisara ang stream; pare-pareho ang EOF kung may naganap na error.
#isama
int main()
char name="my.txt";
if(fp = fopen(pangalan, "r")!=NULL)
// posible bang buksan ang file?
... // mga kinakailangang aksyon sa data
else printf("Nabigong buksan ang file");
Pagbabasa ng isang character mula sa isang file:
char fgetc(stream);
Ang argument ng function ay isang pointer sa isang stream ng uri ng FILE. Ibinabalik ng function ang code ng read character. Kung ang dulo ng file ay naabot o naganap ang isang error, ang pare-parehong EOF ay ibabalik.
Pagsusulat ng isang simbolo sa isang file:
fputc(char, stream);
Ang mga argumento ng function ay isang character at isang pointer sa isang stream ng uri ng FILE. Ibinabalik ng function ang code ng read character.
Ang mga function ng fscanf() at fprintf() ay katulad ng scanf() at printf() function, ngunit gumagana sa mga file ng data, at mayroong pointer sa file bilang kanilang unang argumento.
fscanf(stream, "Format ng Input", mga argumento);
fprintf(stream, "Format ng Output", mga argumento);
Ang mga function na fgets() at fputs() ay idinisenyo para sa string input/output;
fgets(Puro sa Linya, Bilang ng mga Character, stream);
Binabasa ang mga character mula sa stream hanggang sa mabasa ang isang bagong linyang character na "\n", na kasama sa string, o hanggang sa matapos ang stream sa EOF o ang maximum na bilang ng mga character ay nabasa na. Ang resulta ay inilalagay sa isang string pointer at nagtatapos sa null character na "\0". Ibinabalik ng function ang address ng string.
fputs(Pointer To String, stream);
Kinokopya ang isang string sa stream mula sa kasalukuyang posisyon. Ang pagwawakas na null character ay hindi kinopya.
Halimbawa
Ilagay ang numero at i-save ito sa s1.txt file. Basahin ang numero mula sa file na s1.txt, dagdagan ito ng 3 at i-save ito sa file na s2.txt.
Paggawa gamit ang mga text file sa C++.
Mayroong dalawang pangunahing uri ng mga file: text at binary. Ang mga file ay nagbibigay-daan sa gumagamit na magbasa ng malalaking halaga ng data nang direkta mula sa disk nang hindi kinakailangang ipasok ito mula sa keyboard.
Text Ang mga file na binubuo ng anumang mga character ay tinatawag. Nakaayos ang mga ito sa mga linya, ang bawat isa ay nagtatapos sa isang end-of-line na character. Ang dulo ng file mismo ay ipinahiwatig ng "end of file" na simbolo. Kapag nagsusulat ng impormasyon sa isang text file, na maaaring matingnan gamit ang anumang text editor, ang lahat ng data ay na-convert sa isang uri ng character at naka-imbak sa anyo ng character.
SA binary Sa mga file, ang impormasyon ay binabasa at isinulat sa anyo ng mga bloke ng isang tiyak na laki, kung saan ang data ng anumang uri at istraktura ay maaaring maimbak.
Upang gumana sa mga file, espesyal mga uri ng data, tinawag batis. Daloy ifstream ay ginagamit upang gumana sa mga file sa mode ng pagbabasa, at ofstream sa recording mode. Upang gumana sa mga file sa parehong mode ng pagsulat at pagbabasa, ginagamit ang isang stream fstream.
Sa mga programang C++, kapag nagtatrabaho sa mga text file, dapat mong isama ang mga library ng iostream at fstream.
Upang rekord data sa isang text file, kailangan mo:
ilarawan ang isang variable ng uri ng stream.
impormasyon ng output sa isang file.
siguraduhing isara ang file.
Para sa pagbabasa data mula sa isang text file, kailangan mo:
ilarawan ang isang variable ng uri ng ifstream.
magbukas ng file gamit ang open function.
isara ang file.
Itala impormasyon sa isang text file
Tulad ng nabanggit kanina, upang magsimulang magtrabaho sa isang text file, kailangan mong tukuyin ang isang variable ng uri ng stream. Halimbawa, tulad nito:
Isang variable na F ang gagawin para magsulat ng impormasyon sa file.
Sa susunod na yugto, dapat buksan ang file para sa pagsusulat. Sa pangkalahatan, magiging ganito ang hitsura ng operator ng pagbubukas ng stream:
F.open("file", mode);
Narito ang F ay isang variable na inilarawan bilang ofstream,
file - buong pangalan ng file sa disk,
mode - mode ng pagtatrabaho sa file na binubuksan.
Pakitandaan na kapag tinukoy ang buong pangalan ng file, dapat kang gumamit ng double slash. Halimbawa, ang buong pangalan ng file na noobs.txt, na matatagpuan sa folder ng laro sa drive D:, ay kailangang isulat tulad nito:
D:\\game\\noobs.txt.
Maaaring buksan ang file sa isa sa mga sumusunod na mode:
ios::in - buksan ang file sa data reading mode, ang mode na ito ay ang default na mode para sa ifstreams;
ios::out - buksan ang isang file sa mode ng pagsulat ng data (sa kasong ito, ang impormasyon tungkol sa umiiral na file ay nawasak), ang mode na ito ay ang default na mode para sa mga stream;
ios::app - buksan ang file sa mode ng pagsulat ng data hanggang sa dulo ng file;
ios::ate - lumipat sa dulo ng isang nakabukas na file;
ios::trunc - i-clear ang file, nangyayari rin ito sa ios::out mode;
ios::nocreate - huwag magbukas ng file kung wala ito;
ios::noreplace - huwag magbukas ng kasalukuyang file.
Maaaring wala ang parameter ng mode, kung saan mabubuksan ang file sa default na mode para sa stream na ito.
Pagkatapos ng matagumpay na pagbubukas ng file (sa anumang mode), ang variable na F ay mag-iimbak ng totoo, kung hindi man mali. Papayagan ka nitong suriin ang kawastuhan ng operasyon ng pagbubukas ng file.
Maaari kang magbukas ng file (kunin natin ang file na D:\\game\\noobs.txt bilang isang halimbawa) sa recording mode sa isa sa mga sumusunod na paraan:
// una paraan
ofstream F;
F.open("D:\\game\\noobs.txt", ios::out);
//second method, ios::out mode ang default mode
// Para sa daloyofstream
ofstream F;
//pinagsasama ng ikatlong paraan ang paglalarawan ng variable at ang uri ng stream
//at binubuksan ang file sa isang statement
ofstream F("D:\\game\\noobs.txt", ios::out);
Pagkatapos buksan ang file sa write mode, isang walang laman na file ang gagawin kung saan maaari kang sumulat ng impormasyon.
Kung gusto mong magbukas ng kasalukuyang file sa write-first mode, dapat mong gamitin ang ios::app bilang mode.
Pagkatapos buksan ang isang file sa mode ng pag-record, maaari kang sumulat dito sa parehong paraan tulad ng sa screen, sa halip na ang karaniwang output devicecoutdapat mong tukuyin ang pangalan ng bukas na file.
Halimbawa, upang magsulat ng variable a sa stream F, ang output statement ay magiging ganito:
Para sa sequential output sa stream G ng mga variable b, c, d, ang output operator ay magiging ganito:
G< Ang pagsasara ng stream ay ginagawa gamit ang operator: HALIMBAWA: Gumawa ng text file D:\\game\\noobs.txt at magsulat ng mga tunay na numero dito. #include "stdafx.h" #isama #isama #isama gamit ang namespace std; int main() setlocale(LC_ALL, "RUS"); int i, n; doble a; //naglalarawan ng stream para sa pagsusulat ng data sa isang file ofstream
f;
// buksan ang file sa write mode, //modeios::
palabasnaka-install bilang default f.open("D:\\game\\noobs.txt", ios::out); //ipasok ang bilang ng mga tunay na numero cout<<"
n=";
cin>>
n;
//loop para sa pagpasok ng mga totoong numero //at isulat ang mga ito sa isang file para sa (i=0; i cout<<"a=";
//magpasok ng numero cin>>a; f< //pagsasara ng batis f.close(); system("pause"); bumalik 0; _______________________________________________________________ Upang mabasa ang impormasyon mula sa isang text file, kailangan mong ilarawan ang isang variable na tulad ng ifstream. Pagkatapos nito, kailangan mong buksan ang file para sa pagbabasa gamit ang operator bukas. Kung ang variable ay tinatawag na F, ang unang dalawang pahayag ay magiging ganito: F.open("D:\\game\\noobs.txt", ios::in); Pagkatapos buksan ang isang file sa mode ng pagbabasa, maaari mong basahin ang impormasyon mula dito sa parehong paraan tulad ng mula sa keyboard, sa halip nacintukuyin ang pangalan ng stream kung saan babasahin ang data. Halimbawa, upang basahin mula sa stream F papunta sa variable a, ang input statement ay magiging ganito: Dalawang numero sa isang text editor ang itinuturing na hiwalay kung mayroong kahit isa sa mga character sa pagitan ng mga ito: espasyo, tab, dulo ng linya. Mabuti kung alam ng programmer nang maaga kung gaano karami at kung anong mga halaga ang iimbak sa text file. Gayunpaman, kadalasan ang uri ng mga halaga na nakaimbak sa file ay kilala lamang, ngunit ang kanilang numero ay maaaring mag-iba. Upang malutas ang problemang ito, kailangan mong basahin ang mga halaga mula sa file nang paisa-isa, at bago ang bawat pagbasa, suriin kung naabot na ang dulo ng file. May function para dito F.
eof().
Narito ang F ay ang pangalan ng thread, ang function ay nagbabalik ng isang Boolean na halaga: totoo o mali, depende sa kung ang dulo ng file ay naabot. Samakatuwid, ang isang loop upang basahin ang mga nilalaman ng buong file ay maaaring isulat tulad nito: // ayusin para sa pagbabasa ng mga halaga mula sa isang file, pagpapatupad //masira ang loop kapag naabot namin ang dulo ng file, //sa kasong ito F.eof() ay magbabalik ng true habang (!F.eof()) HALIMBAWA: Ang text file na D:\\game\\noobs.txt ay nag-iimbak ng mga totoong numero, ipinapakita ang mga ito sa screen at kalkulahin ang kanilang numero. #include "stdafx.h" #isama #isama #isama #isama gamit ang namespace std; int main() setlocale(LC_ALL, "RUS"); int n=0; lumutang a; fstream F; //buksan ang file sa reading mode F.open("D:\\game\\noobs.txt"); //kung ang file ay nabuksan nang tama, kung gayon //loop para sa pagbabasa ng mga halaga mula sa isang file; ang loop execution ay maaantala, //kapag naabot namin ang dulo ng file, sa kasong ito F.eof() ay magbabalik ng true. habang (!F.eof()) //pagbabasa ng susunod na halaga mula sa stream F papunta sa variable a F>>a; //output ang value ng variable a sa screen cout< //dagdagan ang bilang ng mga numerong binasa //pagsasara ng batis F.close(); //input sa screen ang bilang ng mga numerong binasa cout<<"n="< //kung ang pagbubukas ng file ay hindi tama, kung gayon ang output //mensahe tungkol sa kawalan ng naturang file iba cout<<" Файл не существует"< system("pause"); bumalik 0; C++. Binary file processing Kapag nagsusulat ng impormasyon sa isang binary file, ang mga character at numero ay isinusulat bilang isang sequence ng mga byte. Upang isulat data sa isang binary file, kailangan mo: ilarawan ang isang file variable ng uri FAIL * gamit ang FILE *filename operator; Dito ang filename ay ang pangalan ng variable kung saan iimbak ang pointer sa file. magsulat ng impormasyon sa isang file gamit ang fwrite function Upang bilangin b data mula sa isang binary file, kailangan mo: ilarawan ang isang variable ng uri ng FILE * buksan ang isang file gamit ang fopen function isara ang isang file gamit ang fclose function Mga pangunahing function na kinakailangan upang gumana sa mga binary file. Para sa mga pagbubukas Ang file ay inilaan para sa fopen function. FILE *fopen(const *filename, const char *mode) Narito ang filename ay isang string na nag-iimbak ng buong pangalan ng file na binubuksan, ang mode ay isang string na tumutukoy sa mode para sa pagtatrabaho sa file; ang mga sumusunod na halaga ay posible: "rb" - buksan ang binary file sa read mode; "wb" - lumikha ng isang binary file para sa pag-record; kung ito ay umiiral, ang mga nilalaman nito ay malinis; "ab" - lumikha o magbukas ng binary file upang idugtong sa dulo ng file; "rb+" - buksan ang isang umiiral na binary file sa read-write mode; "wb+" - buksan ang binary file sa read-write mode, ang umiiral na file ay na-clear; "ab+" - isang binary file ay binuksan o nilikha upang itama ang umiiral na impormasyon at magdagdag ng bagong impormasyon sa dulo ng file. Ang function ay nagbabalik ng NULL sa file variable f kung ang file ay hindi matagumpay na nagbubukas. Matapos buksan ang isang file, magagamit ang ika-0 byte nito, ang pointer ng file ay 0, ang halaga nito, habang binabasa o isinulat ito, ay inililipat ng bilang ng mga byte na nabasa (nakasulat). Ang kasalukuyang halaga ng file pointer ay ang byte number kung saan magaganap ang read o write operation. Para sa pagsasara ang file ay inilaan para sa fclose function int fclose(FILE *filename); Nagbabalik ng 0 kung matagumpay na naisara ang file, NULL kung hindi. Ang function ng pag-alis ay para sa pagtanggal mga file. int tanggalin(const char *filename); Tinatanggal ng function na ito ang isang file na pinangalanang filenema mula sa disk. Ang file na tatanggalin ay dapat na sarado. Ang function ay nagbabalik ng isang hindi-zero na halaga kung ang file ay hindi matanggal. Para sa pagpapalit ng pangalan file, ang pagpapalit ng pangalan ay inilaan: int rename(const char *oldfilename, const char *newfilename); Ang unang parameter ay ang lumang pangalan ng file, ang pangalawa ay ang bago. Nagbabalik ng 0 kung matagumpay na natapos ang programa. Nagbabasa mula sa isang binary file ay ginagawa gamit ang fread function: fread(walang bisa *ptr, laki, n, FILE *filename); Ang fread function ay nagbabasa ng n elemento ng laki ng laki mula sa filename ng file papunta sa isang array ptr. Ibinabalik ng function ang bilang ng mga elementong nabasa. Pagkatapos magbasa mula sa isang file, ang pointer nito ay inilipat ng n*size bytes. Itala sa isang binary file ay ginagawa gamit ang fwrite function: fwrite(const void *ptr, laki, n, FILE *filename); Ang fwrite function ay nagsusulat sa filename ng file mula sa isang array ptr ng n elemento ng laki ng laki. Ibinabalik ng function ang bilang ng mga elementong nakasulat. Pagkatapos magsulat ng impormasyon sa file, ang pointer ay inililipat ng n*size bytes. Para sa kontrol ng end-of-file mayroong isang function feof: int feof(FILE *filename); Nagbabalik ito ng hindi zero na halaga kung naabot ang dulo ng file. HALIMBAWA: Gumawa ng binary file D:\\game\\noobs.dat at isulat ang n integer at n real number dito. #include "stdafx.h" #isama gamit ang namespace std; int main() setlocale(LC_ALL, "RUS"); int n, i; doble a; //lumikha ng binary file sa write mode f=fopen("D:\\game\\noobs.dat", "wb"); //
input
mga numeron cout<<"n=";
cin>>n; fwrite(&n, sizeof(int), 1, f); //loop upang ipasok ang mga tunay na numero para sa (i=0; i //ipasok ang susunod na tunay na numero cout<<"a=";
cin>>a; //pagsusulat ng totoong numero sa isang binary file fwrite(&a, sizeof(double), 1, f); //
malapit na
file fclose(f); system("pause"); bumalik 0; HALIMBAWA: Ipakita ang mga nilalaman ng binary file D:\\game\\noobs.dat na nilikha sa nakaraang gawain #include "stdafx.h" #isama gamit ang namespace std; int main() setlocale(LC_ALL, "RUS"); int n, i; doble *a; FILE *f; //ilarawan ang variable ng file //buksan ang umiiral na binary file sa read mode //basahin ang isang integer mula sa file papunta sa variable n //output n sa screen cout<<"n="< //paglalaan ng memorya para sa isang hanay ng mga n numero a=bagong double[n]; //basahin ang mga tunay na numero mula sa file papunta sa array a //output ang array sa screen para sa (i=0; i cout< cout< //
malapit na
file fclose(f); system("pause"); bumalik 0; Binary file- sunud-sunod na istraktura ng data, pagkatapos buksan ang isang file, ang unang byte na nakaimbak dito ay magagamit. Maaari kang magsulat o magbasa ng data mula sa isang file nang sunud-sunod. Sabihin nating kailangan mong bilangin ang ikalabinlimang numero, at pagkatapos ay ang una. Gamit ang sunud-sunod na pag-access maaari itong gawin sa sumusunod na paraan: int n, i; doble a; FILE *f; f=fopen("D:\\game\\noobs.dat", "rb"); para sa (i=0; i<15; i++)
fclose(f); f=fopen("D:\\game\\noobs.dat", "rb"); fread(&a, sizeof(double), 1, f); fclose(f); Tulad ng nakikita mo, ang pagbabasa ng mga numero mula sa isang file at pagkatapos ay muling buksan ang file ay hindi ang pinaka-maginhawang paraan. Magiging mas maginhawang gamitin ang function na fseek upang ilipat ang pointer ng file sa isang ibinigay na byte. int fseek(FILE *filename, mahabang int offset, int pinanggalingan); Itinatakda ng function ang kasalukuyang posisyon ng file pointer F alinsunod sa mga halaga ng pinagmulan at offset. Ang offset na parameter ay katumbas ng bilang ng mga byte kung saan ang file pointer ay ma-offset kaugnay sa pinagmulang tinukoy ng origin parameter. Ang value para sa origin parameter ay dapat isa sa mga sumusunod na offset value na tinukoy sa stdio.h header: SEEK_SET - mula sa simula ng file; SEEK_CUR - mula sa kasalukuyang posisyon; SEEK_END - mula sa dulo ng file. Ang function ay nagbabalik ng isang zero na halaga kung ang operasyon ay matagumpay, hindi-zero kung ang isang pagkabigo ay naganap sa panahon ng offset execution Ang function ng fseek ay aktwal na nagpapatupad ng direktang pag-access sa anumang halaga sa isang file. Kailangan mo lang malaman ang lokasyon (byte number) ng value sa file. Tingnan natin ang paggamit ng direktang pag-access sa mga binary file gamit ang sumusunod na problema bilang isang halimbawa. HALIMBAWA Sa binary file na D:\\game\\noobs.dat na ginawa kanina, palitan ang pinakamalaki at pinakamaliit na totoong numero. Ang algorithm para sa paglutas ng problema ay binubuo ng mga sumusunod na yugto: pagbabasa ng reals mula sa isang file papunta sa array a. maghanap sa array a para sa maximum (max) at minimum (min) na mga halaga at ang kanilang mga numero (imax, imin). paglipat ng file pointer sa pinakamataas na halaga at pagsusulat ng min. paglipat ng file pointer sa pinakamababang halaga at max. Nasa ibaba ang teksto ng programa para sa paglutas ng problema sa mga komento. #include "stdafx.h" #isama gamit ang namespace std; int main() setlocale(LC_ALL, "RUS"); int n, i, imax, imin; doble *a, max, min; FILE *f; //magbukas ng file sa read-write mode f=fopen("D:\\game\\noobs.dat", "rb+"); //basahin ang numero mula sa file papunta sa variable n //mga tunay na numero sa file fread(&n, sizeof(int), 1, f); cout<<"n="< //maglaan ng memorya para sa pag-iimbak ng mga tunay na numero, //na itatabi sa array a a=bagong double[n]; //basahin mula sa file papunta sa array at totoong mga numero fread(a, sizeof(doble), n, f); //hanapin ang maximum at minimum na mga elemento //sa array a at ang kanilang mga index para sa (imax=imin=0, max=min=a, i=1; i kung (a[i]> max) max=a[i]; kung (a[i] min=a[i]; //
gumagalaw
panturo
Upang
maximum
elemento fseek(f, sizeof(int)+imax*sizeof(double), SEEK_SET); //magsulat ng min sa halip na maximum na elemento ng file fwrite(&min, sizeof(double), 1, f); //
gumagalaw
panturo
Upang
pinakamababa
elemento fseek(f, sizeof(int)+imin*sizeof(double), SEEK_SET); //isulat ang max sa halip na ang minimum na elemento ng file fwrite(&max, sizeof(double), 1, f); // pagsasara ng file fclose(f); //libreng memorya tanggalin [
]a; system("pause"); Karamihan sa mga programa sa computer ay gumagana sa mga file, at samakatuwid mayroong pangangailangan na lumikha, magtanggal, magsulat, magbasa, magbukas ng mga file. Ano ang file? Ang file ay isang pinangalanang hanay ng mga byte na maaaring maimbak sa ilang storage device. Well, ngayon ay malinaw na ang isang file ay nangangahulugan ng isang tiyak na pagkakasunud-sunod ng mga byte na may sarili nitong natatanging pangalan, halimbawa file.txt. Ang mga file na may parehong mga pangalan ay hindi matatagpuan sa parehong direktoryo. Ang pangalan ng file ay tumutukoy hindi lamang sa pangalan nito, kundi pati na rin sa extension nito, halimbawa: file.txt at file.dat —
iba't ibang mga file, bagama't mayroon silang parehong mga pangalan. Mayroong isang bagay bilang isang buong pangalan ng file - ito ang buong address sa direktoryo ng file na nagpapahiwatig ng pangalan ng file, halimbawa: D:\docs\file.txt. Mahalagang maunawaan ang mga pangunahing konseptong ito, kung hindi, magiging mahirap na magtrabaho sa mga file. Upang gumana sa mga file kailangan mong magsama ng isang header file Ang file I/O ay katulad ng karaniwang I/O, ang pagkakaiba lang ay ang I/O ay ginaganap sa isang file sa halip na sa screen. Kung ang I/O sa mga karaniwang device ay ginaganap gamit ang cin at cout objects, pagkatapos ay upang ayusin ang file I/O ito ay sapat na upang lumikha ng iyong sariling mga bagay na maaaring magamit nang katulad ng cin at cout operator. Halimbawa, kailangan mong lumikha ng isang text file at isulat ang linyang Paggawa sa mga file sa C++ dito. Upang gawin ito kailangan mong gawin ang mga sumusunod na hakbang: Bakit kailangang lumikha ng isang ofstream object sa halip na isang ifstream object? Dahil kailangan mong magsulat sa isang file, at kung kailangan mong magbasa ng data mula sa isang file, gagawa ng ifstream class object. // lumikha ng isang bagay para sa pagsulat sa file ng stream /*pangalan ng object*/; // object ng klase ng stream Tawagan natin ang object fout. Ito ang makukuha natin: Ofstream fout; Bakit kailangan natin ng isang bagay? Ang bagay ay kinakailangan upang makapagsulat sa isang file. Nagawa na ang object, ngunit hindi nauugnay sa file kung saan kailangang isulat ang string. Fout.open("cppstudio.txt"); // iugnay ang bagay sa file Sa pamamagitan ng dot operation, nagkakaroon kami ng access sa open() class method, kung saan ipinapahiwatig namin ang pangalan ng file sa mga panaklong. Ang tinukoy na file ay malilikha sa kasalukuyang direktoryo na may programa. Kung mayroong isang file na may parehong pangalan, ang umiiral na file ay papalitan ng bago. Kaya, bukas ang file, ang natitira lamang ay isulat ang kinakailangang linya dito. Ginagawa ito tulad nito: Fout<< "Работа с файлами в С++"; // запись строки в файл
Gamit ang stream operation kasabay ng fout object, ang string na Paggawa gamit ang mga file sa C++ ay isinusulat sa isang file. Dahil hindi na kailangang baguhin ang mga nilalaman ng file, dapat itong sarado, iyon ay, ang bagay ay dapat na ihiwalay mula sa file. Fout.close(); // isara ang file Resulta - nilikha ang isang file gamit ang linyang Paggawa gamit ang mga file sa C++. Maaaring pagsamahin ang mga hakbang 1 at 2, iyon ay, sa isang linya, lumikha ng isang bagay at iugnay ito sa isang file. Ginagawa ito tulad nito: Ofstream fout("cppstudio.txt"); // gumawa ng object ng class ofstream at iugnay ito sa cppstudio.txt file Pagsamahin natin ang lahat ng code at kunin ang sumusunod na programa. // file.cpp: Tinutukoy ang entry point para sa console application. #include "stdafx.h" #include Ito ay nananatiling suriin na ang programa ay gumagana nang tama, at upang gawin ito, buksan ang file cppstudio.txt at tingnan ang nilalaman nito, dapat itong - Paggawa gamit ang mga file sa C++. Ang programa ay nagpapakita ng dalawang paraan upang magbasa mula sa isang file, ang una ay gumagamit ng paglipat ng operasyon sa isang stream, ang pangalawa ay gumagamit ng function. getline() . Sa unang kaso, ang unang salita lang ang binabasa, at sa pangalawang kaso, isang string na 50 character ang haba ang binabasa. Ngunit dahil wala pang 50 character ang natitira sa file, binabasa ang mga character hanggang sa at kasama ang huli. Pakitandaan na ang pagbabasa sa pangalawang pagkakataon (linya 17) ay nagpatuloy pagkatapos ng unang salita, at hindi mula sa simula, dahil ang unang salita ay nabasa salinya 14. Ang resulta ng programa ay ipinapakita sa Figure 1. Paggawa gamit ang mga file sa C++ Upang magpatuloy, pindutin ang anumang key. . . Figure 1 - Paggawa gamit ang mga file sa C++ Ang programa ay gumana nang tama, ngunit ito ay hindi palaging nangyayari, kahit na ang lahat ay maayos sa code. Halimbawa, ang pangalan ng isang hindi umiiral na file ay ipinasa sa programa o nagkaroon ng error sa pangalan. ano kaya? Sa kasong ito, walang mangyayari sa lahat. Ang file ay hindi mahahanap, na nangangahulugang hindi ito maaaring basahin. Samakatuwid, babalewalain ng compiler ang mga linya kung saan ginagawa ang trabaho sa file. Bilang resulta, ang programa ay lalabas nang tama, ngunit walang ipapakita sa screen. Tila ito ay isang ganap na normal na reaksyon sa gayong sitwasyon. Ngunit ang isang simpleng user ay hindi mauunawaan kung ano ang nangyayari at kung bakit ang linya mula sa file ay hindi lumitaw sa screen. Kaya, upang gawing napakalinaw ang lahat, ang C++ ay nagbibigay ng gayong function - is_open(), na nagbabalik ng mga halaga ng integer: 1 - kung matagumpay na nabuksan ang file, 0 - kung hindi nabuksan ang file. Baguhin natin ang programa sa pagbubukas ng isang file, upang kung ang file ay hindi bukas, isang kaukulang mensahe ay ipinapakita. // file_read.cpp: Tinutukoy ang entry point para sa console application. #include "stdafx.h" #include Ang resulta ng programa ay ipinapakita sa Figure 2. Hindi mabuksan ang file! Upang magpatuloy, pindutin ang anumang key. . . Figure 2 - Paggawa gamit ang mga file sa C++ Tulad ng makikita mula sa Figure 2, iniulat ng programa na imposibleng buksan ang file. Samakatuwid, kung ang programa ay gumagana sa mga file, inirerekomenda na gamitin ang function na ito, is_open(), kahit na sigurado ka na ang file ay umiiral. Tinutukoy ng mga mode ng pagbubukas ng file kung paano ginagamit ang mga file. Upang itakda ang mode, ang klase ng ios_base ay nagbibigay ng mga constant na tumutukoy sa mode ng pagbubukas ng file (tingnan ang Talahanayan 1). Ang mga mode ng pagbubukas ng file ay maaaring itakda nang direkta kapag lumilikha ng isang bagay o kapag tumatawag sa open() function .
Ofstream fout("cppstudio.txt", ios_base::app); // buksan ang file upang magdagdag ng impormasyon sa dulo ng file fout.open("cppstudio.txt", ios_base::app); // buksan ang file upang magdagdag ng impormasyon sa dulo ng file Maaaring pagsamahin ang mga mode ng pagbubukas ng file gamit ang isang bitwise na lohikal na operasyon o| , halimbawa: ios_base::out | ios_base::trunc - nagbubukas ng file para sa pagsusulat pagkatapos itong i-clear. Ang mga bagay ng klase ng ofstream, kapag nauugnay sa mga file, bilang default ay naglalaman ng mga mode ng pagbubukas ng file ios_base::out | ios_base::trunc .
Ibig sabihin, malilikha ang file kung wala ito. Kung umiiral ang file, ang mga nilalaman nito ay tatanggalin, at ang file mismo ay magiging handa para sa pagsulat. Ang mga object ng ifstream class, kapag nauugnay sa isang file, ay may default na file opening mode ios_base::in - ang file ay bukas read-only. Ang mode ng pagbubukas ng file ay tinatawag ding flag para sa pagiging madaling mabasa, gagamitin namin ang terminong ito sa hinaharap. Ang talahanayan 1 ay hindi nakalista ang lahat ng mga flag, ngunit ang mga ito ay dapat na sapat upang makapagsimula ka. Tandaan na ang ate at app flag ay halos magkapareho sa paglalarawan, pareho nilang inililipat ang pointer sa dulo ng file, ngunit pinapayagan lang ng app flag ang pagsusulat sa dulo ng file, at ang ate flag ay inililipat lang ang flag sa dulo. ng file at hindi nililimitahan kung saan isusulat. Bumuo tayo ng isang programa na, gamit ang sizeof() na operasyon, ay kakalkulahin ang mga katangian ng mga pangunahing uri ng data sa C++ at isulat ang mga ito sa isang file. Mga pagtutukoy: Ang pagsusulat sa isang file ay dapat gawin sa sumusunod na format: /* uri ng data byte max na halaga bool = 1 255.00 char = 1 255.00 short int = 2 32767.00 unsigned short int = 2 65535.00 int = 4 2147483647.00 unsigned int = 4 7294 unsigned int = 4 4294967295.00 float = 4 2147483647.00 long float = 8 9223372036854775800.00 double = 8 9223372036854775800.00 */ Ang nasabing programa ay binuo na mas maaga sa seksyon, ngunit doon ang lahat ng impormasyon tungkol sa mga uri ng data ay nai-output sa karaniwang output device, at kailangan nating gawing muli ang programa upang ang impormasyon ay nakasulat sa isang file. Upang gawin ito, kailangan mong buksan ang file sa write mode, na may paunang truncation ng kasalukuyang impormasyon ng file ( linya 14). Kapag ang file ay nagawa at matagumpay na nabuksan (mga linya 16 - 20), sa halip na ang cout statement, sa linya 22 ginagamit namin ang fout object. kaya, sa halip na screen, ang impormasyon tungkol sa mga uri ng data ay isusulat sa isang file. // write_file.cpp: Tinutukoy ang entry point para sa console application. #include "stdafx.h" #include Imposibleng hindi mapansin na ang mga pagbabago sa programa ay minimal, at lahat salamat sa katotohanan na ang karaniwang input/output at file input/output ay ginagamit sa eksaktong parehong paraan. Sa pagtatapos ng programa, salinya 45Tahasang isinara namin ang file, kahit na hindi ito kinakailangan, ngunit itinuturing na mahusay na kasanayan sa programming. Ito ay nagkakahalaga ng pagpuna na ang lahat ng mga function at manipulator na ginagamit upang i-format ang karaniwang input/output ay may kaugnayan din para sa file input/output. Samakatuwid, walang mga error na naganap kapag ang pahayag cout ay pinalitan ng isang bagay palaban.
// file_read.cpp: Tinutukoy ang entry point para sa console application. #include "stdafx.h" #include Mga mode ng pagbubukas ng file
