Kufanya kazi na faili za maandishi katika C++.
Kuna aina mbili kuu za faili: maandishi na binary. Faili huruhusu mtumiaji kusoma kiasi kikubwa cha data moja kwa moja kutoka kwenye diski bila kulazimika kuiingiza kutoka kwenye kibodi.
Maandishi faili zinazojumuisha wahusika wowote huitwa. Zimepangwa katika mistari, kila moja ikiishia na herufi ya mwisho wa mstari. Mwisho wa faili yenyewe unaonyeshwa na ishara ya "mwisho wa faili". Wakati wa kuandika habari kwa faili ya maandishi, ambayo inaweza kutazamwa kwa kutumia mhariri wowote wa maandishi, data zote zinabadilishwa kuwa aina ya tabia na kuhifadhiwa katika fomu ya tabia.
KATIKA binary Katika faili, habari inasomwa na kuandikwa kwa namna ya vitalu vya ukubwa fulani, ambayo data ya aina yoyote na muundo inaweza kuhifadhiwa.
Kufanya kazi na faili, maalum aina za data, kuitwa vijito. Mtiririko ifstream inatumika kufanya kazi na faili katika hali ya kusoma, na ya mkondo katika hali ya kurekodi. Kufanya kazi na faili katika hali ya kuandika na kusoma, mkondo hutumiwa mkondo.
Katika programu za C ++, unapofanya kazi na faili za maandishi, lazima ujumuishe maktaba ya iostream na fstream.
Ili andika chini data kwa faili ya maandishi, unahitaji:
eleza utofauti wa aina ya mkondo.
pato habari kwa faili.
hakikisha kufunga faili.
Kwa kusoma data kutoka kwa faili ya maandishi, unahitaji:
elezea utofauti wa aina ifstream.
fungua faili kwa kutumia kazi ya wazi.
funga faili.
Rekodi habari kwa faili ya maandishi
Kama ilivyoelezwa hapo awali, ili kuanza kufanya kazi na faili ya maandishi, unahitaji kufafanua tofauti ya aina ya mkondo. Kwa mfano, kama hii:
Tofauti F itaundwa ili kuandika habari kwa faili.
Katika hatua inayofuata, faili lazima ifunguliwe kwa maandishi. Kwa ujumla, mwendeshaji wa ufunguzi wa mkondo ataonekana kama:
F.fungua("faili", modi);
Hapa F ni kigezo kinachoelezewa kama ofstream,
faili - jina kamili la faili kwenye diski,
mode - mode ya kufanya kazi na faili kufunguliwa.
Tafadhali kumbuka kuwa unapotaja jina kamili la faili, lazima utumie kufyeka mara mbili. Kwa mfano, jina kamili la faili noobs.txt, lililo kwenye folda ya mchezo kwenye kiendeshi cha D:, litahitaji kuandikwa hivi:
D:\\mchezo\\noobs.txt.
Faili inaweza kufunguliwa katika mojawapo ya njia zifuatazo:
ios:: in - fungua faili katika hali ya usomaji wa data, hali hii ni hali ya msingi ya ifstreams;
ios :: nje - fungua faili katika hali ya uandishi wa data (katika kesi hii, habari kuhusu faili iliyopo imeharibiwa), hali hii ni hali ya msingi ya mito;
ios :: programu - kufungua faili katika hali ya kuandika data hadi mwisho wa faili;
ios::ate - hoja hadi mwisho wa faili tayari wazi;
ios::trunc - futa faili, hii pia hutokea katika ios::out mode;
ios::nocreate - usifungue faili ikiwa haipo;
ios::noreplace - usifungue faili iliyopo.
Kigezo cha modi kinaweza kuwa haipo, katika hali ambayo faili inafunguliwa katika hali ya chaguo-msingi ya mkondo huu.
Baada ya kufunguliwa kwa faili kwa mafanikio (kwa hali yoyote), tofauti F itahifadhi kweli, vinginevyo uongo. Hii itawawezesha kuangalia usahihi wa operesheni ya kufungua faili.
Unaweza kufungua faili (hebu tuchukue faili D:\\mchezo\\noobs.txt kama mfano) katika hali ya kurekodi kwa mojawapo ya njia zifuatazo:
// kwanza njia
mkondo F;
F.open("D:\\mchezo\\noobs.txt", ios::out);
//second, ios::out mode ndio modi chaguo-msingi
// Kwa mtiririkoya mkondo
mkondo F;
// njia ya tatu inachanganya maelezo ya kutofautiana na aina ya mkondo
// na kufungua faili katika taarifa moja
ofstream F("D:\\game\\noobs.txt", ios::out);
Baada ya kufungua faili katika hali ya kuandika, faili tupu itaundwa ambayo unaweza kuandika habari.
Ikiwa unataka kufungua faili iliyopo katika hali ya kuandika-kwanza, unapaswa kutumia ios::programu kama modi.
Baada ya kufungua faili katika hali ya kurekodi, unaweza kuiandikia kwa njia sawa na kwa skrini, badala ya kifaa cha kawaida cha pato.kotilazima ueleze jina la faili iliyo wazi.
Kwa mfano, kuandika kutofautisha a ili kutiririsha F, taarifa ya pato itaonekana kama:
Kwa matokeo ya mtiririko wa kutiririsha G ya vijiti b, c, d, mwendeshaji wa pato atakuwa kama hii:
G< Kufunga mkondo kunafanywa kwa kutumia opereta: MFANO: Unda faili ya maandishi D:\\mchezo\\noobs.txt na uandike n nambari halisi ndani yake. #pamoja na "stdafx.h" #pamoja na #pamoja na #pamoja na kutumia nafasi ya majina std; int kuu() setlocale(LC_ALL, "RUS"); int, n; mara mbili a; // inaelezea mtiririko wa kuandika data kwa faili ya mkondo
f;
// fungua faili katika hali ya kuandika, //modiios::
njeimewekwa kwa chaguo-msingi f.fungua("D:\\mchezo\\noobs.txt", ios::out); // ingiza nambari ya nambari halisi koti<<"
n=";
cini>>
n;
// kitanzi cha kuingiza nambari halisi // na uandike kwa faili kwa (i=0; i koti<<"a=";
// ingiza nambari cin>>a; f< // kufunga mkondo f.funga(); mfumo ("pause"); kurudi 0; _______________________________________________________________ Ili kusoma habari kutoka kwa faili ya maandishi, unahitaji kuelezea tofauti kama ifstream. Baada ya hayo, unahitaji kufungua faili kwa kusoma kwa kutumia operator wazi. Ikiwa kutofautisha kunaitwa F, basi taarifa mbili za kwanza zitakuwa kama hii: F.open("D:\\mchezo\\noobs.txt", ios::in); Baada ya kufungua faili katika hali ya kusoma, unaweza kusoma habari kutoka kwake kwa njia sawa na kutoka kwa kibodi, badala yakecinitaja jina la mtiririko ambao data itasomwa. Kwa mfano, kusoma kutoka kwa mkondo F hadi kutofautisha a, taarifa ya ingizo ingeonekana kama hii: Nambari mbili katika mhariri wa maandishi zinachukuliwa kutengwa ikiwa kuna angalau moja ya wahusika kati yao: nafasi, tabo, mwisho wa mstari. Ni vizuri ikiwa programu anajua mapema ni ngapi na ni maadili gani ya kuhifadhi kwenye faili ya maandishi. Walakini, mara nyingi aina ya maadili yaliyohifadhiwa kwenye faili inajulikana tu, lakini idadi yao inaweza kutofautiana. Ili kutatua tatizo hili, unahitaji kusoma maadili kutoka kwa faili moja kwa wakati, na kabla ya kila kusoma, angalia ikiwa mwisho wa faili umefikiwa. Kuna kipengele kwa hili F.
eof().
Hapa F ni jina la thread, kazi inarudi thamani ya Boolean: kweli au uongo, kulingana na ikiwa mwisho wa faili umefikiwa. Kwa hivyo, kitanzi cha kusoma yaliyomo kwenye faili nzima kinaweza kuandikwa kama hii: // panga kwa kusoma maadili kutoka kwa faili, utekelezaji // kitanzi kitavunjika tunapofikia mwisho wa faili, //katika kesi hii F.eof() itarudi kweli wakati (!F.eof()) MFANO: Faili ya maandishi D:\\mchezo\\noobs.txt huhifadhi nambari halisi, zionyeshe kwenye skrini na uhesabu nambari zao. #pamoja na "stdafx.h" #pamoja na #pamoja na #pamoja na #pamoja na kutumia nafasi ya majina std; int kuu() setlocale(LC_ALL, "RUS"); int n=0; kuelea a; mkondo F; // fungua faili katika hali ya kusoma F.open("D:\\mchezo\\noobs.txt"); // ikiwa faili ilifunguliwa kwa usahihi, basi // kitanzi cha kusoma maadili kutoka kwa faili; utekelezaji wa kitanzi utakatizwa, //tunapofikia mwisho wa faili, katika kesi hii F.eof() itarudi kweli. wakati (!F.eof()) // kusoma thamani inayofuata kutoka kwa mkondo F hadi kutofautisha a F>>a; // toa thamani ya kutofautisha a kwenye skrini koti< //ongeza idadi ya nambari zilizosomwa // kufunga mkondo F.funga(); // ingiza kwenye skrini idadi ya nambari zilizosomwa koti<<"n="< // ikiwa ufunguzi wa faili haukuwa sahihi, basi matokeo // ujumbe kuhusu kutokuwepo kwa faili kama hiyo mwingine cout<<" Файл не существует"< mfumo ("pause"); kurudi 0; C++. Usindikaji wa faili binary Wakati wa kuandika habari kwa faili ya binary, wahusika na nambari huandikwa kama mlolongo wa baiti. Ili andika chini data kwa faili ya binary, unahitaji: elezea utofauti wa faili wa aina FAIL * ukitumia FILE *filename; operator. Hapa jina la faili ni jina la kutofautisha ambapo pointer ya faili itahifadhiwa. andika habari kwa faili ukitumia kitendakazi cha fwrite Ili zingatia b data kutoka kwa faili ya binary, unahitaji: elezea utofauti wa aina FILE * fungua faili kwa kutumia fopen kazi funga faili kwa kutumia kazi ya fclose Vipengele vya msingi vinavyohitajika kufanya kazi na faili za binary. Kwa uvumbuzi Faili imekusudiwa kwa kazi ya fopen. FILE *fopen(const *jina la faili, const char *mode) Hapa jina la faili ni kamba ambayo huhifadhi jina kamili la faili inayofunguliwa, mode ni kamba ambayo huamua hali ya kufanya kazi na faili; maadili yafuatayo yanawezekana: "rb" - fungua faili ya binary katika hali ya kusoma; "wb" - tengeneza faili ya binary kwa kurekodi; ikiwa iko, yaliyomo yake yanafutwa; "ab" - kuunda au kufungua faili ya binary ili kuambatanisha hadi mwisho wa faili; "rb+" - fungua faili ya binary iliyopo katika hali ya kusoma-kuandika; "wb +" - fungua faili ya binary katika hali ya kusoma-kuandika, faili iliyopo imefutwa; "ab+" - faili ya binary inafunguliwa au kuundwa ili kurekebisha taarifa zilizopo na kuongeza taarifa mpya hadi mwisho wa faili. Chaguo za kukokotoa hurejesha NULL katika kibadilishaji cha faili f ikiwa faili itafunguka bila kufaulu. Baada ya kufungua faili, byte yake ya 0 inapatikana, pointer ya faili ni 0, thamani ambayo, inaposomwa au kuandikwa, inabadilishwa na idadi ya byte iliyosomwa (iliyoandikwa). Thamani ya sasa ya pointer ya faili ni nambari ya byte ambayo operesheni ya kusoma au kuandika itatokea. Kwa kufunga faili imekusudiwa kwa kazi ya fclose int fclose(FILE *jina la faili); Hurejesha 0 ikiwa faili ilifungwa kwa mafanikio, NULL vinginevyo. Kitendaji cha kuondoa ni cha kuondolewa mafaili. int remove(const char *filename); Kitendaji hiki kinafuta faili inayoitwa filenema kutoka kwa diski. Faili ya kufutwa lazima ifungwe. Chaguo za kukokotoa hurejesha thamani isiyo ya sifuri ikiwa faili haikuweza kufutwa. Kwa kubadilisha jina faili, kazi ya kubadilisha jina imekusudiwa: int rename (const char *oldfilename, const char *newfilename); Kigezo cha kwanza ni jina la faili la zamani, la pili ni mpya. Hurejesha 0 ikiwa programu itaisha kwa mafanikio. Kusoma kutoka kwa faili ya binary inafanywa kwa kutumia fread kazi: fread(batili *ptr, size, n, FILE *jina la faili); Kitendaji cha fread husoma n vipengele vya saizi kutoka kwa jina la faili hadi safu ya ptr. Chaguo la kukokotoa hurejesha idadi ya vipengele vilivyosomwa. Baada ya kusoma kutoka kwa faili, pointer yake inabadilishwa na byte za n*size. Rekodi kwa faili ya binary inafanywa kwa kutumia kazi ya fwrite: fwrite(const void *ptr, size, n, FILE *jina la faili); Kitendakazi cha fwrite huandika kwa faili jina la faili kutoka kwa safu ya ptr ya vipengele vya saizi ya n. Chaguo za kukokotoa hurejesha idadi ya vipengele vilivyoandikwa. Baada ya kuandika habari kwa faili, pointer inabadilishwa na byte za n * size. Kwa udhibiti wa mwisho wa faili kuna kazi feof: int feof(FILE *jina la faili); Inarudisha thamani isiyo ya sifuri ikiwa mwisho wa faili umefikiwa. MFANO: Unda faili ya binary D:\\mchezo\\noobs.dat na uandike n nambari kamili na n nambari halisi ndani yake. #pamoja na "stdafx.h" #pamoja na kutumia nafasi ya majina std; int kuu() setlocale(LC_ALL, "RUS"); int n, i; mara mbili a; // tengeneza faili ya binary katika hali ya kuandika f=fopen("D:\\mchezo\\noobs.dat", "wb"); //
pembejeo
nambarin koti<<"n=";
cin>> n; fwrite(&n, sizeof(int), 1, f); // kitanzi cha kuingiza n nambari halisi kwa (i=0; i // ingiza nambari halisi inayofuata koti<<"a=";
cin>>a; // kuandika nambari halisi kwa faili ya binary fwrite(&a, sizeof(double), 1, f); //
karibu
faili funga (f); mfumo ("pause"); kurudi 0; MFANO: Onyesha yaliyomo kwenye faili ya binary D:\\mchezo\\noobs.dat iliyoundwa katika kazi iliyotangulia #pamoja na "stdafx.h" #pamoja na kutumia nafasi ya majina std; int kuu() setlocale(LC_ALL, "RUS"); int n, i; mara mbili *a; FILE *f; // eleza utofauti wa faili // fungua faili ya binary iliyopo katika hali ya kusoma // soma nambari moja kutoka kwa faili hadi kutofautisha n // pato n kwa skrini koti<<"n="< //kugawa kumbukumbu kwa safu ya nambari za n a=new double[n]; //read n nambari halisi kutoka kwa faili hadi safu a // toa safu kwenye skrini kwa (i=0; i koti< koti< //
karibu
faili funga (f); mfumo ("pause"); kurudi 0; Faili ya binary- muundo wa data mfululizo, baada ya kufungua faili, byte ya kwanza iliyohifadhiwa ndani yake inapatikana. Unaweza kuandika au kusoma data kutoka kwa faili kwa mlolongo. Hebu sema unahitaji kuhesabu nambari ya kumi na tano, na kisha ya kwanza. Kwa kutumia ufikiaji unaofuatana hii inaweza kufanywa kwa njia ifuatayo: int n, i; mara mbili a; FILE *f; f=fopen("D:\\mchezo\\noobs.dat", "rb"); kwa (i=0; i<15; i++)
funga (f); f=fopen("D:\\mchezo\\noobs.dat", "rb"); mkate(&a, sizeof(mbili), 1, f); funga (f); Kama unaweza kuona, kusoma nambari kutoka kwa faili na kufungua faili tena sio njia rahisi zaidi. Itakuwa rahisi zaidi kutumia kitendakazi cha fseek kusogeza pointer ya faili kwa byte fulani. int fseek(FILE *jina la faili, urekebishaji mrefu wa int, asili ya int); Chaguo za kukokotoa huweka kielekezi cha sasa cha nafasi ya faili F kwa mujibu wa asili na maadili ya kukabiliana. Kigezo cha kukabiliana ni sawa na idadi ya baiti ambazo kielekezi cha faili kitarekebishwa kulingana na asili iliyobainishwa na kigezo asili. Thamani ya kigezo cha asili lazima iwe mojawapo ya thamani zifuatazo za kukabiliana zilizofafanuliwa katika kichwa cha stdio.h: SEEK_SET - tangu mwanzo wa faili; SEEK_CUR - kutoka kwa nafasi ya sasa; SEEK_END - kutoka mwisho wa faili. Chaguo za kukokotoa hurejesha thamani ya sifuri ikiwa utendakazi ulifaulu, thamani isiyo ya sifuri ikiwa urekebishaji umeshindwa. Chaguo za kukokotoa za fseek hutekeleza ufikiaji wa moja kwa moja kwa thamani yoyote katika faili. Unahitaji tu kujua eneo (nambari ya byte) ya thamani kwenye faili. Wacha tuangalie kutumia ufikiaji wa moja kwa moja kwenye faili za binary kwa kutumia shida ifuatayo kama mfano. MFANO Katika faili ya binary D:\\mchezo\\noobs.dat iliyoundwa mapema, badilisha nambari kubwa na ndogo zaidi halisi. Algorithm ya kutatua shida ina hatua zifuatazo: kusoma reals kutoka kwa faili hadi safu a. tafuta katika safu a kwa maadili ya juu (max) na ya chini (min) na nambari zao (imax, imin). kusonga pointer ya faili hadi thamani ya juu na kuandika min. kusonga pointer ya faili kwa thamani ya chini na max ya uandishi. Chini ni maandishi ya programu ya kutatua tatizo na maoni. #pamoja na "stdafx.h" #pamoja na kutumia nafasi ya majina std; int kuu() setlocale(LC_ALL, "RUS"); int n, i, imax, imin; mara mbili *a, max, min; FILE *f; // fungua faili katika hali ya kusoma-kuandika f=fopen("D:\\mchezo\\noobs.dat", "rb+"); //soma nambari kutoka kwa faili hadi kutofautisha n // nambari halisi kwenye faili mkate(&n, sizeof(int), 1, f); koti<<"n="< //tenga kumbukumbu ya kuhifadhi nambari halisi, //ambayo itahifadhiwa katika safu a a=new double[n]; //soma kutoka kwa faili hadi safu na nambari halisi mkate(a, sizeof(mbili), n, f); //tafuta vipengele vya juu na vya chini zaidi //katika safu a na fahirisi zao kwa (imax=imin=0, max=min=a, i=1; i ikiwa (a[i]>max) max=a[i]; ikiwa (a[i] min=a[i]; //
kusonga
pointer
Kwa
upeo
kipengele fseek(f, sizeof(int)+imax*sizeof(double), SEEK_SET); //andika dakika badala ya kipengee cha juu zaidi cha faili fwrite(&min, sizeof(double), 1, f); //
kusonga
pointer
Kwa
kiwango cha chini
kipengele fseek(f, sizeof(int)+imin*sizeof(double), SEEK_SET); //rekodi max badala ya kipengele cha chini cha faili fwrite(&max, sizeof(double), 1, f); // kufunga faili funga (f); // kumbukumbu ya bure futa [
]a; mfumo ("pause"); 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 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 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 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. Lebo: Faili za maandishi, fopen, fclose, feof, setbuf, setvbuf, fflush, fgetc, fprintf, fscanf, fgets, mtiririko ulioakibishwa, mtiririko usio na buffer. Kufanya kazi na faili ya maandishi ni sawa na kufanya kazi na kiweko: kwa kutumia vitendaji vya kuingiza vilivyoumbizwa tunahifadhi data kwenye faili, kwa kutumia vitendaji vya kutoa vilivyoumbizwa tunasoma data kutoka kwa faili. Kuna nuances nyingi ambazo tutaangalia baadaye. Shughuli kuu zinazohitajika kufanywa ni Kwa kuongeza, kuna idadi ya kazi wakati hatuhitaji kufikia yaliyomo ya faili: kubadilisha jina, kusonga, kunakili, nk. Kwa bahati mbaya, kiwango cha C hakina maelezo ya utendakazi kwa mahitaji haya. Kwa kweli, zinapatikana kwa kila utekelezaji wa mkusanyaji. Kusoma yaliyomo kwenye saraka (folda, saraka) pia ni kupata faili, kwa sababu folda yenyewe ni faili iliyo na metainformation. Wakati mwingine ni muhimu kufanya shughuli za msaidizi: hoja kwenye eneo linalohitajika kwenye faili, kumbuka nafasi ya sasa, kuamua urefu wa faili, nk. Ili kufanya kazi na faili, unahitaji kipengee cha FILE. Kipengee hiki huhifadhi kitambulisho cha mtiririko wa faili na maelezo yanayohitajika ili kuidhibiti, ikijumuisha kielekezi kwa bafa yake, kiashirio cha nafasi ya faili na viashirio vya hali. Kitu cha FILE yenyewe ni muundo, lakini sehemu zake hazipaswi kufikiwa. Programu inayobebeka lazima ichukue faili kama kitu dhahania kinachoruhusu ufikiaji wa mtiririko wa faili. Uundaji na ugawaji wa kumbukumbu kwa kitu cha aina FILE unafanywa kwa kutumia fopen au tmpfile kazi (kuna wengine, lakini tutazingatia haya tu). Kazi ya fopen inafungua faili. Inapokea hoja mbili - kamba yenye anwani ya faili na kamba yenye hali ya kufikia faili. Jina la faili linaweza kuwa kamili au la jamaa. fopen inarudisha kielekezi kwa kitu cha FILE ambacho kinaweza kutumika kupata faili zaidi. FILE* fopen(const char* jina la faili, const char* mode); Kwa mfano, hebu tufungue faili na kuandika Hello World ndani yake #pamoja na Kazi ya fopen yenyewe hutenga kumbukumbu kwa kitu; kusafisha hufanywa na kazi ya fclose. Inahitajika kufunga faili, haitajifunga yenyewe. Chaguo la kukokotoa la fopen linaweza kufungua faili katika hali ya maandishi au ya binary. Chaguo msingi ni maandishi. Njia ya ufikiaji inaweza kuwa kama ifuatavyo Ikiwa ni muhimu kufungua faili katika hali ya binary, basi barua b inaongezwa hadi mwisho wa mstari, kwa mfano "rb", "wb", "ab", au, kwa hali ya mchanganyiko, "ab +", " wb+”, “ab+”. Badala ya b, unaweza kuongeza barua t, kisha faili itafungua katika hali ya maandishi. Inategemea utekelezaji. Katika kiwango kipya cha C (2011), herufi x inamaanisha kuwa fopen inapaswa kushindwa ikiwa faili tayari ipo. Wacha tuongeze programu yetu ya zamani: fungua tena faili na uzingatie kile tulichoandika hapo. #pamoja na Badala ya kazi ya fgets, unaweza kutumia fscanf, lakini unahitaji kukumbuka kuwa inaweza tu kusoma mstari hadi nafasi ya kwanza. Pia, badala ya kufungua na kufunga faili, unaweza kutumia kazi ya freopen, ambayo "hufungua tena" faili na haki mpya za kufikia. #pamoja na Vipengele vya kukokotoa fprintf na fscanf hutofautiana na printf na scanf kwa kuwa tu huchukua kama hoja yao ya kwanza kielekezi kwa FILE ambacho watatoa au kutoka kwao watasoma data. Inastahili kuongeza mara moja kwamba kazi za printf na scanf zinaweza kubadilishwa kwa urahisi na kazi za fprintf na fscanf. Katika Mfumo wa Uendeshaji (tunazingatia mifumo ya uendeshaji ya kawaida na ya kutosha) kuna mitiririko mitatu ya kawaida: mkondo wa pato wa kawaida stdout, mkondo wa kawaida wa pembejeo stdin na mkondo wa matokeo wa makosa ya kawaida stderr. Zinafunguliwa kiotomatiki programu inapozinduliwa na inahusishwa na koni. Mfano #pamoja na Ikiwa simu ya chaguo la kukokotoa itashindwa, itarudi NULL. Makosa wakati wa kufanya kazi na faili hufanyika mara nyingi, kwa hivyo kila wakati tunapofungua faili, tunahitaji kuangalia matokeo ya kazi. #pamoja na Tatizo linatokea wakati faili kadhaa zinafunguliwa mara moja: ikiwa mmoja wao hawezi kufunguliwa, basi wengine lazima pia kufungwa FILE *inputFile, *outputFile; isiyotiwa saini m, n; haijatiwa saini i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); ikiwa (inputFile == NULL) ( printf("Hitilafu ya kufungua faili %s", INPUT_FILE); getch(); toka(3); ) outputFile = fopen(OUTPUT_FILE, WRITE_ONLY); ikiwa (outputFile == NULL) ( printf("Hitilafu ya kufungua faili %s", OUTPUT_FILE); getch(); ikiwa (inputFile != NULL) ( fclose(inputFile); ) toka(4); ) ... Katika hali rahisi, unaweza kuchukua hatua moja kwa moja, kama ilivyo kwenye kipande cha msimbo uliopita. Katika hali ngumu zaidi, njia hutumiwa kuchukua nafasi ya RAII kutoka C ++: vifuniko, au vipengele vya mkusanyaji (kusafisha katika GCC), nk. Kama ilivyoelezwa hapo awali, tunapotoa data, huwekwa kwanza kwenye bafa. Bafa imefutwa Unaweza kulazimisha upakuaji wa bafa kwa kupiga kitendakazi cha fflush(File *). Hebu tuangalie mifano miwili - pamoja na bila kusafisha. #pamoja na Ondoa maoni kwa simu isiyofaa. Wakati wa kukimbia, fungua faili ya maandishi na uangalie tabia. Unaweza kukabidhi bafa ya faili mwenyewe kwa kuweka saizi yako mwenyewe. Hii inafanywa kwa kutumia kazi Seti tupu (FILE * mkondo, char * bafa); ambayo inachukua FILE iliyofunguliwa tayari na kielekezi kwa bafa mpya. Ukubwa wa bafa mpya lazima iwe si chini ya BUFSIZ (kwa mfano, kwenye kituo cha kazi cha BUFSIZ ni baiti 512). Ukipitisha NULL kama bafa, mtiririko unakuwa bila buffer. Unaweza pia kutumia kazi Int setvbuf(FILE * mkondo, char * buffer, int mode, size_t size); ambayo inakubali bafa ya saizi ya kiholela. Hali inaweza kuchukua maadili yafuatayo Mfano: wacha tuweke bafa yetu na tuone jinsi usomaji kutoka kwa faili unafanywa. Hebu faili iwe fupi (kitu kama Hello, World!), na tunaisoma tabia kwa tabia #pamoja na Inaweza kuonekana kuwa data tayari iko kwenye bafa. Kusoma herufi kwa herufi hufanywa kutoka kwa bafa. Kazi int feof(FILE * mkondo); inarudi kweli ikiwa mwisho wa faili umefikiwa. Kazi ni rahisi kutumia wakati unahitaji kupitia faili nzima tangu mwanzo hadi mwisho. Acha kuwe na faili iliyo na maandishi maandishi text.txt. Tunasoma tabia ya faili kwa tabia na kuionyesha kwenye skrini. #pamoja na Kila kitu kitakuwa sawa, lakini kazi ya feof haifanyi kazi kwa usahihi ... Hii ni kutokana na ukweli kwamba dhana ya "mwisho wa faili" haijafafanuliwa. Hitilafu ambayo mara nyingi hutokea wakati wa kutumia feof ni kwamba data ya mwisho iliyosomwa imechapishwa mara mbili. Hii ni kutokana na ukweli kwamba data imeandikwa kwa bafa ya pembejeo, usomaji wa mwisho hutokea na kosa na kazi inarudi thamani ya zamani iliyosomwa. #pamoja na Mfano huu utashindwa (uwezekano mkubwa) na uchapishe herufi ya mwisho ya faili mara mbili. Suluhisho sio kutumia feof. Kwa mfano, hifadhi jumla ya idadi ya rekodi, au tumia ukweli kwamba vipengele vya fscanf n.k. kwa kawaida hurejesha idadi ya thamani zilizosomwa na kulinganishwa kwa usahihi. #pamoja na 1. Faili moja ina nambari mbili - vipimo vya safu. Wacha tujaze faili ya pili na safu ya nambari za nasibu. #pamoja na 2. Mtumiaji anakili faili, na kwanza anachagua hali ya uendeshaji: faili inaweza kutolewa ama kwa console au kunakiliwa kwa faili mpya. #pamoja na 3. Mtumiaji huingiza data kutoka kwa console na imeandikwa kwa faili hadi ufunguo wa esc utakaposisitizwa. Angalia programu na uone. jinsi inavyofanya ikiwa unaingia backspace: ni nini pato kwa faili na ni nini pato kwa koni. #pamoja na 4. Faili ina nambari kamili. Pata upeo wao. Wacha tuchukue fursa ya ukweli kwamba kazi ya fscanf inarudisha idadi ya vitu vilivyosomwa kwa usahihi na vinavyolingana. Nambari 1 inapaswa kurejeshwa kila wakati. #pamoja na Suluhisho lingine ni kusoma nambari hadi tufikie mwisho wa faili. #pamoja na 5. Faili ina maneno: neno la Kirusi, tabulation, neno la Kiingereza, katika safu kadhaa. Mtumiaji huingia neno la Kiingereza, ni muhimu kutoa moja ya Kirusi. Faili ya tafsiri inaonekana kama hii jua jua na kuhifadhiwa katika usimbaji cp866 (OEM 866). Ni muhimu: jozi ya mwisho ya maneno pia inaisha na kulisha mstari. Algorithm ni kama ifuatavyo: tunasoma mstari kutoka kwa faili, pata herufi ya kichupo kwenye mstari, badilisha herufi ya kichupo na sifuri, nakala ya neno la Kirusi kutoka kwa buffer, nakala ya neno la Kiingereza kutoka kwa buffer, angalia usawa. #pamoja na 6. Hesabu idadi ya mistari kwenye faili. Tutasoma herufi ya faili kwa herufi, tukihesabu idadi ya herufi "\n" hadi tutakapokutana na herufi ya EOF. EOF ni herufi maalum inayoonyesha kuwa ingizo limekamilika na hakuna data zaidi ya kusoma. Chaguo za kukokotoa hurejesha thamani hasi iwapo kutatokea hitilafu. #fafanua _CRT_SALAMA_NO_ONYO #pamoja na Ru-Cyrl 18-mafunzo Sypachev S.S. 1989-04-14 [barua pepe imelindwa] Stepan Sypachev wanafunzi Bado si wazi? - Andika maswali kwenye sanduku la barua Fopen() chaguo la kukokotoa hufungua mtiririko kwa matumizi, huhusisha faili na mtiririko huo, na kisha kurudisha kielekezi cha FILE kwenye mkondo huo. Mara nyingi faili inachukuliwa kama faili ya diski. fopen() kazi ina mfano ufuatao: FILE *fopen(const char *jina la faili, const char *mode); Ambapo modi inaelekeza kwenye kamba iliyo na modi inayotaka ya kufungua faili. Thamani halali za modi katika Borland C++ zinaonyeshwa kwenye jedwali. jina la faili lazima liwe mfuatano wa herufi ambayo hutoa jina halali la faili kwa mfumo wa uendeshaji, na inaweza kuwa na jina la njia. Fopen() chaguo za kukokotoa hurejesha kielekezi kwa aina ya msingi FILE. Kiashiria hiki kinatambua faili na hutumiwa na kazi nyingi za mfumo wa faili. Haupaswi kamwe kuibadilisha mwenyewe. Chaguo za kukokotoa hurejesha kielekezi kisicho na maana ikiwa faili haiwezi kufunguliwa. Kama jedwali linavyoonyesha, faili inaweza kufunguliwa kwa maandishi au hali ya binary. Katika hali ya maandishi, unapoandika, mlolongo wa kurudi kwa gari na milisho ya laini hutafsiriwa kwa herufi mpya. Katika pato, kinyume chake ni kweli: herufi mpya inatafsiriwa katika kurudi kwa gari na kulisha mstari. Tafsiri hii haipatikani katika faili za mfumo wa jozi. Wakati t wala b haijabainishwa katika hoja ya modi, basi hali ya maandishi/jombari ya faili inabainishwa na thamani ya utofauti wa kimataifa _fmode iliyofafanuliwa katika Borland C++. Kwa chaguo-msingi, fmode imewekwa kuwa O_TEXT, yaani, hali ya maandishi imewekwa. Ukiweka _fmode kuwa O_BINARY, basi faili zitafunguliwa katika hali ya jozi. (Makro hizi zimefafanuliwa katika fcntl.h.) Kwa kawaida, kutumia t au b wazi huondoa athari zinazohusiana na _fmode kutofautiana. Kwa kuongeza, _fmode ni maalum kwa bidhaa za Borland pekee. Haijafafanuliwa katika mfumo wa ANSI C I/O. Ikiwa unahitaji kufungua faili iliyopewa jina la jaribio kwa uandishi, unapaswa kuandika: Fp = fopen("mtihani", "w"); Ambapo fp ni tofauti ya aina FILE *. Walakini, ni kawaida kuona yafuatayo: Ikiwa((fp = fopen("mtihani", "w"))==NULL) ( Njia hii inakuwezesha kuchunguza makosa wakati wa kufungua faili, kwa mfano, kuwepo kwa ulinzi wa kuandika au ukosefu wa nafasi ya bure kwenye diski. Ikiwa fopen() inatumika kufungua faili kwa ajili ya kuandika, basi faili yoyote iliyokuwepo awali yenye jina lililotajwa itafutwa. Ikiwa faili iliyo na jina maalum haipo, itaundwa. Ikiwa unahitaji kuongeza habari hadi mwisho wa faili, unapaswa kutumia hali ya (kuongeza). Ikiwa faili haipo, itaundwa. Kufungua faili kwa kusoma kunahitaji uwepo wa faili. Ikiwa faili haipo, hitilafu itarejeshwa. Ikiwa faili inafunguliwa kwa uendeshaji wa kusoma / kuandika, basi haijafutwa ikiwa iko, na ikiwa faili haipo, basi imeundwa. Maana Hufungua faili kwa ajili ya kusoma. (Hufungua kwa chaguo-msingi kama faili ya maandishi.) Huunda faili ya kuandikia. (Hufungua kwa chaguo-msingi kama faili ya maandishi.) Inaambatanisha na faili. (Hufungua kwa chaguo-msingi kama faili ya maandishi.) Hufungua faili ya jozi kwa kusoma. Hufungua faili ya jozi kwa kuandika. Huambatanisha na faili ya jozi. Hufungua faili kwa ajili ya kusoma/kuandika. (Hufungua kwa chaguo-msingi kama faili ya maandishi.) Huunda faili ya kusoma/kuandika. (Hufungua kwa chaguo-msingi kama faili ya maandishi.) Huambatanisha au kuunda faili ya kusoma/kuandika. (Hufungua kwa chaguo-msingi kama faili ya maandishi.) Hufungua faili ya jozi kwa kusoma/kuandika. Huunda faili ya jozi ya kusoma/kuandika. Huambatisha au kuunda faili ya mfumo wa jozi ya kusoma/kuandika. Inaunda faili ya maandishi kwa maandishi. Inaambatanisha na faili ya maandishi. Hufungua faili ya maandishi kwa ajili ya kusoma. Huunda faili ya maandishi kwa kusoma/kuandika. Hufungua au kuunda faili ya maandishi kwa kusoma/kuandika. Kwa urahisi wa upatikanaji, habari katika vifaa vya kuhifadhi huhifadhiwa kwa namna ya faili. Faili ni eneo lenye jina la kumbukumbu ya nje iliyotengwa kwa ajili ya kuhifadhi safu ya data. Data iliyo katika faili ni ya asili tofauti sana: mipango katika lugha ya algorithmic au mashine; data ya awali ya uendeshaji wa programu au matokeo ya utekelezaji wa programu; maandishi ya bure; picha za picha, nk. Saraka (folda, saraka) - mkusanyiko unaoitwa wa ka kwenye njia ya uhifadhi iliyo na majina ya subdirectories na faili, zinazotumiwa katika mfumo wa faili ili kurahisisha shirika la faili. Mfumo wa faili inayoitwa sehemu ya kazi ya mfumo wa uendeshaji ambayo hufanya shughuli kwenye faili. Mifano ya mifumo ya faili ni FAT (FAT - Jedwali la Ugawaji wa Faili), NTFS, UDF (hutumika kwenye CD). Kuna matoleo matatu kuu ya FAT: FAT12, FAT16 na FAT32. Wanatofautiana katika kina kidogo cha rekodi katika muundo wa disk, i.e. idadi ya biti zilizotengwa kuhifadhi nambari ya nguzo. FAT12 hutumiwa hasa kwa diski za floppy (hadi 4 KB), FAT16 - kwa disks za uwezo mdogo, FAT32 - kwa anatoa za FLASH za juu (hadi 32 GB). Wacha tuangalie muundo wa mfumo wa faili kwa kutumia FAT32 kama mfano. Vifaa vya kumbukumbu ya nje katika mfumo wa FAT32 vina anwani ya kuzuia badala ya kushughulikia kwa kawaida. Taarifa imeandikwa kwa kifaa cha kumbukumbu ya nje katika vitalu au sekta. Sekta ni sehemu ya chini kabisa inayoweza kushughulikiwa ya uhifadhi wa taarifa kwenye vifaa vya hifadhi ya nje. Kwa kawaida, ukubwa wa sekta ni fasta kwa 512 bytes. Ili kuongeza nafasi ya anwani ya vifaa vya kumbukumbu ya nje, sekta zinajumuishwa katika vikundi vinavyoitwa makundi. Nguzo ni muungano wa sekta kadhaa, ambayo inaweza kuchukuliwa kama kitengo huru na mali fulani. Mali kuu ya nguzo ni saizi yake, iliyopimwa kwa idadi ya sekta au idadi ya ka. Mfumo wa faili wa FAT32 una muundo ufuatao. Vikundi vinavyotumiwa kuandika faili vimehesabiwa kuanzia 2. Kama sheria, kikundi cha 2 kinatumiwa na saraka ya mizizi, na kuanzia kikundi cha 3 safu ya data huhifadhiwa. Sekta zinazotumiwa kuhifadhi habari juu ya saraka ya mizizi hazijaunganishwa. Sekta ya boot huanza na habari ifuatayo: Kwa kuongeza, sekta ya boot ina taarifa muhimu zifuatazo: Sekta ya habari ya mfumo wa faili ina: Jedwali la FAT lina habari kuhusu hali ya kila nguzo kwenye diski. Biti 2 za chini za duka la meza la FAT F8 FF FF 0F FF FF FF FF (ambayo inalingana na hali ya makundi 0 na 1, ambayo haipo kimwili). Ifuatayo, hali ya kila nguzo ina nambari ya nguzo ambayo faili ya sasa inaendelea au habari ifuatayo: Saraka ya mizizi ina seti ya rekodi za habari 32-bit kuhusu kila faili, iliyo na habari ifuatayo: Wakati wa kufanya kazi na majina ya faili ndefu (ikiwa ni pamoja na majina ya Kirusi), jina la faili limewekwa kwa kutumia mfumo wa encoding UTF-16. Katika kesi hii, byte 2 zimetengwa kwa kusimba kila herufi. Katika kesi hii, jina la faili limeandikwa katika muundo ufuatao: Kwa mtayarishaji programu, faili iliyofunguliwa inawakilishwa kama mlolongo wa data inayosomwa au kuandikwa. Wakati faili inafunguliwa, inahusishwa na I/O mkondo. Taarifa ya pato imeandikwa kwa mkondo, taarifa ya pembejeo inasomwa kutoka kwa mkondo. Mtiririko unapofunguliwa kwa I/O, unahusishwa na muundo wa kawaida wa FILE, ambao umefafanuliwa katika stdio.h. Muundo wa FILE una habari muhimu kuhusu faili. Kufungua faili hufanywa kwa kutumia fopen() kazi, ambayo inarudisha pointer kwa muundo wa FILE ambao unaweza kutumika kwa shughuli zinazofuata kwenye faili. FILE *fopen(jina, aina); Thamani ya kurudi ni kiashirio kwa mkondo wazi. Ikiwa hitilafu itapatikana, NULL itarejeshwa. Fclose() chaguo za kukokotoa hufunga mtiririko au mitiririko inayohusishwa na faili zilizofunguliwa kwa kutumia fopen() chaguo la kukokotoa. Mtiririko utakaofungwa unaamuliwa na hoja ya fclose() chaguo la kukokotoa. Thamani ya kurejesha: thamani 0 ikiwa mtiririko ulifungwa kwa mafanikio; EOF mara kwa mara ikiwa hitilafu ilitokea. 1 #pamoja na Kusoma herufi kutoka kwa faili: char fgetc(mkondo); Kuandika ishara kwa faili: fputc(char, mkondo); Hoja za chaguo za kukokotoa ni herufi na kielekezi kwa mtiririko wa aina FILE. Chaguo la kukokotoa linarudisha msimbo wa herufi iliyosomwa. Vipengele vya fscanf() na fprintf() vinafanana na vitendaji vya scanf() na printf(), lakini hufanya kazi na faili za data, na kuwa na kielekezi cha faili kama hoja yao ya kwanza. fscanf(mkondo, "InputFormat", hoja); Faili za maandishi
Kamba_2
Kamba_3Fanya kazi na faili za maandishi
Chaguzi za ufikiaji wa faili.
Aina
Maelezo
r
Kusoma. Faili lazima iwepo.
w
Andika faili mpya. Ikiwa faili iliyo na jina sawa tayari ipo, yaliyomo yake yatapotea.
a
Andika hadi mwisho wa faili. Uendeshaji wa nafasi (fseek, fsetpos, frewind) hupuuzwa. Faili imeundwa ikiwa haikuwepo.
r+
Kusoma na kusasisha. Unaweza kusoma na kuandika. Faili lazima iwepo.
w+
Kurekodi na kusasisha. Faili mpya imeundwa. Ikiwa faili iliyo na jina sawa tayari ipo, yaliyomo yake yatapotea. Mnaweza kuandika na kusoma.
a+
Maliza chapisho na usasishe. Shughuli za uwekaji nafasi ni za kusoma tu na kupuuzwa kwa maandishi. Ikiwa faili haikuwepo, mpya itaundwa.
fscanf(faili, "%127s", buffer);Hitilafu katika kufungua faili
Kuhifadhi Data
Ikiwa imefanikiwa, chaguo la kukokotoa linarudi 0. feof
Mifano
kalamu ya penseli
penseli ya kalamu ya mpira
mlango wa mlango
dirisha la madirisha
mwenyekiti mwenyekiti
kiti cha mkono
KUMBUKA: EOF ni ya aina int, kwa hivyo unahitaji kutumia int kusoma wahusika. Zaidi ya hayo, thamani ya EOF haijafafanuliwa na kiwango.
huweka ("Haiwezi kufungua faili.");
kutoka(1);
}Jedwali: Thamani za modi zinazoruhusiwa
muundo wa faili FAT32
Saizi ya chini ya faili inayohitajika kwenye diski inalingana na nguzo 1.
Kufanya kazi na faili katika lugha ya C
jina - jina la faili ya kufungua (pamoja na njia),
type ni kielekezi kwa safu ya wahusika ambayo inafafanua jinsi faili inavyopatikana:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int kuu() (
FILE *fp;
char name = "my.txt" ;
ikiwa ((fp = fopen(jina, "r")) == NULL )
{
printf( "Imeshindwa kufungua faili");
getchar();
kurudi 0;
}
// alifanikiwa kufungua faili
... // vitendo vinavyohitajika kwenye data
fclose (fp);
getchar();
kurudi 0;
}
Hoja ya kukokotoa ni kielekezi kwa mtiririko wa aina FILE. Chaguo la kukokotoa linarudisha msimbo wa herufi iliyosomwa. Ikiwa mwisho wa faili umefikiwa au hitilafu hutokea, EOF ya mara kwa mara inarudi.
