Natutunan na namin kung paano magsulat ng impormasyon sa isang text file. – Kung hindi mo natutunan kung paano, tingnan ang nakaraang artikulo. Ito ay sinabi at inilarawan nang detalyado
Ngunit paano kung mayroon nang file at kailangan nating basahin ang impormasyon mula dito para sa pagproseso? Sa kabutihang palad, ito ay medyo simple din. Hayaan akong ipaalala sa iyo na mayroong ilang mga pagpipilian para sa pagpapatupad ng gawaing ito ay inilarawan ko lamang ang isa sa mga ito. Ang isang inilarawan ay ang isa na para sa ilang kadahilanan ay tila sa akin personal na pinakamadaling maunawaan.
#isama
int main()
{
char s1 //Babasahin ng variable ang string
ifstream sa (“C:\\\FromC\\myfile.txt” ); //Buksan ang file upang basahin ang impormasyon
sa >>s1 ; //basahin ang linya
in.close() // Pagsasara ng file
cout<
bumalik 0;
}
Narito ang pinakasimpleng programa upang basahin ang unang linya mula sa isang text file na matatagpuan sa kahabaan ng landas
C:\\\FromC\\myfile.txt –
Dahil ito ay pagpapatuloy ng nakaraang artikulo, nagpasya akong gamitin ang file na ginawa namin doon. Marahil ay hindi dapat magkaroon ng anumang mga paghihirap dito.
Ngunit bumalik tayo sa code. Una naming binuksan ang file upang basahin ang impormasyon mula dito, para dito ginagamit namin ang utos ifstream sa mga bracket ipinapahiwatig namin ang alinman sa pangalan ng file o ang landas sa file, tulad ng ginawa ko. (“C:\\\FromC\\myfile.txt” );
Kapag nagbukas kami ng isang file upang basahin ang isang bagay mula dito, nagdeklara kami ng isang variable na tulad ng char –
char s1
Ngayon ang kailangan lang nating gawin ay italaga ang variable ng halaga ng string mula sa file. Ginagawa namin ito bilang isang koponan sa
Bigyang-pansin ang mga anggulo ng bracket sa >>
Sa totoo lang, tulad ng dapat na malinaw mula sa mga komento sa code ng programa, upang maitalaga ng variable ang read value, dapat nating isulat ito pagkatapos sa >>
sa >>s1 ;
Mukhang hindi ito isang partikular na mahirap na gawain, lalo na kung ganap mong pinagkadalubhasaan at natutunan mong gamitin ang materyal mula sa nakaraang artikulo - lahat ay ganap na pareho, 2 utos lamang ang naiiba
Paglikha ng isang file at pagsusulat ng C++ na impormasyon dito
ofstream palabas
( Pangalan ng file );
palabas<< (String na isusulat);
palabas.close();
=============================
Pagbabasa ng teksto mula sa isang file at pag-print ng teksto sa screen sa C++
ifstream sa
(Pangalan ng file );
sa>>
(Binabasa ang linya);
sa.close();(Isara ang file)
============================
Sumulat tayo ng isang simpleng programa na magbabasa ng text input mula sa keyboard at isulat ito sa isang file:
#isama
#isama
int main()
{
\\
3 linya sa hinaharap
clrscsr(); // Nililinis ang screen
cout<<“Wwedi pervuu stroku”
;
cin >>a ; endl ;
cout<<“Wwedi wtoruu stroku”
;
cin >>b ; endl ;
cout<<“Wwedi tretuu stroku”
;
cin >>c ; endl ;
clrscr(); //
/*Simulang magtrabaho kasama ang file*/
ofstream out (“C:\\\FromC\\myfile.txt” ); //Pagbukas ng file para sa pagsusulat
palabas<Isulat ang unang linya
palabas<Isulat ang pangalawang linya
palabas<
out.close(); // Pagsasara ng file
// I-reset ang mga variable sa zero
para sa (int i =0 ;i<=255
;i
++)
(a =*“” ; b =*“” ; c =*“” ;)
ifstream in(“C:\\\FromC\\myfile.txt” );
sa >>a >>b >>c ; //Binabasa namin ang bawat bagong linya sa isang bagong variable
in.close(); // Pagsasara ng file
/* */
para sa (i =0 ;a !=*“” ;i ++)
{
kung (i >sizeof(a )) masira ;
cout<
}
cout<<“\n”
; \\
/* */
{
kung (i >sizeof(b)) masira ;
cout<
}
cout<<“\n”
; \\
Inilipat ang cursor sa isang bagong linya
/* */
para sa (i =0 ;с !=*“” ;i ++)
{
kung (i >sizeof(c )) masira ;
cout<<с
;
}
bumalik 0;
}
===================
Sa mga halimbawa sa itaas mayroong isang tulad MALAKI kapintasan. Kung susubukan naming magpasok ng isang linya na naglalaman ng mga puwang, hindi gagana ang programa ayon sa kailangan namin. Marahil, hindi lamang ako, kundi pati na rin ang maraming iba pang mga tao ang nakatagpo ng error na ito. Samakatuwid, iniiwan ko ang maling code upang makita mo kung ano ang maaari mong makaharap.
Dahil walang mga libro sa bahay, muli akong nagsimulang magsaliksik sa Internet at nakakita ng maraming lahat ng uri ng sopistikadong kalokohan. Pero kahit papaano nakahanap ako ng solusyon sa problema ko.
Nakatulong ito na basahin ko iyon cout sumusuporta sa kanyang mga pamamaraan. At sa Internet lahat ng payo ay napupunta sa paggamit ng function getline Sa kabutihang-palad para sa akin, nalaman ko kung paano gamitin ang function na ito nang napakabilis at pagkatapos ay ginamit ito sa code.
Sa pangkalahatan, ito ay nagkakahalaga ng pagbanggit at paglalarawan ng function na ito, ngunit sa ngayon ay hindi ko talaga maintindihan ito, naiintindihan ko lang na kailangan itong gamitin at naiintindihan ko kung paano, kaya magbibigay ako ng isang mas tamang halimbawa ng aming programa na binuo. :
#isama
#isama
int main()
{
char a,b,c; \\
3 linya sa hinaharap
clrscsr(); // Nililinis ang screen
/* Ipasok ang mga halaga para sa mga variable*/
cout<<“Wwedi pervuu stroku”
;
cin.getline(a, sizeof(a)); endl ;
cout<<“Wwedi wtoruu stroku”
;
cin.getline(a, sizeof(b)); endl ;
cout<<“Wwedi tretuu stroku”
;
cin.getline(a, sizeof(c)); endl ;
clrscr(); //Matapos ipasok ang mga halaga, na-clear ang screen
/*Simulang magtrabaho kasama ang file*/
ofstream out (“C:\\\FromC\\myfile.txt”); // Pagbukas ng file para sa pagsusulat
palabas<Isulat ang unang linya
palabas<Isulat ang pangalawang linya
palabas<
out.close(); // Pagsasara ng file
// I-reset ang mga variable sa zero
para sa (int i =0 ;i<=255
;i
++)
(a =*“” ; b =*“” ; c=*“” ;)
/*Magpatuloy sa paggawa sa file*/
kung mag-stream in (“C:\\\FromC\\myfile.txt” );
in.getline(a, sizeof(a));//
A
in.getline(b, sizeof(b));//
Pagbasa ng isang linya sa isang variable b
in.getline(c,sizeof(c));
//
Pagbasa ng isang linya sa isang variable c
in.close(); // Pagsasara ng file
/* Binabasa namin ang unang linya ng character ayon sa karakter at ipinapakita ito sa screen */
para sa (i =0 ;a !=*“” ;i++)
{
kung (i >sizeof(a )) masira ;
cout<
}
cout<<“\n”
; \\
Inilipat ang cursor sa isang bagong linya
/* Binabasa namin ang pangalawang linya ng character sa pamamagitan ng character at ipinapakita ito sa screen */
para sa (i =0 ;b !=*“” ;i ++)
{
kung (i >sizeof(b)) masira ;
cout<
}
cout<<“\n”
; \\
Inilipat ang cursor sa isang bagong linya
/* Binabasa namin ang pangatlong linya ng character ayon sa karakter at ipinapakita ito sa screen */
para sa (i =0 ;с !=*“” ;i++)
{
kung (i>sizeof (c )) masira ;
cout<<с[i];
}
getch(); \\Naghihintay na pindutin ang Enter key
bumalik 0;
}
===================
Ang materyal na ito ay naglalarawan ng isang halimbawa ng character-by-character na pagbabasa ng impormasyon. Dahil hindi ko inilarawan ang pagtatrabaho sa mga variable tulad ng char, kung gayon ang mga nagsisimula ay maaaring makaranas ng ilang abala sa pag-unawa sa code. Hindi ko lang alam kung anong klase char ay may ilang mga kakaiba at naisip na ang lahat ay mas simple. Samakatuwid, ang ilang hindi maintindihan na mga sandali ng programa sa itaas ay mababasa sa susunod na artikulo nagtatrabaho sa char V C++ para sa mga Nagsisimula
Kung hindi, ang ibinigay na halimbawa kung paano magbasa ng mga linya mula sa isang text file sa C++ ay dapat na naa-access at medyo naiintindihan. Hindi ito ang pinakamainam na opsyon sa pagpapatupad sa ngayon, at napalampas ko ang ilang mahahalagang punto, ngunit dahil nagsisimula na tayong matutunan ang wikang C++, sapat na ito sa ngayon. Mamaya ay malamang na makarating ako sa kung ano ang napalampas ko, ngunit ngayon kailangan ko lamang na makita ang pinaka kinakailangan.
Kung naiintindihan mo at ko ang materyal na ito, nangangahulugan ito na gumawa kami ng isang maliit na hakbang patungo sa aming propesyonalismo.
Tandaan:
masira ;– Ito ang utos na lumalabas sa loop. Mayroon kaming kung ang cycle counter para sa nagiging mas malaki kaysa sa ipinahayag na laki ng variable char, pagkatapos ay pilit kaming lumabas sa loop
!= –
Ito ang kondisyong itinakda namin. Ang kundisyong ito ay tinutukoy ng hindi pagkakapantay-pantay
kung(a !=b)- Nagbabasa na parang a hindi pantay b
endl ; – Inililipat nito ang cursor sa isang bagong linya sa loob ng console (sa pagkakaintindi ko)
Ang utos na ito ay katulad ng “\n”
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
I-save ang file.
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
Upang magbukas ng text file sa C, gamitin ang fopen function:
FILE *pTextFile = fopen("C:\\TextFile.txt", "r");
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.
Sa pamamagitan ng paraan, ginawa ko ang program na ito 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, alamin natin kung paano gumawa ng isang text file gamit ang programmatically 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.
– paghahambing upang matukoy ang pagkakapantay-pantay o hindi pagkakapantay-pantay.
Ang praktikal na layunin ng isang enumeration ay upang tukuyin ang isang hanay ng mga natatanging simbolikong constant ng isang uri ng integer.
Isang halimbawa ng paggamit ng mga enumerated variable:
mo=1, tu, kami, ika, fr, sa, su ) araw;
puts(“ Ipasok ang araw ng linggo (mula 1 hanggang 7) : ”); scanf(“%d”, &t_day);
w_day = su; simulan = mo;
katapusan = w_day -t_day;
printf(“\n Ang Lunes ay %d araw ng linggo, \ ito na ngayon ang %d araw. \n\
Hanggang sa katapusan ng linggo %d araw (araw). ”, simula, t_day, end);
Resulta ng programa: Ipasok ang araw ng linggo (mula 1 hanggang 7): 2
Ang Lunes ay ang unang araw ng linggo, ngayon ay ang ika-2 araw. Mayroong 5 araw (araw) hanggang sa katapusan ng linggo.
18. Mga file sa wikang C
Ang file ay isang set ng data na matatagpuan sa external na media at isinasaalang-alang sa panahon ng pagproseso bilang isang solong kabuuan. Ang mga file ay naglalaman ng data na nilayon para sa pangmatagalang imbakan.
Mayroong dalawang uri ng mga file: text at binary. Ang mga text file ay isang pagkakasunud-sunod ng mga ASCII na character at maaaring tingnan at i-edit gamit ang anumang text editor.
Ang mga binary (binary) na file ay isang pagkakasunud-sunod ng data, ang istraktura nito ay tinutukoy ng software.
Ang wikang C ay may malaking hanay ng mga function para sa pagtatrabaho sa mga file, karamihan sa mga ito ay matatagpuan sa stdio.h at io.h na mga aklatan.
18.1. Pagbukas ng file
Ang bawat file ay itinalaga ng isang panloob na lohikal na pangalan, na ginagamit sa ibang pagkakataon kapag ina-access ito. Ang lohikal na pangalan (file identifier) ay
pointer sa file, i.e. sa isang lugar ng memorya na naglalaman ng lahat ng kinakailangang impormasyon tungkol sa file. Ang format ng deklarasyon ng file pointer ay ang mga sumusunod:
FILE * pointer sa file; |
|
FILE – pagkakakilanlan ng uri ng istraktura na inilarawan sa karaniwang aklatan |
|
stdio.h at naglalaman ng sumusunod na impormasyon: |
|
uri ng struct( | |
– ang bilang ng mga hindi pa nababasang byte na natitira sa buffer; |
|
ang karaniwang laki ng buffer ay 512 bytes; sa sandaling antas=0, |
|
ang susunod na bloke ng data ay binabasa sa buffer mula sa file; |
|
– bandila ng katayuan ng file – basahin, isulat, idugtong; |
|
– deskriptor ng file, ibig sabihin. bilang na tumutukoy sa hindi nito- |
|
unsigned char hold; | – hindi nailipat na karakter, i.e. ungetc-character; |
– laki ng panloob na intermediate buffer; |
|
unsigned char buffer; | – halaga ng pointer para sa pag-access sa loob ng buffer, i.e. |
tumutukoy sa simula ng buffer, sa simula ng linya, o sa kasalukuyang halaga |
|
Ang halaga ng pointer sa loob ng buffer depende sa mode |
|
ma buffering; |
|
unsigned char *curp; | – kasalukuyang halaga ng pointer para sa pag-access sa loob ng |
fera, ibig sabihin. tumutukoy sa kasalukuyang posisyon sa exchange buffer |
|
sa programa; |
|
unsigned istemp; | - pansamantalang bandila ng file; |
– bandila kapag nagtatrabaho sa isang file; |
|
) FILE; | |
Bago ka magsimulang magtrabaho kasama ang file, i.e. Upang makapagbasa o makapagsulat ng impormasyon sa isang file, dapat itong buksan para ma-access. Para sa layuning ito ang function ay karaniwang ginagamit
FILE* fopen(char* file_name, char* mode);
ito ay nangangailangan ng isang panlabas na representasyon - ang pisikal na pangalan ng isang file sa isang medium (floppy disk, hard drive) at tumutugma ito sa isang lohikal na pangalan.
Pisikal na pangalan, i.e. ang pangalan ng file at path dito ay tinukoy ng unang parameter
– isang linya, halimbawa, “a:Mas_dat.dat” – isang file na pinangalanang Mas_dat.dat na matatagpuan sa isang floppy disk, “d:\\work\\Sved.txt” – isang file na pinangalanang Sved.txt na matatagpuan sa hard magmaneho sa direktoryo ng trabaho.
Pansin! Ang backslash (\), bilang isang espesyal na karakter, ay nakasulat nang dalawang beses sa isang linya.
Sa matagumpay na pagbubukas, ang fopen function ay nagbabalik ng isang pointer sa file (mula dito ay tinutukoy bilang ang file pointer). Sa error, NULL ay ibinalik. Ang sitwasyong ito ay karaniwang nangyayari kapag ang landas sa file na bubuksan ay hindi tinukoy nang tama. Halimbawa, kung sa display class ng aming unibersidad ay tinukoy mo ang isang landas na ipinagbabawal para sa pagsusulat (karaniwan ay d:\work\ ang pinapayagan).
Ang pangalawang parameter ay isang linya na tumutukoy sa file access mode:
w - ang file ay binuksan para sa pagsusulat; kung walang file na may ibinigay na pangalan, ito ay malilikha; kung ang naturang file ay umiiral, pagkatapos ay ang nakaraang impormasyon ay nawasak bago buksan;
r – bubukas ang file para sa read only; kung walang ganoong file, nangyayari ang isang error;
a – binuksan ang file upang magdagdag ng bagong impormasyon sa dulo;
r+ - ang file ay binuksan para sa pag-edit ng data - parehong pagsusulat at pagbabasa ng impormasyon ay posible;
w+ – kapareho ng para sa r+;
a+ – katulad ng para sa a, tanging pagsusulat lamang ang maaaring gawin kahit saan sa file; Ang pagbabasa ng file ay magagamit din;
t – bubukas ang file sa text mode b – bubukas ang file sa binary mode.
Ang text mode ay naiiba sa binary mode dahil kapag ang isang file ay binuksan bilang isang pares ng text ng mga character na "line feed", ang "carriage return" ay pinalitan ng isang character: "line feed" para sa lahat ng mga function para sa pagsusulat ng data sa file, at para sa lahat ng output function ang character na “line feed” " ay pinapalitan na ngayon ng dalawang character: "line feed", "carriage return".
Bilang default, bubukas ang file sa text mode. Halimbawa: FILE *f; – ang isang pointer sa file f ay ipinahayag;
f = fopen("d:\\work\\Dat_sp.cpp", "w"); – isang file na may lohikal na pangalan f, na may pisikal na pangalan na Dat_sp.cpp, na matatagpuan sa drive d, sa direktoryo ng trabaho, ay binuksan para sa pagsulat; o mas maikli
FILE *f = fopen("d:\\work\\Dat_sp.cpp", "w");
18.2. Pagsasara ng file
Pagkatapos magtrabaho sa isang file, ang pag-access dito ay dapat na sarado. Ginagawa ito ng int fclose (file pointer) function. Halimbawa, mula sa nakaraang halimbawa ang file ay sarado tulad nito: fclose (f);
Upang isara ang maramihang mga file, isang function ay ipinakilala, ipinahayag tulad ng sumusunod: void fcloseall (walang bisa);
Kung kailangan mong baguhin ang access mode para sa isang file, kailangan mo munang isara ang file at pagkatapos ay buksan itong muli, ngunit may iba't ibang mga karapatan sa pag-access. Upang gawin ito, gamitin ang karaniwang function:
FILE* freopen (char*file_name, char *mode, FILE *file_pointer);
Isinasara muna ng function na ito ang file na ipinahayag file_pointer(tulad ng ginagawa ng fopen function), at pagkatapos ay bubuksan ang file na may filename at mga pahintulot na "mode".
Ang wikang C ay may kakayahang magtrabaho kasama ang mga pansamantalang file na kailangan lamang habang tumatakbo ang programa. Sa kasong ito, ginagamit ang function
FILE* tmpfile (walang bisa);
na lumilikha ng isang pansamantalang file sa disk na may "w+b" na mga karapatan sa pag-access pagkatapos makumpleto ang programa o pagkatapos na isara ang pansamantalang file, awtomatiko itong tatanggalin.
18.3. Sumulat – basahin ang impormasyon
Ang lahat ng mga aksyon para sa pagbabasa at pagsulat ng data sa isang file ay maaaring nahahati sa tatlong grupo: character-by-character input-output operations; line-by-line na I/O operations; harangan ang mga operasyon ng I/O.
Tingnan natin ang mga pangunahing function na ginagamit sa bawat isa sa tatlong grupo ng mga operasyon na ito.
I/O ng character-by-character
Sa character-by-character na I/O function, isang character ang natatanggap mula sa isang file o isang character ang ipinadala sa isang file:
Row I/O
Line I/O functions transfer mula sa isang file o sa
I-block ang I/O
Ang mga function ng block I/O ay gumagana sa buong mga bloke
impormasyon: | |
int fread (void*p, insize, | – nagbabasa ng n bloke ng laki ng byte bawat isa mula sa file |
int n, FILE *f) | la f sa isang lugar ng memorya na may pointer p (kinakailangan |
int fwrite (void*p, insize, | maglaan ng memorya nang maaga para sa bloke na basahin); |
– nagsusulat ng n bloke ng laki ng mga byte bawat isa mula sa |
|
int n, FILE *f) | memory area na may pointer p sa file f. |
Ang naka-format na I/O ay ginawa ng mga function.
Huling na-update: 10/31/2015
Klase FileStream kumakatawan sa mga kakayahan ng pagbabasa mula sa isang file at pagsulat sa isang file. Pinapayagan ka nitong magtrabaho kasama ang parehong mga text file at mga binary.
Isaalang-alang natin ang pinakamahalagang katangian at pamamaraan nito:
array - isang hanay ng mga byte kung saan ilalagay ang data na nabasa mula sa file
kinakatawan ng offset ang offset sa mga byte sa array kung saan ilalagay ang mga read byte
count - ang maximum na bilang ng mga byte na babasahin. Kung may mas kaunting mga byte sa file, lahat ng mga ito ay mababasa.
array - isang hanay ng mga byte kung saan isusulat ang data sa file
offset - ang offset sa bytes sa array mula sa kung saan ang mga byte ay nagsisimulang isulat sa stream
count - maximum na bilang ng mga byte na isusulat
Length property: ibinabalik ang haba ng stream sa bytes
Position property: ibinabalik ang kasalukuyang posisyon sa stream
Paraan ng pagbabasa: Nagbabasa ng data mula sa isang file patungo sa isang byte array. Kumukuha ng tatlong parameter: int Read(byte array, int offset, int count) at ibinabalik ang bilang ng mga byte na matagumpay na nabasa. Ang mga sumusunod na parameter ay ginagamit dito:
Pamamaraan long Seek(long offset, SeekOrigin origin): nagtatakda ng posisyon sa stream na may offset ng bilang ng mga byte na tinukoy sa offset parameter.
Paraan ng pagsulat: Sumulat ng data mula sa isang byte array patungo sa isang file. Tumatagal ng tatlong parameter: Sumulat (byte array, int offset, int count)
Kinakatawan ng FileStream ang pag-access ng file sa antas ng byte, kaya, halimbawa, kung kailangan mong magbasa o magsulat ng isa o higit pang mga linya sa isang text file, dapat na i-convert ang byte array sa mga string gamit ang mga espesyal na pamamaraan. Samakatuwid, ang ibang mga klase ay ginagamit upang gumana sa mga text file.
Kasabay nito, kapag nagtatrabaho sa iba't ibang mga binary file na may isang tiyak na istraktura, ang FileStream ay maaaring maging lubhang kapaki-pakinabang para sa pagkuha ng ilang piraso ng impormasyon at pagproseso nito.
Tingnan natin ang isang halimbawa ng pagbabasa at pagsulat sa isang text file:
Console.WriteLine("Magpasok ng linyang isusulat sa file:"); string text = Console.ReadLine(); // pagsulat sa isang file gamit ang (FileStream fstream = bagong FileStream(@"C:\SomeDir\noname\note.txt", FileMode.OpenOrCreate)) ( // convert ang string sa bytes byte array = System.Text.Encoding. Default. GetBytes(text); // pagsulat ng array ng mga byte sa isang file fstream.Write(array, 0, array.Length); fstream = File. OpenRead(@"C:\SomeDir\noname\note.txt")) ( // convert ang string sa byte byte array = new byte; // basahin ang data fstream.Read(array, 0, array. Haba); // decode bytes to string string textFromFile = System.Text.Encoding.Default.GetString(array.WriteLine("Text from file: (0)", textFromFile ) Console.ReadLine();
Tingnan natin ang halimbawang ito. Parehong ginagamit ang pagbabasa at pagsulat ng gamit na pahayag. Ang pahayag na ito ay hindi dapat malito sa paggamit ng direktiba, na kinabibilangan ng mga namespace sa simula ng code file. Ang gamit na pahayag ay nagbibigay-daan sa iyo na lumikha ng isang bagay sa isang bloke ng code, sa pagkumpleto kung saan ang Dispose method ng bagay na iyon ay tinatawag, at sa gayon ang bagay ay nawasak. Sa kasong ito, ang variable ng fstream ay nagsisilbing isang bagay.
Ang fstream object ay nilikha sa dalawang magkaibang paraan: sa pamamagitan ng constructor at sa pamamagitan ng isa sa mga static na pamamaraan ng klase ng File.
Dito, dalawang parameter ang ipinapasa sa constructor: ang file path at ang FileMode enumeration. Isinasaad ng enumeration na ito ang file access mode at maaaring kunin ang mga sumusunod na value:
Idagdag: kung umiiral ang file, idaragdag ang teksto sa dulo ng file. Kung ang file ay hindi umiiral, ito ay nilikha. Ang file ay binuksan para sa pagsulat lamang.
Lumikha : Isang bagong file ang nilikha. Kung mayroon nang ganoong file, ito ay mapapatungan
CreateNew : Isang bagong file ang ginawa. Kung mayroon nang ganoong file, ang application ay magtapon ng isang error
Buksan: Nagbubukas ng file. Kung ang file ay hindi umiiral, ang isang pagbubukod ay itinapon
OpenOrCreate : kung ang file ay umiiral, ito ay bubuksan, kung hindi, ang isang bago ay nilikha
Putulin: Kung ang file ay umiiral, ito ay mapapatungan. Ang file ay binuksan para sa pagsulat lamang.
Ang static na OpenRead na paraan ng klase ng File ay nagbubukas ng file para sa pagbabasa at nagbabalik ng isang FileStream object.
Ang FileStream class constructor ay mayroon ding ilang mga overload na nagbibigay-daan sa iyong mas tumpak na i-customize ang object na ginagawa. Ang lahat ng mga bersyon na ito ay maaaring matingnan sa msdn.
Parehong ginagamit ang pagsusulat at pagbabasa ng Encoding.Default na encoding object mula sa System.Text namespace. Sa kasong ito, ginagamit namin ang dalawa sa mga pamamaraan nito: GetBytes upang makakuha ng isang byte array mula sa isang string at GetString upang makakuha ng isang string mula sa isang byte array.
Bilang resulta, ang string na ipinasok namin ay nakasulat sa file note.txt. Sa esensya, ito ay isang binary file (hindi isang text file), bagama't kung magsusulat lamang tayo ng isang linya dito, maaari nating tingnan ang file na ito sa isang form na nababasa ng tao sa pamamagitan ng pagbubukas nito sa isang text editor. Gayunpaman, kung sumulat kami ng mga random na byte dito, halimbawa:
Fstream.WriteByte(13); fstream.WriteByte(103);
Pagkatapos ay maaaring magkaroon tayo ng mga problema sa pag-unawa dito. Samakatuwid, ang mga hiwalay na klase ay idinisenyo upang gumana nang direkta sa mga text file - StreamReader at StreamWriter.
Random na pag-access sa mga file
Kadalasan ang mga binary file ay kumakatawan sa isang partikular na istraktura. At, alam ang istrakturang ito, maaari naming kunin ang kinakailangang piraso ng impormasyon mula sa file o, sa kabaligtaran, magsulat ng isang tiyak na hanay ng mga byte sa isang tiyak na lugar sa file. Halimbawa, sa mga wav file, ang audio data mismo ay nagsisimula sa 44 bytes, at hanggang 44 bytes ay mayroong iba't ibang metadata - ang bilang ng mga audio channel, sampling frequency, atbp.
Gamit ang pamamaraang Seek(), makokontrol natin ang posisyon ng stream cursor, simula kung saan binabasa o isinulat ang file. Ang pamamaraang ito ay tumatagal ng dalawang parameter: offset at posisyon sa file. Ang isang posisyon sa isang file ay inilalarawan ng tatlong mga halaga:
SeekOrigin.Begin : simula ng file
SeekOrigin.End : dulo ng file
SeekOrigin.Current : kasalukuyang posisyon sa file
Ang cursor ng stream kung saan nagsisimula ang pagbabasa o pagsusulat ay inilipat pasulong sa pamamagitan ng offset na nauugnay sa posisyong tinukoy bilang pangalawang parameter. Ang offset ay maaaring negatibo, pagkatapos ay gumagalaw ang cursor pabalik, kung positibo, pagkatapos ay pasulong.
Tingnan natin ang isang halimbawa:
Gamit ang System.IO; gamit ang System.Text; class Program ( static void Main(string args) ( string text = "hello world"; // pagsulat sa isang file gamit ang (FileStream fstream = bagong FileStream(@"D:\note.dat", FileMode.OpenOrCreate)) ( / / convert ang string sa bytes input = Encoding.Default.GetBytes(text); // magsulat ng array ng mga byte sa isang file fstream.Write(input, 0, input.Length); ); ilipat ang pointer sa dulo ng file, limang byte sa dulo ng file fstream.Seek(-5, SeekOrigin.End); kasalukuyang posisyon byte output = bagong byte( output, 0, output.Length); // decode ang mga byte sa isang string string textFromFile = Encoding.Default.GetString(output); , textFromFile); sa file ang word na mundo sa salitang house string replaceText = "house"; GetBytes(replaceText , 0, input.Length);
// basahin ang buong file // ibalik ang pointer sa simula ng file fstream.Seek(0, SeekOrigin.Begin);
output = bagong byte;
fstream.Read(output, 0, output.Length);
// decode ang mga byte sa isang string textFromFile = Encoding.Default.GetString(output);
Console.WriteLine("Text mula sa file: (0)", textFromFile); // hello house ) Console.Read();
) )
Output ng console:
Text na nakasulat sa file Text mula sa file: worl Text mula sa file: hello house
FileStream fstream = null; subukan ( fstream = bagong FileStream(@"D:\note3.dat", FileMode.OpenOrCreate); // mga operasyon na may stream ) catch(Exception ex) ( ) sa wakas ( kung (fstream != null) fstream.Close() ;)
Kung hindi namin gagamitin ang gamit na construct, kailangan naming tahasang tawagan ang Close() method: fstream.Close()
Ang mekanismo ng I/O na binuo ni , ay hindi umaayon sa karaniwang tinatanggap na istilo ng object-oriented programming ngayon, bilang karagdagan, ito ay lubos na gumagamit ng mga pagpapatakbo ng pointer, na itinuturing na potensyal na hindi ligtas sa mga modernong secure na code execution environment. Ang isang alternatibo kapag bumubuo ng mga aplikasyon ng aplikasyon ay ang mekanismo ng mga karaniwang klase ng I/O na ibinigay ng pamantayan ng wikang C++.
Pagbubukas ng mga file
Ang pinakakaraniwang ginagamit na mga klase ay ang ifstream para sa pagbabasa, ofstream para sa pagsusulat, at fstream para sa pagbabago ng mga file.
Ang lahat ng mga sinulid na klase ng I/O ay hindi direktang hinango mula sa karaniwang ninuno na ios, na ganap na namamana ng functionality nito. Kaya, ang mode ng pagbubukas ng file ay tinukoy ng miyembro ng data ng open_mode na uri ng enumeration, na tinukoy bilang sumusunod:
Enum open_mode ( app, binary, in, out, trunc, ate );
Nasa ibaba ang mga posibleng halaga ng mga flag at ang kanilang layunin.
Halimbawa, para magbukas ng file na may pangalang test.txt para magbasa ng data sa binary form, isusulat mo ang:
ifstream file; file.open("test.txt", ios::in | ios::binary);
Ang lohikal na O operator (|) ay nagbibigay-daan sa iyo na lumikha ng isang mode na may anumang kumbinasyon ng mga flag. Kaya, upang kapag nagbubukas ng isang file sa pamamagitan ng pagpasok, hindi mo sinasadyang ma-overwrite ang isang umiiral na file na may parehong pangalan, dapat mong gamitin ang sumusunod na form:
Ofstream na file; file.open("test.txt", ios::out | ios::app);
Ipinapalagay na ang kaukulang file ng header ay kasama sa proyekto:
#isama
Upang suriin kung matagumpay na nabuksan ang file, maaari mong gamitin ang construct
If (!file) ( //Handling file opening error)
Mga operator ng pagsasama at pagkuha
Na-override sa mga klase sa paghawak ng file operator ng pagsasama (<<) записывает данные в файловый поток. Как только вы открыли файл для записи, можно записывать в него текстовую строку целиком:
file<< "Это строка текста";
Maaari ka ring magsulat ng text string sa mga bahagi:
file<< "Это " << "строка " << "текста";
Tinatapos ng endl statement ang line input na may carriage return:
file<< "Это строка текста" << endl;
Gamit ang kasamang operator, madaling isulat ang mga halaga ng mga variable o elemento ng array sa isang file:
Ofstream file("Temp.txt"); char buff = "Ang text array ay naglalaman ng mga variable"; int vx = 100; lumutang pi = 3.14159; file<< buff << endl << vx << endl << pi << endl;
Bilang resulta ng pagpapatupad ng code, tatlong linya ng Temp.txt text file ang nabuo:
Ang text array ay naglalaman ng mga variable 100 3.14159
Tandaan na ang mga numerong halaga ay isinulat sa file bilang mga string ng teksto sa halip na mga binary na halaga.
Operator sa pagkuha(>>) ay gumagawa ng kabaligtaran na epekto. Mukhang upang mag-extract ng mga character mula sa Temp.txt file na isinulat nang mas maaga, susulat ka ng code tulad ng sumusunod:
Ifstream file("Temp.txt"); char buff; int vx; lumutang pi; file >> buff >> vx >> pi;
Gayunpaman, titigil ang operator ng pagkuha sa unang delimiter na makikita nito (space, tab, o newline). Kaya, kapag nag-parse ng pangungusap na "Text array ay naglalaman ng mga variable," tanging ang salitang "Text" ang isusulat sa buff array, ang espasyo ay hindi papansinin, at ang salitang "array" ay magiging halaga ng buong vx variable, at code. "magkakagulo" ang pagpapatupad na may hindi maiiwasang paglabag sa istruktura ng data. Susunod, kapag tinatalakay ang klase ng ifstream, ipapakita namin kung paano maayos na ayusin ang pagbabasa ng file mula sa nakaraang halimbawa.
ifstream class: pagbabasa ng mga file
Tulad ng iminumungkahi ng pangalan, ang klase ng ifstream ay idinisenyo upang mag-input ng isang stream ng file. Ang mga pangunahing pamamaraan ng klase ay nakalista sa ibaba. Karamihan sa mga ito ay minana mula sa klase ng istream at na-overload upang i-extend ang parent functionality. Halimbawa, ang get function, depende sa parameter ng tawag, ay maaaring magbasa hindi lamang ng isang character, kundi pati na rin ng isang bloke ng mga character.
Ngayon ay malinaw na kung paano kailangang baguhin ang nakaraang halimbawa upang ang paggamit ng data extraction operator ay nagbibigay ng inaasahang resulta:
Ifstream file("Temp.txt"); char buff; int vx; lumutang pi; file.getline(buff, sizeof(buff)); file >> vx >> pi:
Babasahin ng getline method ang unang linya ng file hanggang sa dulo, at ang >> operator ay magtatalaga ng mga value sa mga variable.
Ang sumusunod na halimbawa ay nagpapakita ng pagdaragdag ng data sa isang text file at pagkatapos ay binabasa ang buong file. Ang isang while(1) loop ay ginagamit sa halip na while(!file2.eof()) para sa mga kadahilanang tinalakay sa .
#isama
if (file2.eof()) break;
#isama
Ang code na ito sa ilalim ng Windows OS ay nakasalalay din sa pagkakaroon ng isang bagong linya na karakter sa huling linya ng file ay magiging mas maaasahan kung gawin ito:
Habang (1) ( if (file.eof()) break; file.getline(str, sizeof(str)); cout<< str << endl; }
Ang mga tahasang tawag sa bukas at pagsasara ng mga pamamaraan ay hindi kinakailangan. Sa katunayan, ang pagtawag sa tagabuo na may isang argumento ay nagbibigay-daan sa iyo upang agad na buksan ang file sa sandali ng paglikha ng sinulid na file object:
Ifstream file("test.txt");
Sa halip na malapit na paraan, maaari mong gamitin ang delete operator, na awtomatikong tatawag sa destructor ng file object at isasara ang file. Ang while loop code ay nagsisiguro ng wastong end-of-file checks.
ofstream class: pagsulat ng mga file
Ang klase ng ofstream ay idinisenyo upang mag-output ng data mula sa isang file stream. Ang mga sumusunod ay naglilista ng mga pangunahing pamamaraan ng klase na ito.
Ang inclusion operator na inilarawan kanina ay maginhawa para sa pag-aayos ng pagsulat sa isang text file:
Ofstream file("temp.txt"); kung bumalik ang (!file); para sa (int i=1; i<=3; i++) file << "Строка " << i << endl; file.close();
Binary file
Sa prinsipyo, ang binary data ay itinuturing na parang text data. Ang pagkakaiba ay kung ang binary data ay nakasulat sa isang partikular na lohikal na istraktura, dapat itong basahin mula sa isang file patungo sa isang variable ng parehong uri ng istraktura.
Ang unang parameter ng mga paraan ng pagsulat at pagbabasa (ang address ng write/read block) ay dapat sa uri ng pointer ng character char * , kaya kinakailangang magsagawa ng tahasang conversion ng uri ng address ng void * na istraktura. Tinutukoy ng pangalawang parameter na ang mga binary block ng file ay may pare-parehong laki ng byte anuman ang aktwal na haba ng record. Ang sumusunod na application ay nagbibigay ng isang halimbawa ng paglikha at pagpapakita ng data sa isang simpleng notebook. Ang mga entry ng file ay pagkatapos ay basahin nang sunud-sunod at ipinapakita sa console.
#isama
Bilang resulta ng pagpapatupad ng code na ito, nabuo ang isang binary file na Notebook.dat mula sa tatlong bloke ng 80 byte bawat isa (ipagpalagay na ang mga character ay single-byte). Naturally, maaari kang gumamit ng iba pang mga paraan ng pag-thread at magsagawa ng anumang mga operasyon sa mga patlang ng isang partikular na istraktura ng data.
klase ng fstream: random na pag-access sa file
Ipagpalagay natin na mayroon tayong 100 entries sa ating notebook, at gusto nating bilangin ang ika-50. Siyempre, maaari mong ayusin ang isang loop at basahin ang lahat ng mga tala mula sa una hanggang sa ibinigay na isa. Malinaw na ang isang mas naka-target na solusyon ay upang itakda ang pos file position pointer nang direkta sa entry 50 at basahin mula dito:
Ifstream ifile("Notebook.dat", ios::binary); int pos = 49 * sizeof(Mga Tala); ifile.seekg(pos); // hanapin ang 50th Notes note;
//Notes – ang istrukturang “record” na inilarawan sa itaas ifile.read((char*)&Note, sizeof(Notes));
Ang ganitong mga operasyon sa paghahanap ay epektibo kung ang file ay binubuo ng mga talaan ng kilala at pare-pareho ang laki. Upang palitan ang mga nilalaman ng isang arbitrary na tala, kailangan mong buksan ang output stream sa modification mode:
Ofstream ofile ("Notebook.dat", ios::binary | ios::ate); int pos = 49 * sizeof(Mga Tala); ofile seekp(pos); // search for the 50th entry Notes Note50 = ("Yeltsin Boris Nikolaevich", "095-222-3322", 64); ofile.write((char*)&Tandaan, sizeof(Notes)); // kapalit
Sa wakas, posibleng magbukas ng file nang sabay-sabay para sa pagbabasa/pagsusulat, gamit ang mga pamamaraang minana ng fstream streaming class mula sa mga nauna nito. Dahil ang klase ng fstream ay nagmula sa istream at ostream (mga magulang ng ifstream at ofstream ayon sa pagkakabanggit), lahat ng mga pamamaraan na nabanggit kanina ay magagamit sa application.
Ipinapakita ng sumusunod na halimbawa ang muling pagsasaayos ng una at pangatlong mga entry sa Notebook.dat file.
#isama
Sa constructor ng file object, dapat mong tukuyin ang ios::in at ios::out na mga flag, na nagbibigay-daan sa sabay-sabay na mga operasyon sa pagbasa at pagsulat. Bilang resulta ng pagpapatupad ng code na ito, ang una at pangatlong entry sa Notebook.dat binary file ay ipapalit.
Mayroong karagdagang mga halimbawa sa paksa.
