Metų laikai

Pradžia

Pas mokytoją

Kad būtų lengviau pasiekti, informacija saugojimo įrenginiuose saugoma failų pavidalu.

Failas yra pavadinta išorinės atminties sritis, skirta duomenų masyvo saugojimui. Failuose esantys duomenys yra labai įvairaus pobūdžio: programos algoritmine arba mašinine kalba; pradiniai programos veikimo duomenys arba programos vykdymo rezultatai; nemokami tekstai; grafiniai vaizdai ir kt. Katalogas (aplankas, katalogas) - pavadintas baitų rinkinys laikmenoje, kuriame yra pakatalogių ir failų pavadinimai, naudojamas failų sistemoje, siekiant supaprastinti failų organizavimą.

Failų sistema

vadinama funkcine operacinės sistemos dalimi, kuri atlieka operacijas su failais. Failų sistemų pavyzdžiai yra FAT (FAT – failų paskirstymo lentelė), NTFS, UDF (naudojami kompaktiniuose diskuose).

Yra trys pagrindinės FAT versijos: FAT12, FAT16 ir FAT32. Jie skiriasi disko struktūros įrašų bitų gyliu, t.y. bitų skaičius, skirtas saugoti klasterio numerį. FAT12 daugiausia naudojamas diskeliams (iki 4 KB), FAT16 – mažos talpos diskams, FAT32 – didelės talpos FLASH diskams (iki 32 GB).

Pažvelkime į failų sistemos struktūrą, kaip pavyzdį naudodami FAT32.

FAT32 failo struktūra

Išoriniai FAT32 sistemos atminties įrenginiai turi blokų, o ne baitų adresavimą. Informacija įrašoma į išorinį atminties įrenginį blokais arba sektoriais. Sektorius yra minimalus adresuojamas informacijos saugojimo išoriniuose saugojimo įrenginiuose vienetas. Paprastai sektoriaus dydis yra fiksuotas 512 baitų. Siekiant padidinti išorinių atminties įrenginių adresų erdvę, sektoriai sujungiami į grupes, vadinamas klasteriais. Klasteris yra kelių sektorių sąjunga, kurią galima laikyti nepriklausomu vienetu

tam tikros savybės

Failų rašymui naudojami klasteriai numeruojami pradedant nuo 2. Klasterį Nr. 2 paprastai naudoja šakninis katalogas, o nuo 3 klasterio yra saugomas duomenų masyvas. Sektoriai, naudojami informacijai saugoti virš šakninio katalogo, nėra sugrupuoti.
Mažiausias reikalingo failo dydis diske atitinka 1 klasterį.

Įkrovos sektorius prasideda tokia informacija:

• EB 58 90 – besąlyginis šuolis ir parašas;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
• 00 02 – baitų skaičius sektoriuje (dažniausiai 512);
• 1 baitas – sektorių skaičius klasteryje;
• 2 baitai – rezervinių sektorių skaičius.

Be to, įkrovos sektoriuje yra ši svarbi informacija:

• 0x10 (1 baitas) – FAT lentelių skaičius (dažniausiai 2);
• 0x20 (4 baitai) – sektorių skaičius diske;
• 0x2С (4 baitai) – šakninio katalogo klasterio numeris;
• 0x47 (11 baitų) – tūrio etiketė;
• 0x1FE (2 baitai) – įkrovos sektoriaus parašas (55 AA).

Failų sistemos informacijos sektoriuje yra:

• 0x00 (4 baitai) – parašas (52 52 61 41);
• 0x1E4 (4 baitai) – parašas (72 72 41 61);
• 0x1E8 (4 baitai) – laisvų klasterių skaičius, -1, jei nežinoma;
• 0x1EC (4 baitai) – paskutinio įrašyto klasterio numeris;
• 0x1FE (2 baitai) – parašas (55 AA).

FAT lentelėje yra informacija apie kiekvienos grupės diske būseną. Apatiniai 2 FAT lentelės baitai saugo F8 FF FF 0F FF FF FF FF (tai atitinka 0 ir 1 grupių būseną, kurių fiziškai nėra). Toliau kiekvienos klasterio būsenoje yra klasterio, kuriame tęsiasi dabartinis failas, numeris arba ši informacija:

• 00 00 00 00 – klasteris nemokamas;
• FF FF FF 0F – esamo failo pabaiga.

• 8 baitai – failo pavadinimas;
• 3 baitai – failo plėtinys;

Šakniniame kataloge yra 32 bitų informacijos įrašų rinkinys apie kiekvieną failą, kuriame yra ši informacija:

Jei dirbate su ilgi vardai failų (įskaitant rusiškus pavadinimus), failo pavadinimas užkoduotas UTF-16 kodavimo sistemoje. Šiuo atveju kiekvienam simboliui koduoti skiriami 2 baitai. Šiuo atveju failo pavadinimas rašomas tokia struktūra:

• 1 sekos baitas;
• 10 baitų yra 5 apatiniai failo pavadinimo simboliai;
• 1 baito atributas;
• 1 baitas rezervuotas;
• 1 baitas – DOS vardo kontrolinė suma;
• 12 baitų yra 3 apatiniai failo pavadinimo simboliai;
• 2 baitai – pirmo klasterio numeris;
• likusieji ilgojo vardo simboliai.

Darbas su failais C kalba

Programuotojui atidarytas failas yra vaizduojamas kaip skaitomų arba įrašomų duomenų seka. Kai failas atidaromas, jis susiejamas su I/O srautas. Išvesties informacija įrašoma į srautą, įvesties informacija nuskaitoma iš srauto.

Kai srautas atidaromas I/O, jis susiejamas su standartine FILE struktūra, kuri apibrėžta stdio.h. FILE struktūroje yra reikalinga informacija apie failą.

Failas atidaromas naudojant funkciją fopen(), kuri grąžina žymeklį į FILE struktūrą, kurią galima naudoti tolimesnėms failo operacijoms.

FAILAS *fopen(vardas, tipas);

• "r" - atidarykite failą skaitymui (failas turi egzistuoti);
• "w" - atidarykite tuščią failą rašymui; jei failas egzistuoja, jo turinys prarandamas;
• "a" - atidarykite failą rašymui iki galo (pridėjimui); failas sukuriamas, jei jo nėra;
• "r+" - atidarykite failą skaitymui ir rašymui (failas turi egzistuoti);
• "w+" - atidarykite tuščią failą skaitymui ir rašymui; jei failas egzistuoja, jo turinys prarandamas;
• "a+" - atidarykite failą skaitymui ir pridėjimui, jei failo nėra, tada jis sukuriamas.

Grąžinama vertė yra rodyklė į atvirą srautą. Jei įvyksta klaida, grąžinama NULL.

Funkcija fclose() uždaro srautą ar srautus, susietus su failais, atidarytais naudojant funkciją fopen(). Uždaromas srautas nustatomas pagal funkcijos fclose() argumentą.

Grąžinama reikšmė: vertė 0, jei srautas buvo sėkmingai uždarytas; pastovus EOF, jei įvyko klaida.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#įtraukti
int main() (
FILE *fp;
char pavadinimas = "mano.txt" ;
if ((fp = fopen(vardas, "r" )) == NULL )
{
printf( "Nepavyko atidaryti failo");
getchar ();
grąžinti 0;
}
// pavyko atidaryti failą
... // būtini veiksmai su duomenimis
fclose(fp);
getchar ();
grąžinti 0;
}

Simbolio skaitymas iš failo:

char fgetc(srautas);

Simbolio įrašymas į failą:

fputc(char, srautas);

Funkcijos argumentai yra simbolis ir rodyklė į FILE tipo srautą. Funkcija grąžina perskaityto simbolio kodą.

Funkcijos fscanf() ir fprintf() yra panašios į scanf() ir printf() funkcijas, tačiau veikia su duomenų failais, o pirmasis argumentas yra failo rodyklė.

fscanf(stream, "InputFormat", argumentai);

Anksčiau įvesdami ir išvesdami duomenis dirbome su standartiniais srautais – klaviatūra ir monitoriumi. Dabar pažiūrėkime, kaip C kalba priima duomenis iš failų ir įrašo juos ten. Prieš atlikdami šias operacijas, turite atidaryti failą ir jį pasiekti.

C programavimo kalboje rodyklė į failą yra FILE tipo, o jo deklaracija atrodo taip:
FILE *mano failas;

Kita vertus, funkcija fopen () atidaro failą adresu, nurodytu kaip pirmasis argumentas skaitymo („r“), rašymo („w“) arba pridėjimo („a“) režimu ir grąžina į jį žymeklį. prie programos. Todėl failo atidarymo ir prijungimo prie programos procesas atrodo maždaug taip:
mano failas = fopen("labas.txt", "r");

Skaitant arba įrašant duomenis į failą, jis pasiekiamas per failo žymeklį (šiuo atveju mano failas).

Jei dėl vienokių ar kitokių priežasčių (nurodytu adresu failo nėra, prieiga prie jo uždrausta) funkcija fopen() negali atidaryti failo, tada ji grąžina NULL. Realiose programose jie beveik visada apdoroja failo atidarymo klaidą if šakoje, bet mes to praleisime.

Funkcijos fopen() deklaracija yra stdio.h antraštės faile, todėl ji turi būti įtraukta. Taip pat stdio.h yra deklaruojamas struktūros tipas FILE.

Baigus darbą su failu, įprasta jį uždaryti, kad buferis būtų atlaisvintas nuo duomenų ir dėl kitų priežasčių. Tai ypač svarbu, jei programa ir toliau veikia po darbo su failu. Ryšys tarp išorinio failo ir programos rodyklės į jį nutraukiamas naudojant fclose() funkciją. Rodyklė į failą perduodama kaip parametras:
fclose(mano failas);

Programoje galima atidaryti daugiau nei vieną failą. Tokiu atveju kiekvienas failas turi būti susietas su savo failo žymekliu. Tačiau jei programa pirmiausia dirba su vienu failu, o paskui jį uždaro, tada žymeklį galima naudoti norint atidaryti antrą failą.

Skaitymas iš tekstinio failo ir rašymas į jį

fscanf()

Fscanf () funkcija yra panaši į funkciją scanf (), tačiau, skirtingai nei ji, ji pateikia suformatuotą įvestį iš failo, o ne iš standartinio įvesties srauto. Fscanf() funkcija paima parametrus: failo žymeklį, formato eilutę, atminties sričių adresus duomenims rašyti:
fscanf(mano failas, "%s%d", str, &a);

Grąžina sėkmingai nuskaitytų duomenų arba EOF skaičių. Tarpai ir naujos eilutės simboliai skaičiuojami kaip duomenų skyrikliai.

Tarkime, kad turime failą, kuriame yra toks objektų aprašymas:

Obuoliai 10 23,4 bananai 5 25,0 duona 1 10,3

#įtraukti main () ( FILE * failas; struct food ( char name[ 20 ] ; nepasirašytas kiekis; plaukiojanti kaina; ) ; struct food shop[ 10 ] ; char i= 0 ; file = fopen ( "fscanf.txt", "r" ) ; while (fscanf (failas, "%s%u%f" , shop[ i].name , & (shop[ i].qty ) , & (shop[ i].price ) != EOF) ( printf ( "%s %u %.2f \n", parduotuvė[ i].pavadinimas, parduotuvė[ i].v., parduotuvė[ i].kaina) ;

i++;

) )

Šiuo atveju deklaruojama struktūra ir struktūrų masyvas. Kiekviena failo eilutė atitinka vieną masyvo elementą; masyvo elementas yra struktūra, kurią sudaro eilutė ir du skaitmeniniai laukai. Ciklas skaito vieną eilutę per iteraciją. Kai aptinkama failo pabaiga, fscanf() grąžina EOF ir ciklas baigiasi.
fgets ()

Fgets() funkcija yra panaši į gets() funkciją ir atlieka eilutę po eilutės įvestį iš failo. Vienas iškvietimas į fgets() nuskaitys vieną eilutę. Tokiu atveju galite perskaityti ne visą eilutę, o tik dalį jos nuo pat pradžių. fgets() parametrai atrodo taip:
fgets (simbolių_masyvas, perskaitytų_simbolių_skaičius, rodyklė_į_failą)

Pavyzdžiui:

#įtraukti fgets (str, 50, mano failas) \n"Šis funkcijos iškvietimas iš failo, susieto su mano failo žymekliu, nuskaitys vieną visą teksto eilutę, jei jos ilgis yra mažesnis nei 50 simbolių, įskaitant simbolį „\n“, kurį funkcija taip pat išsaugos masyve. Paskutinis (50-asis) str masyvo elementas bus simbolis „\0“, pridėtas fgets() . Jei eilutė ilgesnė, funkcija skaitys 49 simbolius ir pabaigoje parašys „\0“. Tokiu atveju „\n“ skaitymo eilutėje nebus.

#define N 80 main () ( FILE * failas; char arr[ N] ; failas = fopen ("fscanf.txt", "r") ; while (fgets (arr, N, failas) != NULL) printf (" %s" , arr) ; printf ("

) ;

fclose(failas);

) \n"Šioje programoje, skirtingai nei ankstesnėje, duomenys eilutė po eilutės skaitomi į masyvą. Kai skaitoma kita eilutė, ankstesnė prarandama. Fgets() funkcija grąžina NULL, jei negali nuskaityti kitos eilutės. \0 " getc() arba fgetc() \n" Funkcija getc() arba fgetc() (abi veikia) leidžia iš failo gauti kitą vieną simbolį. \0 " getc() arba fgetc() \n" while ((arr[ i] = fgetc (failas) ) != EOF) ( if (arr[ i] == "

) (arr[i] = "

;

printf("%s

• , arr) ;
• Išvestis po eilutės. Funkcija fputs(string, file_pointer) .
• Išvestis po simbolio. Funkcija fputc() arba putc(simbolis, failo_rodiklis) .

Žemiau pateikiami kodo pavyzdžiai, kuriuose naudojami trys duomenų išvedimo į failą metodai.

Vienos struktūros laukų įrašymas į kiekvieną failo eilutę:

failas = fopen ("fprintf.txt" , "w" ) ; \n" while (scanf ("%s%u%f" , shop[ i].name , & (shop[ i].qty ) , & (shop[ i].price ) ) != EOF) ( fprintf (failas, " %s %u %.2f

, parduotuvė[ i].pavadinimas, parduotuvė[ i].v., parduotuvė[ i].kaina) ;

i++; \n")

Eilutė po eilutės išvestis į failą (fputs(), skirtingai nei pats puts(), eilutės pabaigoje nededa „\n“):

while (gets (arr) != NULL) ( fputs (arr, file); fputs ("

, failas);

)

Išvesties po simbolio pavyzdys:

while ((i = getchar () ) != EOF) putc (i, failas) ;

Skaitymas iš dvejetainio failo ir rašymas į jį

1. Su failu galite dirbti ne kaip simbolių seka, o kaip baitų seka. Iš esmės su netekstiniais failais dirbti kitaip negalima. Tačiau tokiu būdu galite skaityti ir rašyti tekstinius failus. Šio failo prieigos būdo pranašumas yra skaitymo ir rašymo greitis: per vieną prieigą galima nuskaityti / įrašyti didelį informacijos bloką.
2. Atidarant dvejetainės prieigos failą, antrasis fopen() parametras yra eilutė „rb“ arba „wb“.
3. Darbo su dvejetainiais failais tema yra gana sudėtinga ir jai reikia atskiros pamokos. Čia bus pažymėtos tik failo, kuris laikomas baitų srautu, skaitymo ir rašymo į jį funkcijų ypatybės.
4. Funkcijos fread() ir fwrite() laikomos parametrais:

atminties srities, iš kurios įrašomi arba nuskaitomi duomenys, adresas,

bet kokio tipo dydis,

#įtraukti nurodyto dydžio nuskaitytų duomenų kiekis, failų indeksas. \0 " Šios funkcijos grąžina sėkmingai perskaitytų arba įrašytų duomenų skaičių. Tie. galite "užsakyti" nuskaityti 50 duomenų elementų, bet gauti tik 10. Klaidos nebus. \n" Funkcijų fread() ir fwrite() naudojimo pavyzdys: \0 " #įtraukti

Čia bandoma nuskaityti 50 simbolių iš pirmojo failo. n saugo faktiškai perskaitytų simbolių skaičių. n reikšmė gali būti 50 arba mažesnė. Duomenys dedami į eilutę. Tas pats atsitinka su antruoju failu. Tada pirmoji eilutė pridedama prie antrosios, o duomenys iškeliami į trečiąjį failą.

Problemų sprendimas

1. Parašykite programą, kuri paklausia vartotojo tekstinio failo pavadinimo (adreso), tada jį atidaro ir suskaičiuoja jame esančių simbolių ir eilučių skaičių.
2. Parašykite programą, kuri įrašo į failą duomenis, gautus iš kito failo ir kokiu nors būdu pakeistą prieš rašant. Kiekviena duomenų eilutė, gauta iš failo, turi tilpti į struktūrą.

Žymos: Tekstiniai failai, fopen, fclose, feof, setbuf, setvbuf, fflush, fgetc, fprintf, fscanf, fgets, buferinis srautas, nebuferinis srautas.

Darbas su tekstiniais failais

Darbas su tekstiniu failu panašus į darbą su konsole: naudodami suformatuotas įvesties funkcijas išsaugome duomenis į failą, naudodamiesi formatuotomis išvesties funkcijomis skaitome duomenis iš failo. Yra daug niuansų, kuriuos apžvelgsime vėliau. Pagrindinės operacijos, kurias reikia atlikti, yra

• 1. Atidarykite failą, kad jį būtų galima pasiekti. Atitinkamai, galite atidaryti jį skaitymui, rašymui, skaitymui ir rašymui, perrašymui ar rašymui iki failo pabaigos ir pan. Atidarius failą taip pat gali įvykti aibė klaidų – failo gali nebūti, gali būti netinkamo tipo failas, neturėti leidimo dirbti su failu ir pan. Į visa tai reikia atsižvelgti.
• 2. Tiesioginis darbas su byla – rašymas ir skaitymas. Čia taip pat reikia prisiminti, kad dirbame ne su laisvosios kreipties atmintimi, o su buferiniu srautu, kuris prideda savo specifikos.
• 3. Uždarykite failą. Kadangi failas yra išorinis programos išteklius, jei jis neuždarytas, jis ir toliau kabės atmintyje, galbūt net ir uždarius programą (pvz., nebus galima ištrinti atidaryto failo ar atlikti pakeitimų, ir tt). Be to, kartais reikia ne uždaryti, o „iš naujo atidaryti“ failą, pavyzdžiui, norint pakeisti prieigos režimą.

Be to, yra keletas užduočių, kai mums nereikia pasiekti failo turinio: pervardyti, perkelti, kopijuoti ir pan. Deja, C standarte nėra šių poreikių funkcijų aprašymo. Žinoma, jie yra prieinami kiekvienam kompiliatoriaus diegimui. Katalogo (aplanko, katalogo) turinio skaitymas taip pat yra prieiga prie failo, nes pats aplankas yra failas su metainformacija.

Kartais reikia atlikti kai kurias pagalbines operacijas: perkelti į norimą vietą faile, prisiminti esamą situaciją, nustatyti failo ilgį ir kt.

Norėdami dirbti su failu, jums reikia FILE objekto. Šiame objekte saugomas failo srauto identifikatorius ir informacija, reikalinga jam valdyti, įskaitant rodyklę į buferį, failo padėties indikatorių ir būsenos indikatorius.

Objektas FILE pats yra struktūra, tačiau jo laukai neturėtų būti pasiekiami. Nešiojamoji programa turi laikyti failą kaip abstraktų objektą, leidžiantį pasiekti failų srautą.

Atminties kūrimas ir paskirstymas objekto tipo FILE atliekamas naudojant funkciją fopen arba tmpfile (yra ir kitų, bet mes sutelksime dėmesį tik į juos).

Funkcija fopen atidaro failą. Jis gauna du argumentus - eilutę su failo adresu ir eilutę su failo prieigos režimu. Failo pavadinimas gali būti absoliutus arba santykinis. fopen grąžina žymeklį į FILE objektą, kurį galima naudoti toliau prieiti prie failo.

FILE* fopen(const char* failo pavadinimas, const char* režimas);

Pavyzdžiui, atidarykime failą ir į jį įrašykime Hello World

#įtraukti #įtraukti #įtraukti void main() ( //Naudodami failo kintamąjį pasieksime failą FILE *file; //Atidarykite tekstinį failą su rašymo leidimais file = fopen ("C:/c/test.txt", "w+t") ; //Įrašykite į failą fprintf(file, "Sveikas, pasauli!" //Uždarykite failą fclose(file);

Pati funkcija fopen paskiria atmintį objektui valymą atlieka fclose funkcija. Būtina uždaryti failą, jis neužsidarys savaime.

Funkcija fopen gali atidaryti failą tekstiniu arba dvejetainiu režimu. Numatytasis yra tekstas. Prieigos režimas gali būti toks

Jei reikia atidaryti failą dvejetainiu režimu, eilutės pabaigoje pridedama raidė b, pvz., „rb“, „wb“, „ab“ arba, naudojant mišrųjį režimą, „ab+“, „ wb+“, „ab+“. Vietoj b galite pridėti raidę t, tada failas bus atidarytas teksto režimu. Tai priklauso nuo įgyvendinimo. Naujajame C standarte (2011 m.) raidė x reiškia, kad fopen turėtų nepavykti, jei failas jau egzistuoja. Papildykime savo sena programa: Iš naujo atidarykime failą ir apsvarstykime, ką ten parašėme.

#įtraukti #įtraukti #įtraukti void main() ( FILE *failas; char buferis; failas = fopen ("C:/c/test.txt", "w"); fprintf (failas, "Sveikas, pasauli!"); fclose (failas); failas = fopen("C:/c/test.txt", "r" fgets(buferis, 127, printf("%s", buferis(failas);));

Vietoj funkcijos fgets galite naudoti fscanf, tačiau reikia atsiminti, kad ji gali nuskaityti tik eilutę iki pirmos vietos.
fscanf(failas, "%127s", buferis);

Be to, užuot atidarę ir uždarę failą, galite naudoti funkciją „Freopen“, kuri „iš naujo atidaro“ failą su naujomis prieigos teisėmis.

#įtraukti #įtraukti #įtraukti void main() ( FILE *failas; char buferis; failas = fopen ("C:/c/test.txt", "w"); fprintf (failas, "Sveikas, pasauli!"); freopen ("C:/" c/test.txt", "r", failas); fgets (buferis, 127, failas); printf ("%s", buferis); fclose (failas); getch (); )

Funkcijos fprintf ir fscanf skiriasi nuo printf ir scanf tik tuo, kad jos kaip pirmąjį argumentą laiko žymeklį į FAILĄ, į kurį bus išvesta arba iš kurio nuskaitys duomenis. Verta iš karto pridurti, kad printf ir scanf funkcijas galima lengvai pakeisti fprintf ir fscanf funkcijomis. OS (laikome labiausiai paplitusią ir tinkamiausią operacinės sistemos) yra trys standartiniai srautai: standartinis išvesties stdout, standartinės įvesties stdin ir standartinės klaidos išvesties stderr. Jie automatiškai atidaromi paleidus programą ir yra susieti su konsole. Pavyzdys

#įtraukti #įtraukti #įtraukti void main() ( int a, b; fprintf(stdout, "Įveskite du skaičius\n"); fscanf(stdin, "%d", &a); fscanf(stdin, "%d", &b); if (b == 0) ( fprintf(stderr, "Klaida: padalinti iš nulio"); ) else ( fprintf(stdout, "%.3f", (float) a / (float) b); ) getch();

Klaida atidarant failą

Jei funkcijos fopen iškvietimas nepavyksta, jis grąžins NULL. Klaidos dirbant su failais pasitaiko gana dažnai, todėl kiekvieną kartą atidarius failą reikia patikrinti darbo rezultatą

#įtraukti #įtraukti #įtraukti #define ERROR_OPEN_FILE -3 void main() ( FAILAS *failas; char buferis; failas = fopen("C:/c/test.txt", "w"); if (failas == NULL) ( printf ("Klaida atidarant failas"); getch(); išeiti (ERROR_OPEN_FILE); ) fprintf (failas, "Sveikas, pasauli!"); freopen ("C:/c/test.txt", "r", failas); if (failas = = NULL) ( printf("Klaida atidarant failą"); getch(); exit(ERROR_OPEN_FILE); ) fgets(buferis, 127, failas) printf("%s", buferis(failas); ; )

Problema kyla, kai vienu metu atidaromi keli failai: jei vieno iš jų nepavyksta atidaryti, likusius taip pat reikia uždaryti

FILE *inputFile, *outputFile;

nepasirašytas m, n; nepasirašytas i, j;įvesties failas = fopen(INPUT_FILE, READ_ONLY); if (inputFile == NULL) ( printf("Klaida atidarant failą %s", INPUT_FILE); getch(); exit(3); ) outputFile = fopen(OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) ( printf ("Klaida atidarant failą %s", OUTPUT_FILE); getch(); if (inputFile != NULL) ( fclose (inputFile); ) exit (4); ) ...

IN

paprasti atvejai

• galite veikti tiesiai, kaip ir ankstesnėje kodo dalyje. Daugiau
• sunkių atvejų
• naudojami metodai, pakeičiantys RAII iš C++: vyniotuvai arba kompiliatoriaus funkcijos (išvalymas GCC) ir kt.
• Duomenų buferis

Kaip minėta anksčiau, kai išvedame duomenis, jie pirmiausia įdedami į buferį. Buferis išvalytas

#įtraukti #įtraukti #įtraukti 1) Jei jis pilnas

2) Jei srautas uždarytas

3) Jei aiškiai nurodome, kad reikia išvalyti buferį (čia taip pat yra išimčių :)).

4) Taip pat išvalyta, jei programa sėkmingai baigta. Tuo pačiu metu visi failai uždaromi. Vykdymo laiko klaidos atveju tai gali neįvykti.

kuris paima jau atidarytą FILE ir žymeklį į naują buferį. Naujo buferio dydis turi būti ne mažesnis nei BUFSIZ (pavyzdžiui, dabartinėje darbo stotyje BUFSIZ yra 512 baitų). Jei perduodate NULL kaip buferį, srautas bus nebuferinis. Taip pat galite naudoti funkciją

Int setvbuf(FILE * srautas, char * buferis, int režimas, dydis_t dydis);

kuri priima savavališko dydžio buferį. Režimas gali turėti šias reikšmes

• _IOFBF- pilnas buferis. Duomenys įrašomi į failą, kai jis pilnas. Skaitant buferis laikomas pilnu, kai prašoma atlikti įvesties operaciją, o buferis tuščias.
• _IOLBF- linijinis buferis. Duomenys įrašomi į failą, kai jis pilnas arba kai aptinkamas naujos eilutės simbolis. Skaitant buferis užpildomas iki naujos eilutės simbolio, kai prašoma atlikti įvesties operaciją, o buferis tuščias.
• _IONBF– nėra buferio. Tokiu atveju dydis ir buferio parametrai nepaisomi.

Pavyzdys: nustatykime savo buferį ir pažiūrėkime, kaip vyksta nuskaitymas iš failo. Tegul failas būna trumpas (kažkas panašaus į Hello, World!), ir mes skaitome jį po simbolio

#įtraukti #įtraukti #įtraukti void main() ( FILE *input = NULL; char c; char buferis = (0); input = fopen("D:/c/text.txt", "rt"); setbuf (įvestis, buferis); while ( !feof(input)) (c = fgetc(input); printf("%c\n", c); printf("%s\n", buferis); _getch(); ) fclose(input )

Matyti, kad duomenys jau yra buferyje. Skaitymas po simbolio atliekamas iš buferio.

feof

Funkcija int feof(FILE * srautas); grąžina true, jei pasiekiama failo pabaiga. Funkciją patogu naudoti, kai reikia peržiūrėti visą failą nuo pradžios iki pabaigos. Tegul yra failas su tekstiniu turiniu text.txt. Failą skaitome po simbolio ir rodome ekrane.

#įtraukti #įtraukti #įtraukti void main() ( FILE *input = NULL; char c; input = fopen ("D:/c/text.txt", "rt"); if (input == NULL) ( printf ("Klaida atidarant failą") _getch(0); o

Viskas būtų gerai, bet feof funkcija neveikia tinkamai... Taip yra dėl to, kad neapibrėžta sąvoka “failo pabaiga”. Klaida, kuri dažnai pasitaiko naudojant feof, yra tai, kad paskutiniai nuskaityti duomenys spausdinami du kartus. Taip yra dėl to, kad duomenys įrašomi į įvesties buferį, paskutinis skaitymas įvyksta su klaida ir funkcija grąžina seną nuskaitytą reikšmę.

#įtraukti #įtraukti #įtraukti void main() ( FILE *input = NULL; char c; input = fopen ("D:/c/text.txt", "rt"); if (input == NULL) ( printf ("Klaida atidarant failą") _getch(0); ();

Šis pavyzdys nepavyks (greičiausiai) ir du kartus išspausdins paskutinį failo simbolį.

Sprendimas yra nenaudoti feof. Pavyzdžiui, parduotuvė bendras kiekisįrašus arba naudoti faktą, kad fscanf ir kt. funkcijos paprastai grąžina teisingai perskaitytų ir suderintų reikšmių skaičių.

#įtraukti #įtraukti #įtraukti void main() ( FILE *input = NULL; char c; input = fopen ("D:/c/text.txt", "rt"); if (input == NULL) ( printf ("Klaida atidarant failą") _getch(0);

Pavyzdžiai

1. Viename faile yra du skaičiai – masyvo matmenys. Užpildykime antrą failą atsitiktinių skaičių masyvu.

#įtraukti #įtraukti #įtraukti #įtraukti //Failų pavadinimai ir teisės #define INPUT_FILE "D:/c/input.txt" #define OUTPUT_FILE "D:/c/output.txt" #define READ_ONLY "r" #define WRITE_ONLY "w" //Maksimali masyvo reikšmė dydis #define MAX_DIMENSION 100 //Klaida atidarant failą #define ERROR_OPEN_FILE -3 void main() ( FILE *inputFile, *outputFile; nepasirašytas m, n; nepasirašytas i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); if ( inputFile == NULL) ( printf("Klaida atidarant failą %s", INPUT_FILE); getch(); exit(ERROR_OPEN_FILE); ) outputFile = fopen(OUTPUT_FILE, WRITE_ONLY) (printf("Klaida). atidaryti failą %s", OUTPUT_FILE); getch(); //Jei failą galima atidaryti skaitymui, tada jį reikia uždaryti if (inputFile != NULL) ( fclose(inputFile); ) exit(ERROR_OPEN_FILE); ) fscanf (įvesties failas, „%ud %ud“, &m, &n); if (m > MAX_DIMENSION; ) if (n > MAX_DIMENSION; ) srand(laikas(NULL));< n; i++) { for (j = 0; j < m; j++) { fprintf(outputFile, "%8d ", rand()); } fprintf(outputFile, "\n"); } //Закрываем файлы fclose(inputFile); fclose(outputFile); }

2. Vartotojas nukopijuoja failą ir pirmiausia pasirenka darbo režimą: failą galima išvesti arba į pultą, arba nukopijuoti į naują failą.

#įtraukti #įtraukti #įtraukti #define ERROR_FILE_OPEN -3 void main() ( FILE *origin = NULL; FILE *output = NULL; char failo pavadinimas; int režimas; printf ("Įveskite failo pavadinimą: "); scanf ("%1023s", failo pavadinimas); origin = fopen (failo pavadinimas, "r"); if (origin == NULL) ( printf ("Klaida atidarant failą %s", failo pavadinimas); getch(); exit(ERROR_FILE_OPEN); ) printf ("įvesti režimą: "); d", &mode); if (mode == 1) ( printf ("Įveskite failo pavadinimą: "); scanf ("%1023s", failo pavadinimas); output = fopen(failo pavadinimas, "w"); if (išvestis = = NULL ) ( printf("Klaida atidarant failą %s", failo pavadinimas); getch(); fclose(origin); exit(ERROR_FILE_OPEN); ) ) else ( output = stdout; ) while (!feof(origin)) ( fprintf (išvestis) , "%c", fgetc(origin));

3. Vartotojas įveda duomenis iš konsolės ir jie įrašomi į failą, kol paspaudžiamas esc klavišas. Peržiūrėkite programą ir pamatysite. kaip jis elgiasi, jei įvesite atgalinį klavišą: kas išvedama į failą ir kas į konsolę.

#įtraukti #įtraukti #įtraukti #define ERROR_FILE_OPEN -3 void main() ( FILE *output = NULL; char c; output = fopen("D:/c/test_output.txt", "w+t"); if (output == NULL) ( printf ("Klaida atidarant failą"; _getch(); , stdout);

4. Faile yra sveikieji skaičiai. Raskite jų maksimumą. Pasinaudokime tuo, kad fscanf funkcija grąžina teisingai nuskaitytų ir suderintų objektų skaičių. Skaičius 1 turi būti grąžinamas kiekvieną kartą.

#įtraukti #įtraukti #įtraukti #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); if (input == NULL) ( printf("Klaida atidarant failą"); _getch(); exit(ERROR_FILE_OPEN); ) maxn = INT_MIN; hasRead = 1; while (hasRead == 1) ( hasRead = fscanf(input, "%d", &num); if (hasRead != 1) (tęsti; ) if (skaičius >

Kitas sprendimas yra skaityti skaičius, kol pasieksime failo pabaigą.

#įtraukti #įtraukti #įtraukti #įtraukti #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); if (input == NULL) ( printf("Klaida atidarant failą"); _getch(); exit(ERROR_FILE_OPEN); ) maxn = INT_MIN; while (!feof(input)) ( fscanf(input, "%d", &num); if (num > maxn ) ( maxn = skaičius; ) ) printf("maks. skaičius = %d", maxn);

5. Faile yra šie žodžiai: Rusiškas žodis, skirtukas, Angliškas žodis, keliomis eilėmis. Vartotojas įveda anglišką žodį, būtina išvesti rusišką.

Vertimo failas atrodo maždaug taip

saulės saulė
pieštukas
tušinukų pieštukas
durų durys
langų langas
kėdės kėdė
fotelis

ir išsaugotas cp866 koduotėje (OEM 866). Svarbu: paskutinė žodžių pora taip pat baigiasi eilutės padavimu.

Algoritmas yra toks: nuskaitome eilutę iš failo, eilutėje randame tabuliavimo simbolį, tabuliavimo simbolį pakeičiame nuliu, nukopijuojame rusišką žodį iš buferio, nukopijuojame anglišką žodį iš buferio, patikriname lygybę.

#įtraukti #įtraukti #įtraukti #įtraukti #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; char buferis; char enWord; char ruWord; char usrWord; be ženklo indeksas; int ilgis; int wasFound; input = fopen("D:/c/input.txt ", "r"); if (input == NULL) ( printf ("Klaida atidarant failą"); _getch(); exit(ERROR_FILE_OPEN); ) printf ("įveskite žodį: "); fgets(usrWord, 127, stdin wasFound = 0; while (!feof(input)) ( fgets(buffer, 511, input); ilgis = strlen(buffer); for (index = 0; index)< length; index++) { if (buffer == "\t") { buffer = "\0"; break; } } strcpy(ruWord, buffer); strcpy(enWord, &buffer); if (!strcmp(enWord, usrWord)) { wasFound = 1; break; } } if (wasFound) { printf("%s", ruWord); } else { printf("Word not found"); } fclose(input); _getch(); }

6. Suskaičiuokite failo eilučių skaičių. Mes skaitysime failą po simbolio, skaičiuodami „\n“ simbolių skaičių, kol susidursime su EOF simboliu. EOF yra specialus simbolis, nurodantis, kad įvestis baigta ir nebėra nuskaitytų duomenų. Klaidos atveju funkcija grąžina neigiamą reikšmę.
PASTABA: EOF yra int tipo, todėl simboliams skaityti reikia naudoti int. Be to, EOF vertė nėra apibrėžta standarte.

#define _CRT_SECURE_NO_WARNINGS #įtraukti #įtraukti #įtraukti int cntLines(const char *failo pavadinimas) ( int eilutės = 0; int bet koks; //bet kuris yra int tipo, nes EOF yra int! FILE *f = fopen(failo pavadinimas, "r"); if (f == NULL ) ( return -1; ) do ( any = fgetc(f); //printf("%c", any);//debug if (bet == "\n") ( eilutės++; ) ) while(bet ! = EOF (fclose);

Ru-Cyrl 18 pamoka Sypachevas S.S. 1989-04-14[apsaugotas el. paštas] Stepanas Sypačiovas

studentai

Vis dar neaišku? – rašykite klausimus į pašto dėžutę

Paskutinį kartą atnaujinta: 2015-10-31 Klasė FileStream

reiškia skaitymo iš failo ir rašymo į failą galimybes. Tai leidžia dirbti tiek su tekstiniais, tiek su dvejetainiais failais.

Panagrinėkime svarbiausias jo savybes ir būdus:

Length ypatybė: grąžina srauto ilgį baitais

Pozicijos ypatybė: grąžina dabartinę padėtį sraute

• masyvas – baitų masyvas, kuriame bus patalpinti iš failo nuskaityti duomenys

  poslinkis reiškia poslinkį baitais masyve, į kurį bus patalpinti skaitymo baitai

  skaičiuoti - maksimalus skaičius baitai, kuriuos reikia perskaityti. Jei faile yra mažiau baitų, visi jie bus nuskaityti.

Metodas long Seek (ilgas poslinkis, SeekOrigin kilmė): nustato vietą sraute su poslinkiu pagal poslinkio parametre nurodytą baitų skaičių.

Rašymo metodas: įrašo duomenis iš baitų masyvo į failą. Turi tris parametrus: Write (baitų masyvas, int poslinkis, int skaičius)

• masyvas – baitų masyvas, iš kurio duomenys bus įrašomi į failą

  poslinkis – poslinkis baitais masyve, nuo kurio baitai pradedami rašyti į srautą

  count – maksimalus įrašomų baitų skaičius

FileStream reiškia prieigą prie failų baitų lygiu, todėl, pavyzdžiui, jei reikia perskaityti arba įrašyti vieną ar daugiau eilučių į tekstinį failą, baitų masyvas turi būti konvertuojamas į eilutes naudojant specialius metodus. Todėl darbui su tekstiniais failais naudojamos kitos klasės.

Tuo pačiu metu dirbant su įvairiais dvejetainiais failais, turinčiais tam tikrą struktūrą, „FileStream“ gali būti labai naudingas norint išgauti tam tikras informacijos dalis ir ją apdoroti.

Pažvelkime į teksto failo skaitymo ir rašymo pavyzdį:

Console.WriteLine("Įveskite eilutę, kurią norite įrašyti į failą:"); string text = Console.ReadLine(); // rašymas į failą naudojant (FileStream fstream = new FileStream(@"C:\SomeDir\noname\note.txt", FileMode.OpenOrCreate)) ( // konvertuoti eilutę į baitus byte array = System.Text.Encoding. Numatytasis GetBytes(text) // baitų masyvo įrašymas į failą fstream = File. Ilgis); // dekoduoti baitus į eilutę textFromFile = System.Text.Encoding.Default.GetString(masyvas) Console.WriteLine("Tekstas iš failo: (0)", textFromFile ) Console.ReadLine();

Pažiūrėkime į šį pavyzdį. Tiek skaitymas, tiek rašymas naudoja naudojimo teiginį. Šio teiginio nereikėtų painioti su naudojimo direktyva, kuri apima vardų sritis kodo failo pradžioje. Naudojant sakinį galima sukurti objektą kodo bloke, kurį užbaigus iškviečiamas to objekto dispose metodas ir taip objektas sunaikinamas. Šiuo atveju kintamasis fstream tarnauja kaip toks objektas.

Fstream objektas sukuriamas dviem skirtingais būdais: naudojant konstruktorių ir naudojant vieną iš statinių failų klasės metodų.

Čia konstruktoriui perduodami du parametrai: failo kelias ir FileMode sąrašas. Šis sąrašas nurodo failo prieigos režimą ir gali turėti šias reikšmes:

Pridėti: jei failas yra, tekstas pridedamas prie failo pabaigos. Jei failo nėra, jis sukuriamas. Failas atidaromas tik rašymui.

Sukurti: sukuriamas naujas failas. Jei toks failas jau yra, jis perrašomas

CreateNew: sukuriamas naujas failas. Jei toks failas jau yra, programa pateikia klaidą

Atidaryti: atidaro failą. Jei failo nėra, daroma išimtis

OpenOrCreate : jei failas yra, jis atidaromas, jei ne, sukuriamas naujas

Sutrumpinti: jei failas yra, jis perrašomas. Failas atidaromas tik rašymui.

Failų klasės statinis OpenRead metodas atveria failą skaitymui ir grąžina FileStream objektą.

FileStream klasės konstruktorius taip pat turi nemažai perkrovų, kurios leidžia tiksliau pritaikyti kuriamą objektą. Visas šias versijas galima peržiūrėti msdn.

Tiek rašant, tiek skaitant naudojamas kodavimo objektas Encoding.Default iš System.Text vardų srities. Šiuo atveju naudojame du jo metodus: GetBytes, kad gautume baitų masyvą iš eilutės, ir GetString, kad gautume eilutę iš baitų masyvo.

Dėl to mūsų įvesta eilutė įrašoma į failą pastaba.txt. Iš esmės tai yra dvejetainis failas (ne tekstinis failas), nors jei į jį įrašome tik eilutę, mes galime peržiūrėti šį failą žmogui suprantama forma, atidarę jį teksto rengyklėje. Tačiau jei į jį įrašysime atsitiktinius baitus, pavyzdžiui:

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

Tada mums gali kilti problemų tai suprasti. Todėl atskiros klasės skirtos darbui tiesiogiai su tekstiniais failais – StreamReader ir StreamWriter.

Atsitiktinė prieiga prie failų

Dažnai dvejetainiai failai reiškia tam tikrą struktūrą. Ir, žinodami šią struktūrą, galime paimti reikiamą informaciją iš failo arba, atvirkščiai, įrašyti tam tikrą baitų rinkinį tam tikroje failo vietoje. Pavyzdžiui, wav failuose patys garso duomenys prasideda nuo 44 baitų, o iki 44 baitų yra įvairių metaduomenų – garso kanalų skaičiaus, diskretizavimo dažnio ir kt.

Naudodami Seek() metodą galime valdyti srauto žymeklio padėtį, pradedant nuo kurios failas skaitomas ar rašomas. Šis metodas apima du parametrus: poslinkį ir padėtį faile. Padėtis faile apibūdinama trimis reikšmėmis:

SeekOrigin.Begin : failo pradžia

SeekOrigin.End : failo pabaiga

SeekOrigin.Current : dabartinė padėtis faile

Srauto, nuo kurio pradedamas skaitymas arba rašymas, žymeklis perkeliamas į priekį pagal poslinkį, palyginti su padėtimi, nurodyta kaip antrasis parametras. Poslinkis gali būti neigiamas, tada žymeklis juda atgal, jei teigiamas, tada į priekį.

Pažiūrėkime į pavyzdį:

Naudojant System.IO; naudojant System.Text; class Programa ( static void Main(string args) ( string text = "hello world"; // rašymas į failą naudojant (FileStream fstream = new FileStream(@"D:\note.dat", FileMode.OpenOrCreate)) ( / / konvertuoti eilutę į baitus input = Encoding.Default.GetBytes(text) // įrašyti baitų masyvą į failą fstream.Write(input, 0, input.Length); ); dabartinės padėties baitų išvestis = naujas baitas (išvestis, 0, išvestis.Length) // iššifruoti baitus į eilutę textFromFile = Encoding.Default.GetString(output)("Tekstas iš failo: (0)"); , textFromFile); GetBytes(replaceText , 0, input.Length);

// perskaityti visą failą // grąžinti žymeklį į failo pradžią fstream.Seek(0, SeekOrigin.Begin);

išvestis = naujas baitas;

Iškvietus fstream.Seek(-5, SeekOrigin.End), srauto žymeklis perkeliamas į failų pabaigą penkiais simboliais:

Tai reiškia, kad į naują failą įrašius eilutę „hello world“, žymeklis bus „w“ simbolio vietoje.

Po to skaitome keturis baitus, prasidedančius simboliu „w“. Šioje koduotėje 1 simbolis bus 1 baitas. Todėl 4 baitų skaitymas prilygs keturių simbolių skaitymui: „worl“.

Tada vėl pereiname prie failo pabaigos, nepasiekdami penkių simbolių pabaigos (tai yra, vėl iš „w“ simbolio padėties), ir įrašome eilutę „house“. Taigi eilutė „namas“ pakeičia eilutę „pasaulis“.

Gijos uždarymas

Aukščiau pateiktuose pavyzdžiuose srautui uždaryti naudojama naudojant konstrukcija. Apdorojus visus naudojamo bloko operatorius ir išraiškas, FileStream objektas sunaikinamas. Tačiau galime pasirinkti kitą būdą:

FileStream fstream = null; try ( fstream = new FileStream(@"D:\note3.dat", FileMode.OpenOrCreate); // operacijos su srautu ) catch(Exception ex) ( ) final ( if (fstream != null) fstream.Close() ;)

Jei nenaudojame naudojant konstrukcijos, turime aiškiai iškviesti Close() metodą: fstream.Close()

Tekstiniai failai

Pažiūrėkime, kaip dirbti su tekstiniu failu C, naudodami pavyzdį. Sukurkite tekstinį failą C diske pavadinimu TextFile.txt. Šiame faile įveskite šias eilutes:

Styga_1 123 eilutė_11, 456
Styga_2
Styga_3

Išsaugokite failą.

Tai yra C programos, kuri atidaro mūsų failą ir nuskaito eilutes iš jo, kodas:

/* *Autorius: @author Subbotin B.P..h> #include #define LEN 50 int main(void) ( puts ("Teksto failo operacijos"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( puts("Problems"); return EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile) return EXIT_SUCCESS;

Norėdami atidaryti tekstinį failą C, naudokite funkciją fopen:

FAILAS *pTextFile = fopen("C:\\Tekstofailas.txt", "r");

Pirmasis funkcijos fopen argumentas nurodo failą, o antrasis sako, kad failas yra atidarytas skaityti iš jo.

Eilutes skaitome naudodami fgets funkciją:

fgets(cArray, LEN, pTextFile);

Pirmasis funkcijos fgets argumentas nurodo simbolių masyvą, kuriame bus saugomos gautos eilutės, antrasis argumentas yra didžiausias skaitomų simbolių skaičius, o trečiasis yra mūsų failas.

Baigę dirbti su failu, turite jį uždaryti:

fclose(pTextFile);

Mes gauname:

Eilutėse atsiranda ir rusiškų raidžių.

Beje, šią programą sukūriau Eclipse. Galite pamatyti, kaip dirbti su C/C++ programoje Eclipse.

Taigi, atidarėme ir perskaitėme duomenis iš tekstinio failo.

Dabar sužinokime, kaip programiškai sukurti tekstinį failą ir įrašyti į jį duomenis.

/* Autorius: @author Subbotin B.P..h> #įtraukti int main(void) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "Tai yra eilutė"; char cNewLine = "\n"; int nVal = 123 ; if(pTextFile == NULL) ( puts ("Problemos"); return EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine );

Sukurkite tekstinį failą duomenims įrašyti:

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

jei failas jau yra, jis bus atidarytas ir visi duomenys iš jo bus ištrinti.

C-string cString ir skaičių nVal programa įrašo į tekstinį failą. cNewLine yra tiesiog nauja eilutė.

Duomenis įrašome į tekstinį failą naudodami fprintf funkciją:

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

pirmasis argumentas yra mūsų failas, antrasis yra formato eilutė, trečiasis ar daugiau yra argumentų, reikalingų šiam formatui, skaičius.