/* Tunasoma herufi ya mstari wa tatu kwa herufi na kuionyesha kwenye skrini */

kwa (i =0 ;с !=*“" ;i++)
{
ikiwa (i> saizi ya (c)) mapumziko;
koti<<с[i];
}

kupata (); \\Inasubiri kitufe cha Ingiza kibonyezwe
kurudi 0;
}
===================

Nyenzo hii inaelezea mfano wa usomaji wa habari kwa wahusika. Kwa kuwa sikuelezea kufanya kazi na anuwai kama char, basi wanaoanza wanaweza kupata usumbufu katika kuelewa kanuni. Sikujua ni aina gani char ina upekee fulani na ilifikiri kila kitu kilikuwa rahisi zaidi. Kwa hiyo, baadhi ya wakati usioeleweka wa programu hapo juu inaweza kusomwa katika makala inayofuata kufanya kazi na Char V C++ kwa Kompyuta

Vinginevyo, mfano uliopewa wa jinsi ya kusoma mistari kutoka kwa faili ya maandishi katika C ++ inapaswa kupatikana na kueleweka kabisa. Hili sio chaguo bora zaidi la utekelezaji hivi sasa, na nilikosa vidokezo muhimu, lakini kwa kuwa tunaanza kujifunza lugha ya C++, hii inatosha kwa sasa. Baadaye labda nitapata kile nilichokosa, lakini sasa ninahitaji kutambua muhimu zaidi.

Ikiwa wewe na mimi tunaelewa nyenzo hii, inamaanisha tumepiga hatua ndogo kuelekea taaluma yetu.

Kumbuka:
mapumziko;- Hii ndio amri inayotoka kwenye kitanzi. Tunayo ikiwa kihesabu cha mzunguko kwa inakuwa kubwa kuliko saizi iliyotangazwa ya kutofautisha char, kisha tunatoka kwa kitanzi kwa nguvu
!= – Hili ndilo sharti tuliloweka. Hali hii inaonyeshwa na usawa
ikiwa(a!=b)- Inasoma kama a si sawa b

mwisho; - Hii inasogeza mshale kwenye mstari mpya ndani ya koni (kwa kadiri ninavyoelewa)
Amri hii ni sawa na "\n"

Faili za maandishi

Wacha tuangalie kufanya kazi na faili ya maandishi katika C kwa kutumia mfano. Unda faili ya maandishi kwenye hifadhi C inayoitwa TextFile.txt. Andika mistari ifuatayo kwenye faili hii:

Mfuatano_1 123 Mfuatano_11, 456
Kamba_2
Kamba_3

Hifadhi faili.

Na hii ndio nambari ya programu ya C inayofungua faili yetu na kusoma mistari kutoka kwayo:

/* *Mwandishi: @author Subbotin B.P..h> #pamoja na #fafanua LEN 50 int main(batili) ( inaweka("Shughuli za faili za maandishi"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( huweka("Matatizo"); rudisha EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile); rudisha EXIT_SUCCESS; )

Ili kufungua faili ya maandishi katika C, tumia fopen kazi:

FILE *pTextFile = fopen("C:\\TextFile.txt", "r");

Hoja ya kwanza kwa kazi ya fopen inaelekeza kwenye faili, na ya pili inasema kwamba faili imefunguliwa kwa kusoma kutoka kwake.

Tunasoma mistari kwa kutumia fgets kazi:

fgets(cArray, LEN, pTextFile);

Hoja ya kwanza ya kazi ya fgets inaelekeza kwa safu ya herufi ambayo mifuatano iliyopokelewa itahifadhiwa, hoja ya pili ni idadi ya juu ya herufi za kusoma, na ya tatu ni faili yetu.

Baada ya kumaliza kufanya kazi na faili, unahitaji kuifunga:

fclose(pTextFile);

Tunapata:

Barua za Kirusi pia zinaonekana kwenye mistari.

Kwa njia, nilifanya programu hii katika Eclipse. Unaweza kuona jinsi ya kufanya kazi na C/C++ kwenye Eclipse.

Kwa hiyo, tulifungua na kusoma data kutoka kwa faili ya maandishi.

Sasa tutajifunza jinsi ya kuunda faili ya maandishi na kuandika data kwake.

/* Mwandishi: @author Subbotin B.P..h> #include int main(batili) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "Hii ni kamba"; char cNewLine = "\n"; int nVal = 123 ; ikiwa(pTextFile == NULL) ( inaweka("Matatizo"); rudisha EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine); fprintf(pTextFile, "%d", nVal); rudisha EXIT_SUCCESS ;)

Unda faili ya maandishi ili kuandika data kwa:

FILE *pTextFile = fopen("C:\\TextFileW.txt", "w");

ikiwa faili tayari iko, itafunguliwa na data yote kutoka kwake itafutwa.

C-string cString na nambari nVal zimeandikwa na programu kwenye faili ya maandishi. cNewLine ni laini mpya.

Tunaandika data kwa faili ya maandishi kwa kutumia kazi ya fprintf:

fprintf(pTextFile, "%s%c", cString, cNewLine);

hoja ya kwanza hapa ni faili yetu, ya pili ni kamba ya umbizo, ya tatu au zaidi ni idadi ya hoja zinazohitajika kwa umbizo hili.

- kulinganisha kutambua usawa au usawa.

Madhumuni ya vitendo ya kuhesabu ni kufafanua seti ya viunga vya ishara tofauti vya aina kamili.

Mfano wa kutumia anuwai zilizoorodheshwa:

mo=1, tu, sisi, th, fr, sa, su ) siku;

huweka(“ Ingiza siku ya juma (kutoka 1 hadi 7) : ”); scanf(“%d”, &t_day);

siku = siku; start = mo;

mwisho = w_day -t_day;

printf(“\n Jumatatu ni siku %d ya wiki, \ sasa ni siku %d. \n\

Hadi mwisho wa wiki siku %d (siku). ”, anza, t_day, mwisho);

Matokeo ya programu: Ingiza siku ya juma (kutoka 1 hadi 7): 2

Jumatatu ni siku ya 1 ya juma, sasa ni siku ya 2. Kuna siku 5 (siku) hadi mwisho wa juma.

18. Faili katika lugha C

Faili ni seti ya data iliyo kwenye vyombo vya habari vya nje na inachukuliwa kuwa moja wakati wa usindikaji. Faili zina data iliyokusudiwa kuhifadhi kwa muda mrefu.

Kuna aina mbili za faili: maandishi na binary. Faili za maandishi ni mlolongo wa herufi za ASCII na zinaweza kutazamwa na kuhaririwa kwa kutumia kihariri chochote cha maandishi.

Faili za binary (binary) ni mlolongo wa data, muundo ambao umedhamiriwa na programu.

Lugha ya C ina seti kubwa ya vitendakazi vya kufanya kazi na faili, ambazo nyingi zinapatikana katika maktaba ya stdio.h na io.h.

18.1. Kufungua faili

Kila faili imepewa jina la ndani la mantiki, ambalo hutumiwa baadaye wakati wa kuipata. Jina la kimantiki (kitambulisho cha faili) ni

pointer kwa faili, i.e. kwa eneo la kumbukumbu ambalo lina habari zote muhimu kuhusu faili. Umbizo la tamko la pointer ya faili ni kama ifuatavyo:

Kabla ya kuanza kufanya kazi na faili, i.e. Ili kuweza kusoma au kuandika habari kwa faili, lazima ifunguliwe kwa ufikiaji. Kwa lengo hili kazi ni kawaida kutumika

FILE* fopen(char* file_name, char* mode);

inachukua uwakilishi wa nje - jina la kimwili la faili kwenye kati (floppy disk, gari ngumu) na inafanana na jina la mantiki.

Jina la kimwili, i.e. jina la faili na njia yake imeainishwa na parameta ya kwanza

– mstari, kwa mfano, “a:Mas_dat.dat” – faili inayoitwa Mas_dat.dat iko kwenye floppy disk, “d:\\work\\Sved.txt” – faili inayoitwa Sved.txt iko kwenye diski ngumu. endesha kwenye saraka ya kazi.

Makini! Backslash (\), kama tabia maalum, imeandikwa mara mbili kwa mstari.

Baada ya kufunguliwa kwa mafanikio, kitendakazi cha fopen kinarudisha kielekezi kwenye faili (hapa kinajulikana kama kielekezi cha faili). Kwa hitilafu, NULL inarejeshwa. Hali hii kawaida hutokea wakati njia ya faili kufunguliwa imeelezwa vibaya. Kwa mfano, ikiwa katika darasa la maonyesho la chuo kikuu chetu unataja njia ambayo ni marufuku kwa kuandika (kawaida d:\work\ inaruhusiwa).

Kigezo cha pili ni mstari unaobainisha hali ya ufikiaji wa faili:

w - faili inafunguliwa kwa maandishi; ikiwa hakuna faili iliyo na jina lililopewa, itaundwa; ikiwa faili kama hiyo ipo, basi habari ya hapo awali inaharibiwa kabla ya kufunguliwa;

r - faili inafungua kwa kusoma tu; ikiwa hakuna faili kama hiyo, hitilafu hutokea;

a - faili inafunguliwa ili kuongeza habari mpya hadi mwisho;

r + - faili inafunguliwa kwa data ya uhariri - wote kuandika na kusoma habari inawezekana;

w+ - sawa na kwa r+;

a+ - sawa na kwa, kuandika tu kunaweza kufanywa popote kwenye faili; usomaji wa faili pia unapatikana;

t - faili inafungua katika hali ya maandishi; b - faili inafungua katika hali ya binary.

Hali ya maandishi hutofautiana na hali ya jozi kwa kuwa faili inapofunguliwa kama maandishi, jozi ya vibambo "mlisho wa mstari", "rejesho la gari" hubadilishwa na herufi moja: "milisho ya mstari" kwa utendaji wote wa kuandika data kwenye faili. , na kwa vitendaji vyote vya pato herufi "line feed" " sasa inabadilishwa na herufi mbili: "line feed", "carriage return".

Kwa chaguo-msingi, faili inafungua kwa hali ya maandishi. Mfano: FILE *f; - pointer kwa faili f imetangazwa;

f = fopen("d:\\work\\Dat_sp.cpp", "w"); - faili yenye jina la mantiki f, ambayo ina jina la kimwili Dat_sp.cpp, iko kwenye gari d, katika saraka ya kazi, inafunguliwa kwa kuandika; au kwa ufupi zaidi

FILE *f = fopen("d:\\work\\Dat_sp.cpp", "w");

18.2. Kufunga faili

Baada ya kufanya kazi na faili, ufikiaji wake lazima ufungwe. Hii inafanywa na kazi ya int fclose (kiashiria cha faili). Kwa mfano, kutoka kwa mfano uliopita, faili imefungwa kama hii: fclose (f);

Ili kufunga faili nyingi, kazi huletwa, iliyotangazwa kama ifuatavyo: batili fcloseall (batili);

Ikiwa unahitaji kubadilisha hali ya kufikia faili, lazima kwanza ufunge faili na kisha uifungue tena, lakini kwa haki tofauti za kufikia. Ili kufanya hivyo, tumia kazi ya kawaida:

FILE* fungua upya (char*file_name, char *mode, FILE *file_pointer);

Chaguo hili la kukokotoa hufunga kwanza faili iliyotangazwa file_pointer(kama fopen kazi inavyofanya), na kisha kufungua faili na jina la faili na ruhusa "mode".

Lugha ya C ina uwezo wa kufanya kazi na faili za muda ambazo zinahitajika tu wakati programu inaendesha. Katika kesi hii, kazi hutumiwa

FILE* tmpfile (batili);

ambayo huunda faili ya muda kwenye diski na haki za ufikiaji "w + b"; baada ya programu kukamilika au baada ya faili ya muda kufungwa, inafutwa kiatomati.

18.3. Andika - soma habari

Vitendo vyote vya kusoma na kuandika data kwenye faili vinaweza kugawanywa katika vikundi vitatu: shughuli za pembejeo za tabia-na-tabia; shughuli za mstari kwa mstari wa I/O; zuia shughuli za I/O.

Hebu tuangalie kazi kuu zinazotumiwa katika kila moja ya makundi haya matatu ya uendeshaji.

Mhusika-kwa-mhusika I/O

Katika vitendaji vya herufi kwa herufi za I/O, herufi moja inapokelewa kutoka kwa faili au herufi moja inatumwa kwa faili:

Safu ya I/O

Uhamisho wa vitendaji vya I/O kutoka kwa faili au kwenda

Zuia I/O

Zuia vitendaji vya I/O hufanya kazi kwenye vizuizi vyote

I/O iliyoumbizwa inatolewa na vitendaji.

Ilisasishwa mwisho: 10/31/2015

Darasa Mtiririko wa faili inawakilisha uwezo wa kusoma kutoka kwa faili na kuandika hadi faili. Inakuruhusu kufanya kazi na faili za maandishi na zile za binary.

Hebu fikiria mali na mbinu zake muhimu zaidi:

Sifa ya urefu: hurejesha urefu wa mkondo kwa baiti

Sifa ya nafasi: hurejesha nafasi ya sasa katika mkondo

Mbinu ya kusoma: Husoma data kutoka kwa faili hadi safu ndogo. Huchukua vigezo vitatu: int Read(safu ya baiti, int offset, int count) na hurejesha idadi ya baiti zilizosomwa kwa ufanisi. Vigezo vifuatavyo vinatumika hapa:

• safu - safu ya ka ambapo data iliyosomwa kutoka kwa faili itawekwa

  offset inawakilisha kukabiliana na baiti katika safu ambamo baiti zilizosomwa zitawekwa

  hesabu - idadi ya juu ya baiti za kusoma. Ikiwa kuna ka chache kwenye faili, basi zote zitasomwa.

Njia Kutafuta kwa muda mrefu (kukabiliana kwa muda mrefu, asili ya SeekOrigin): huweka nafasi katika mtiririko kwa kukabiliana na idadi ya baiti zilizobainishwa katika kigezo cha kukabiliana.

Njia ya kuandika: Huandika data kutoka kwa safu hadi kwenye faili. Inachukua vigezo vitatu: Andika (safu ya byte, int kukabiliana, int count)

• safu - safu ya ka ambayo data itaandikwa kwa faili

  kukabiliana - kukabiliana na baiti katika safu kutoka ambapo ka huanza kuandikwa kwa mkondo

  hesabu - idadi ya juu ya baiti za kuandikwa

FileStream inawakilisha upatikanaji wa faili kwenye ngazi ya byte, kwa hiyo, kwa mfano, ikiwa unahitaji kusoma au kuandika mstari mmoja au zaidi kwenye faili ya maandishi, basi safu ya byte lazima igeuzwe kwa masharti kwa kutumia mbinu maalum. Kwa hiyo, madarasa mengine hutumiwa kufanya kazi na faili za maandishi.

Wakati huo huo, wakati wa kufanya kazi na faili mbalimbali za binary ambazo zina muundo fulani, FileStream inaweza kuwa muhimu sana kwa kutoa vipande fulani vya habari na kusindika.

Wacha tuangalie mfano wa kusoma na kuandika kwa faili ya maandishi:

Console.WriteLine("Ingiza mstari ili kuandika kwa faili:"); maandishi ya kamba = Console.ReadLine (); // kuandika kwa faili kwa kutumia (FileStream fstream = new FileStream(@"C:\SomeDir\noname\note.txt", FileMode.OpenOrCreate)) ( // badilisha mfuatano hadi safu ya byte = System.Text.Encoding. Chaguomsingi. GetBytes(maandishi); // kuandika safu ya baiti kwa fstream ya faili. Andika(array, 0, array.Length); Console.WriteLine("Nakala imeandikwa kwa faili");) // kusoma kutoka kwa faili kwa kutumia (FileStream fstream = File. OpenRead(@"C:\SomeDir\noname\note.txt")) ( // badilisha mfuatano kuwa baiti safu = byte mpya; // soma data fstream.Read(safu, 0, array.Length); // simbua baiti kuwa mfuatano wa maandishiFromFile = System.Text.Encoding.Default.GetString(array); Console.WriteLine("Nakala kutoka kwa faili: (0)", textFromFile); ) Console.ReadLine() ;

Hebu tuangalie mfano huu. Kusoma na kuandika hutumia kauli ya kutumia. Taarifa hii haipaswi kuchanganyikiwa na maagizo ya kutumia, ambayo yanajumuisha nafasi za majina mwanzoni mwa faili ya msimbo. Taarifa ya kutumia inakuwezesha kuunda kitu katika kizuizi cha msimbo, baada ya kukamilika ambayo njia ya Tupa ya kitu hicho inaitwa, na hivyo kitu kinaharibiwa. Katika kesi hii, tofauti ya fstream hutumika kama kitu kama hicho.

Kitu cha fstream kinaundwa kwa njia mbili tofauti: kupitia kwa mjenzi na kupitia mojawapo ya mbinu tuli za darasa la Faili.

Hapa vigezo viwili vinapitishwa kwa mjenzi: njia ya faili na hesabu ya FileMode. Hesabu hii inaonyesha hali ya ufikiaji wa faili na inaweza kuchukua maadili yafuatayo:

Ongeza: ikiwa faili iko, maandishi yanaongezwa hadi mwisho wa faili. Ikiwa faili haipo, imeundwa. Faili inafunguliwa kwa maandishi tu.

Unda : Faili mpya imeundwa. Ikiwa faili kama hiyo tayari ipo, imeandikwa

CreateNew: Faili mpya imeundwa. Ikiwa faili kama hiyo tayari iko, basi programu hutupa kosa

Fungua: Hufungua faili. Ikiwa faili haipo, ubaguzi hutupwa

OpenOrCreate : ikiwa faili iko, inafunguliwa, ikiwa sio, mpya imeundwa

Punguza: Ikiwa faili iko, imeandikwa tena. Faili inafunguliwa kwa maandishi tu.

Njia tuli ya OpenRead ya darasa la Faili hufungua faili kwa kusoma na kurudisha kitu cha FileStream.

Mjenzi wa darasa la FileStream pia ana idadi ya upakiaji unaokuruhusu kubinafsisha kwa usahihi kitu kinachoundwa. Matoleo haya yote yanaweza kutazamwa kwenye msdn.

Kuandika na kusoma hutumia kipengee cha Usimbaji.Chaguo-msingi kutoka kwa nafasi ya jina ya System.Text. Katika kesi hii, tunatumia njia zake mbili: GetBytes kupata safu kutoka kwa kamba na GetString kupata kamba kutoka safu ya baiti.

Matokeo yake, kamba tuliyoingia imeandikwa kwenye faili note.txt. Kimsingi, hii ni faili ya binary (sio faili ya maandishi), ingawa tukiandika mstari tu ndani yake, tunaweza kuona faili hii katika fomu inayoweza kusomeka na binadamu kwa kuifungua katika kihariri cha maandishi. Walakini, ikiwa tutaandika baiti za nasibu ndani yake, kwa mfano:

Fstream.WriteByte(13); fstream.WriteByte(103);

Kisha tunaweza kuwa na matatizo ya kuielewa. Kwa hiyo, madarasa tofauti yameundwa kufanya kazi moja kwa moja na faili za maandishi - StreamReader na StreamWriter.

Ufikiaji wa nasibu kwa faili

Mara nyingi faili za binary zinawakilisha muundo maalum. Na, kwa kujua muundo huu, tunaweza kuchukua kipande cha habari muhimu kutoka kwa faili au, kinyume chake, kuandika seti fulani ya ka mahali fulani kwenye faili. Kwa mfano, katika faili za wav, data ya sauti yenyewe huanza saa 44 bytes, na hadi 44 byte kuna metadata mbalimbali - idadi ya njia za sauti, mzunguko wa sampuli, nk.

Kwa kutumia njia ya Kutafuta (), tunaweza kudhibiti nafasi ya mshale wa mtiririko, kuanzia ambayo faili inasomwa au kuandikwa. Njia hii inachukua vigezo viwili: kukabiliana na nafasi katika faili. Nafasi katika faili inaelezewa na maadili matatu:

SeekOrigin.Begin : mwanzo wa faili

SeekOrigin.End : mwisho wa faili

SeekOrigin.Current : nafasi ya sasa katika faili

Kishale cha mtiririko ambapo usomaji au uandishi huanza husogezwa mbele kwa mkato kulingana na nafasi iliyobainishwa kama kigezo cha pili. Kukabiliana kunaweza kuwa hasi, kisha kishale husogea nyuma, ikiwa chanya, kisha mbele.

Hebu tuangalie mfano:

Kwa kutumia System.IO; kwa kutumia System.Text; class Program ( static void Main(string args) ( string text = "hello world"; // kuandika kwa faili kwa kutumia (FileStream fstream = new FileStream(@"D:\note.dat", FileMode.OpenOrCreate)) ( / / badilisha mfuatano kuwa pembejeo ya byte = Usimbaji.Default.GetBytes(maandishi); // andika safu ya baiti hadi faili fstream. Andika(input, 0, input.Length); Console.WriteLine("Nakala imeandikwa ili faili "); // sogeza kielekezi hadi mwisho wa faili, baiti tano hadi mwisho wa faili fstream.Tafuta(-5, SeekOrigin.End); // ondoa vibambo 5 kutoka mwisho wa mtiririko // soma nne herufi kutoka nafasi ya sasa byte pato = byte mpya; fstream.Read( pato, 0, output.Length); // kusimbua baiti kuwa mfuatano wa maandishiFromFile = Encoding.Default.GetString(output); Console.WriteLine("Text kutoka kwa faili: (0)", textFromFile); // worl // badilisha katika faili neno ulimwengu na neno house string replaceText = "nyumba"; fstream.Seek(-5, SeekOrigin.End); // minus 5 herufi kutoka mwisho wa ingizo la mkondo = Encoding.Default.GetBytes(replaceText); fstream.Write(input , 0, input.Length); // soma faili nzima // rudisha pointer mwanzoni mwa faili fstream.Seek(0, SeekOrigin.Begin); pato = byte mpya; fstream.Soma(pato, 0, pato.Urefu); // simbua baiti kwenye maandishi ya mfuatanoFromFile = Encoding.Default.GetString(output); Console.WriteLine("Nakala kutoka faili: (0)", textFromFile); // hello nyumba ) Console.Soma (); ))

Toleo la Console:

Maandishi yaliyoandikwa hadi faili Nakala kutoka kwa faili: worl Maandishi kutoka kwa faili: hello house

Kupiga simu kwa fstream.Seek(-5, SeekOrigin.End) husogeza kielekezi cha mtiririko hadi mwisho wa faili kurejesha herufi tano:

Hiyo ni, baada ya kuandika mstari "hello dunia" kwa faili mpya, mshale utakuwa kwenye nafasi ya tabia ya "w".

Baada ya hayo, tunasoma ka nne kuanzia na mhusika "w". Katika usimbaji huu, herufi 1 itawakilisha baiti 1. Kwa hiyo, kusoma byte 4 itakuwa sawa na kusoma wahusika nne: "worl".

Kisha, tena, tunahamia mwisho wa faili, bila kufikia mwisho wa wahusika watano (yaani, tena kutoka kwa nafasi ya tabia ya "w"), na kuandika kamba "nyumba". Kwa hivyo kamba "nyumba" inachukua nafasi ya kamba "ulimwengu".

Kufunga thread

Katika mifano iliyo hapo juu, muundo wa kutumia hutumiwa kufunga mkondo. Baada ya waendeshaji wote na misemo katika kizuizi cha kutumia kusindika, kitu cha FileStream kinaharibiwa. Walakini, tunaweza kuchagua njia nyingine:

FileStream fstream = null; jaribu ( fstream = new FileStream(@"D:\note3.dat", FileMode.OpenOrCreate); // shughuli na mkondo ) catch(Ila isipokuwa) ( ) hatimaye ( if (fstream != null) fstream.Close() ;)

Ikiwa hatutumii muundo wa kutumia, basi tunahitaji kupiga simu kwa uwazi njia ya Funga(): fstream.Close()

Utaratibu wa I/O uliotengenezwa na , hauambatani na mtindo unaokubalika kwa ujumla wa upangaji unaolenga kitu leo, kwa kuongezea, hutumia sana utendakazi wa vielelezo ambao unachukuliwa kuwa si salama katika mazingira ya kisasa ya utekelezaji wa nambari salama. Njia mbadala wakati wa kutengeneza programu-tumizi ni utaratibu wa madarasa ya kawaida ya I/O yanayotolewa na kiwango cha lugha cha C++.

Kufungua faili

Madarasa yanayotumika sana ni ifstream kwa kusoma, ofstream kwa maandishi, na fstream kwa kurekebisha faili.

Madarasa yote ya I/O yaliyounganishwa yanatokana kwa njia isiyo ya moja kwa moja kutoka kwa ios ya kawaida, na kurithi kikamilifu utendakazi wake. Kwa hivyo, hali ya kufungua faili imeainishwa na mshiriki wa data wa aina ya uandikishaji ya open_mode, ambayo inafafanuliwa kama ifuatavyo:

Enum open_mode ( programu, binary, ndani, nje, trunc, alikula );

Chini ni thamani zinazowezekana za bendera na madhumuni yao.

Kwa mfano, ili kufungua faili inayoitwa test.txt ili kusoma data katika mfumo wa jozi, ungeandika:

ifstream faili; file.open("test.txt", ios::in | ios::binary);

Kiendeshaji cha mantiki AU (|) hukuruhusu kuunda modi na mchanganyiko wowote wa bendera. Kwa hivyo, ili wakati wa kufungua faili kwa kuingia, usiandike kwa bahati mbaya faili iliyopo na jina moja, lazima utumie fomu ifuatayo:

faili ya mkondo; file.open("test.txt", ios::out | ios::app);

Inachukuliwa kuwa faili ya kichwa inayolingana imejumuishwa katika mradi:

#pamoja na

Kuangalia ikiwa faili ilifunguliwa kwa mafanikio, unaweza kutumia ujenzi

Ikiwa (!faili) (//Kushughulikia kosa la kufungua faili)

Waendeshaji wa kuingizwa na uchimbaji

Imebatilishwa katika madarasa ya kushughulikia faili mwendeshaji wa ujumuishaji (<<) записывает данные в файловый поток. Как только вы открыли файл для записи, можно записывать в него текстовую строку целиком:

Faili<< "Это строка текста";

Unaweza pia kuandika kamba ya maandishi katika sehemu:

Faili<< "Это " << "строка " << "текста";

Taarifa ya endl inamaliza pembejeo ya mstari na kurudi kwa gari:

Faili<< "Это строка текста" << endl;

Kutumia opereta ni pamoja na, ni rahisi kuandika maadili ya anuwai au vitu vya safu kwa faili:

faili ya mkondo ("Temp.txt"); char buff = "Safu ya maandishi ina vigezo"; int vx = 100; kuelea pi = 3.14159; faili<< buff << endl << vx << endl << pi << endl;

Kama matokeo ya kutekeleza msimbo, mistari mitatu ya faili ya maandishi ya Temp.txt huundwa:

Safu ya maandishi ina vigeu 100 3.14159

Kumbuka kuwa nambari zimeandikwa kwa faili kama mifuatano ya maandishi badala ya maadili ya binary.

Opereta wa kurejesha(>>) hutoa athari kinyume. Inaweza kuonekana kuwa ili kutoa herufi kutoka kwa faili ya Temp.txt iliyoandikwa mapema, ungeandika msimbo kama ifuatayo:

Ifstream faili("Temp.txt"); char buff; int vx; kuelea pi; faili >> buff >> vx >> pi;

Walakini, mwendeshaji wa uchimbaji atasimama kwenye kikomo cha kwanza ambacho hukutana nacho (nafasi, kichupo, au laini mpya). Kwa hivyo, wakati wa kuchanganua sentensi "Safu ya maandishi ina vigeu," neno "Nakala" pekee ndilo litakaloandikwa kwa safu ya buff, nafasi hupuuzwa, na neno "safu" litakuwa thamani ya tofauti nzima ya vx, na msimbo. utekelezaji "utaenda mrama" kwa ukiukaji usioepukika wa muundo wa data. Ifuatayo, tunapojadili darasa la ifstream, tutaonyesha jinsi ya kupanga vizuri usomaji wa faili kutoka kwa mfano uliopita.

ifstream darasa: kusoma faili

Kama jina linavyopendekeza, darasa la ifstream limeundwa kuingiza utiririshaji wa faili. Mbinu kuu za darasa zimeorodheshwa hapa chini. Nyingi zao hurithiwa kutoka kwa darasa la istream na zimejaa kupita kiasi ili kupanua utendakazi wa mzazi. Kwa mfano, kazi ya kupata, kulingana na parameter ya simu, haiwezi kusoma tu tabia moja, lakini pia block ya wahusika.

Sasa ni wazi jinsi mfano uliopita unahitaji kurekebishwa ili kutumia opereta wa uchimbaji wa data kutoa matokeo yanayotarajiwa:

Ifstream faili("Temp.txt"); char buff; int vx; kuelea pi; file.getline(buff, sizeof(buff)); faili >> vx >> pi:

Njia ya kupata laini itasoma safu ya kwanza ya faili hadi mwisho, na mendeshaji >> atatoa maadili kwa anuwai.

Mfano ufuatao unaonyesha kuongeza data kwenye faili ya maandishi na kisha kusoma faili nzima. Kitanzi cha wakati(1) kinatumika badala ya while(!file2.eof()) kwa sababu zilizojadiliwa katika .

#pamoja na #pamoja na kutumia nafasi ya majina std; int main() ( ofstream file; file.open("test.txt",ios::out|ios::app); ikiwa (!faili) ( cout<< "File error - can"t open to write data!"; cin.sync(); cin.get(); return 1; } for (int i=0; i<10; i++) file << i << endl; file.close(); ifstream file2; file2.open("test.txt", ios::in); if (!file2) { cout << "File error - can"t open to read data!"; cin.sync(); cin.get(); return 2; } int a,k=0; while (1) { file2 >> a; ikiwa (file2.eof()) itavunjika; koti<< a << " "; k++; } cout << endl << "K=" << k << endl; file2.close(); cin.sync(); cin.get(); return 0; }

Mfano ufuatao unaonyesha kitanzi kinachosoma mistari kutoka kwenye faili ya test.txt na kuzionyesha kwenye kiweko.

#pamoja na #pamoja na kutumia nafasi ya majina std; int main() ( ifstream faili; // tengeneza faili ya kitu cha kutiririsha.open("test.txt"); // fungua faili ili isomwe ikiwa (!faili) itarudisha 1;// rudisha kwenye ufunguzi wa makosa char str; // bafa ya laini tuli // Soma na uonyeshe mistari katika kitanzi hadi eof wakati (!file.getline(str, sizeof(str))).eof()) cout<< str << endl; // вывод прочитанной строки на экран cin.sync(); cin.get(); return 0; }

Nambari hii chini ya Windows OS pia inategemea uwepo wa herufi mpya kwenye safu ya mwisho ya faili; itakuwa ya kuaminika zaidi kufanya hivi:

Wakati (1) (ikiwa (file.eof()) inavunjika; file.getline(str, sizeof(str)); cout<< str << endl; }

Simu za wazi kwa njia zilizo wazi na za karibu hazihitajiki. Kwa kweli, kumwita mjenzi kwa hoja hukuruhusu kufungua faili mara moja, wakati wa kuunda kitu cha faili kilichowekwa nyuzi:

Ifstream faili("test.txt");

Badala ya njia ya karibu, unaweza kutumia operator wa kufuta, ambayo itaita moja kwa moja uharibifu wa kitu cha faili na kufunga faili. Nambari ya kitanzi wakati inahakikisha ukaguzi sahihi wa mwisho wa faili.

ofstream class: kuandika faili

Darasa la ofstream limeundwa kutoa data kutoka kwa mtiririko wa faili. Ifuatayo inaorodhesha njia kuu za darasa hili.

Opereta ya ujumuishaji iliyoelezewa hapo awali ni rahisi kwa kupanga maandishi kwa faili ya maandishi:

faili ya mkondo ("temp.txt"); ikiwa (!faili) itarudi; kwa (int i=1; i<=3; i++) file << "Строка " << i << endl; file.close();

Faili za binary

Kimsingi, data ya binary inachukuliwa kama data ya maandishi. Tofauti ni kwamba ikiwa data ya binary imeandikwa katika muundo maalum wa mantiki, basi lazima isomwe kutoka kwa faili hadi kutofautiana kwa aina sawa ya muundo.

Kigezo cha kwanza cha njia za kuandika na kusoma (anwani ya kizuizi cha kuandika / kusoma) lazima iwe ya aina ya pointer char * , kwa hiyo ni muhimu kufanya uongofu wa wazi wa aina ya anwani ya muundo wa * batili. Kigezo cha pili kinabainisha kuwa vizuizi vya binary vya faili vina ukubwa wa kawaida wa baiti bila kujali urefu halisi wa rekodi. Programu ifuatayo inatoa mfano wa kuunda na kuonyesha data katika daftari rahisi. Maingizo ya faili basi yanasomwa kwa mpangilio na kuonyeshwa kwenye koni.

#pamoja na #pamoja na #pamoja na kutumia nafasi ya majina std; muundo Vidokezo ( // muundo wa data ya daftari char Jina; // jina kamili char Simu; // simu int Umri; // umri); int main() ( setlocale(LC_ALL, "Russian"); Notes Note1= ("The Terrible Ioann Vasilyevich", "haijasakinishwa", 60 ); Notes Note2= ("Godunov Boris Fedorovich", "095-111-2233" , 30 ); Notes Note3= ( "Romanov Petr Mikhailovich ", "812-333-2211 ", 20 ); ofstream ofile("Notebook.dat", ios::binary); ofile.write((char*)&Note1, sizeof (Vidokezo)); // block ya 1 ofile.andika((char*)&Note2, sizeof(Notes)); // 2nd block ofile.andika((char*)&Note3, sizeof(Vidokezo)); // block ya 3 ofile.close(); // funga faili iliyorekodiwa ifstream ifile("Notebook.dat", ios::binary); Notes Note; // muundo tofauti char str;// bafa ya kamba tuli // Soma na uonyeshe mistari katika a kitanzi hadi eof wakati (!ifile.read((char*)&Note, sizeof(Notes)).eof()) ( sprintf(str, "%s\tPhone: %s\tAge: %d" , Note.Name, Kumbuka.Simu, Kumbuka.Umri); cout<< str << endl; } ifile.close(); // закрыть прочитанный файл cin.sync(); cin.get(); return 0; }

Kama matokeo ya kutekeleza nambari hii, faili ya binary Notebook.dat huundwa kutoka kwa vizuizi vitatu vya baiti 80 kila moja (ikizingatiwa kuwa herufi ni baiti moja). Kwa kawaida, unaweza kutumia njia nyingine za kuunganisha na kufanya shughuli zozote kwenye nyanja za muundo maalum wa data.

fstream class: ufikiaji wa faili bila mpangilio

Wacha tuchukue kuwa tunayo maingizo 100 kwenye daftari yetu, na tunataka kuhesabu ya 50. Bila shaka, unaweza kuandaa kitanzi na kusoma rekodi zote kutoka kwa kwanza hadi kwa kupewa. Ni wazi suluhisho linalolengwa zaidi ni kuweka pointer ya nafasi ya faili moja kwa moja hadi 50 na usome kutoka kwayo:

Ifstream ifile("Notebook.dat", ios::binary); int pos = 49 * sizeof(Vidokezo); ifile.seekg(pos); // tafuta ingizo la Vidokezo vya 50; // Vidokezo - muundo wa "rekodi" ulioelezwa hapo juu ifile.read((char*)&Note, sizeof(Vidokezo));

Shughuli hizo za utafutaji zinafaa ikiwa faili ina rekodi za ukubwa unaojulikana na wa mara kwa mara. Ili kuchukua nafasi ya yaliyomo kwenye rekodi ya kiholela, unahitaji kufungua mtiririko wa matokeo katika hali ya urekebishaji:

Ofstream ofile ("Notebook.dat", ios::binary | ios::ate); int pos = 49 * sizeof(Vidokezo); ofile seekp(pos); // tafuta maelezo ya 50 Notes Note50 = ("Yeltsin Boris Nikolaevich", "095-222-3322", 64); ofile.write((char*)&Note, sizeof(Vidokezo)); // mbadala

Ikiwa hutabainisha bendera ya ios::ate (au ios::app), basi unapofungua faili ya binary ya Notebook.dat, maudhui yake ya awali yatafutwa!

Hatimaye, inawezekana kufungua faili wakati huo huo kwa kusoma / kuandika, kwa kutumia mbinu zilizorithiwa na darasa la utiririshaji wa fstream kutoka kwa watangulizi wake. Kwa kuwa darasa la fstream linatokana na istream na ostream (wazazi wa ifstream na ofstream mtawalia), mbinu zote zilizotajwa hapo awali zinapatikana kwenye programu.

Mfano ufuatao unaonyesha mpangilio upya wa maingizo ya kwanza na ya tatu katika faili ya Notebook.dat.

#pamoja na #pamoja na #pamoja na kutumia nafasi ya majina std; struct Notes (Char Jina; char Simu; int Age; ); int main() ( setlocale(LC_ALL, "Russian"); Notes Note1, Note3; // Fungua faili kwa kusoma/kuandika kwa wakati mmoja fstream file("Notebook.dat", ios::binary | ios::in | ios: : out); file.seekg(2 * sizeof(Vidokezo)); // pata na usome Note3 file.soma((char*)&Note3, sizeof(Notes)); file.seekg(0); // pata na usome Note1 file.read((char*)&Note1, sizeof(Vidokezo)); file.seekg(0); // Note1<== Note3 file.write((char*)&Note3, sizeof(Notes)); file.seekg(2 * sizeof(Notes)); // Note3 <== Note1 file.write((char*)&Note1, sizeof(Notes)); char str; // Считывать и отображать записи в цикле, пока не eof file.seekg(0); // вернуться к началу файла while (!file.read((char*)&Note1, sizeof(Notes)).eof()) { sprintf(str, "%s\tТел: %s\tВозраст: %d", Note1.Name, Note1.Phone, Note1.Age); cout << str << endl; } file.close(); cin.sync(); cin.get(); return 0; }

Katika kijenzi cha kitu cha faili, lazima ubainishe bendera za ios::in na ios::nje, kuruhusu shughuli za kusoma na kuandika kwa wakati mmoja. Kama matokeo ya kutekeleza msimbo huu, maingizo ya kwanza na ya tatu katika faili ya binary ya Notebook.dat yatabadilishwa.

Kuna mifano ya ziada juu ya mada.