C Failide sisend/väljund: faili loomine, avamine, lugemine, kirjutamine ja sulgemine

C Failihaldus

Faili saab kasutada suure hulga püsivate andmete salvestamiseks. Nagu paljud teised keeled, pakub ka C järgmisi failihaldusfunktsioone,

1. Faili loomine
2. Faili avamine
3. Faili lugemine
4. Faili kirjutamine
5. Faili sulgemine

Järgmised on kõige olulisemad failihaldusfunktsioonid, mis on saadaval 'C'-s,

funktsioon	eesmärk
avada ()	Faili loomine või olemasoleva faili avamine
fclose ()	Faili sulgemine
fprintf()	Andmeploki kirjutamine faili
fscanf ()	Plokiandmete lugemine failist
getc ()	Loeb failist ühe tähemärgi
putc ()	Kirjutab faili ühe märgi
getw ()	Loeb failist täisarvu
putw ()	Täisarvu kirjutamine faili
fseek ()	Määrab failikursori asukoha määratud asukohta
ftell ()	Tagastab failikursori praeguse asukoha
tagasikerimine ()	Määrab failikursori faili algusesse

Kuidas faili luua

Kui soovite failiga töötada, on esimene samm faili loomine. Fail pole midagi muud kui ruum mälus, kuhu andmeid salvestatakse.

Faili loomiseks programmis C kasutatakse järgmist süntaksit,

FILE *fp;
fp = fopen ("file_name", "mode");

Ülaltoodud süntaksis on fail andmestruktuur, mis on määratletud standardses teegis.

fopen on standardfunktsioon, mida kasutatakse faili avamiseks.

• Kui faili süsteemis pole, luuakse see ja seejärel avatakse.
• Kui fail on süsteemis juba olemas, avatakse see selle abil otse funktsioon.

fp on failikursor, mis osutab tüübifailile.

Iga kord, kui avate või loote faili, peate määrama, mida kavatsete failiga teha. C-programmeerimisega faili saab lugemiseks/kirjutamiseks luua või avada. Režiimi kasutatakse selleks, et määrata, kas soovite faili mõnel allpool nimetatud eesmärgil avada. Järgnevalt on toodud erinevad C-programmeerimise režiimid, mida saab failiga töötamisel kasutada.

Failirežiim	Kirjeldus
r	Avage fail lugemiseks. Kui fail on lugemisrežiimis, siis andmeid ei kustutata, kui fail on süsteemis juba olemas.
w	Avage fail kirjutamiseks. Kui fail on kirjutamisrežiimis, luuakse uus fail, kui faili pole üldse olemas. Kui fail on süsteemis juba olemas, kärbitakse kõik failis olevad andmed ja see avatakse kirjutamiseks.
a	Avage fail sisse lisamisrežiim. Kui fail on lisamisrežiimis, avatakse fail. Faili sisu ei muutu.
r+	algusest peale lugemiseks ja kirjutamiseks avatud
w+	avatud lugemiseks ja kirjutamiseks, faili ülekirjutamine
a+	avatud lugemiseks ja kirjutamiseks, failile lisamine

Antud süntaksis on failinimi ja režiim määratud stringidena, seega peavad need olema alati jutumärkides.

Näide:

#include <stdio.h>
int main() {
FILE *fp;
fp  = fopen ("data.txt", "w");
}

Väljund:

Fail luuakse samasse kausta, kuhu olete oma koodi salvestanud.

Saate määrata tee, kuhu soovite faili luua

#include <stdio.h>
int main() {
FILE *fp;
fp  = fopen ("D://data.txt", "w");
}

Kuidas faili sulgeda

Fail tuleks alati sulgeda, kui failiga seotud toimingud on lõppenud. See tähendab, et faili sisu ja lingid on lõpetatud. See hoiab ära faili juhusliku kahjustamise.

"C" pakub fclose funktsiooni faili sulgemise toimingu tegemiseks. Fclose süntaks on järgmine,

fclose (file_pointer);

Näide:

FILE *fp;
fp  = fopen ("data.txt", "r");
fclose (fp);

Funktsioon fclose võtab argumendina failikursori. Seejärel suletakse failikursoriga seotud fail funktsiooni fclose abil. Tagastab 0, kui sulgemine õnnestus, ja EOF (faili lõpp), kui faili sulgemisel ilmnes tõrge.

Pärast faili sulgemist saab sama failikursorit kasutada ka teiste failidega.

"C" programmeerimisel suletakse failid programmi lõpetamisel automaatselt. Faili käsitsi sulgemine, kirjutades funktsiooni fclose, on hea programmeerimistava.

Faili kirjutamine

C-s tuleb faili kirjutamisel lisada reavahetusmärgid '\n'.

Stdio teek pakub faili kirjutamiseks vajalikke funktsioone:

• fputc (char, faili_osutaja): Kirjutab märgi faili, millele osutab faili_pointer.
• fputs(str, faili_pointer): See kirjutab stringi faili, millele osutab fail_pointer.
• fprintf(faili_pointer, str, muutujate_loendid): See prindib stringi faili, millele osutas fail_pointer. String võib valikuliselt sisaldada vorminguspetsifikaatoreid ja muutujate loendit muutujate_loendid.

Allolev programm näitab, kuidas faili kirjutada:

fputc() funktsioon:

#include <stdio.h>
int main() {
        int i;
        FILE * fptr;
        char fn[50];
        char str[] = "Guru99 Rocks\n";
        fptr = fopen("fputc_test.txt", "w"); // "w" defines "writing mode"
        for (i = 0; str[i] != '\n'; i++) {
            /* write to file using fputc() function */
            fputc(str[i], fptr);
        }
        fclose(fptr);
        return 0;
    }

Väljund:

Ülaltoodud programm kirjutab sisse ühe märgi fputc_test.txt faili, kuni see jõuab järgmise rea sümbolini “\n”, mis näitab, et lause kirjutati edukalt. Protsess seisneb massiivi iga märgi võtmises ja selle faili kirjutamises.

1. Ülaltoodud programmis oleme loonud ja avanud kirjutusrežiimis faili nimega fputc_test.txt ja deklareerinud oma stringi, mis faili kirjutatakse.
2. Kirjutame tähemärgi haaval, kasutades tsüklit for tsüklit, ja paneme iga märgi oma faili, kuni leitakse märk “\n”, seejärel suletakse fail funktsiooni fclose abil.

fputs () Funktsioon:

#include <stdio.h>
int main() {
        FILE * fp;
        fp = fopen("fputs_test.txt", "w+");
        fputs("This is Guru99 Tutorial on fputs,", fp);
        fputs("We don't need to use for loop\n", fp);
        fputs("Easier than fputc function\n", fp);
        fclose(fp);
        return (0);
    }

Väljund:

1. Ülaltoodud programmis oleme loonud ja avanud kirjutusrežiimis faili nimega fputs_test.txt.
2. Pärast seda, kui teeme kirjutustoimingu funktsiooni fputs() abil, kirjutades kolm erinevat stringid
3. Seejärel suletakse fail funktsiooni fclose abil.

fprintf()Funktsioon:

#include <stdio.h>
    int main() {
        FILE *fptr;
        fptr = fopen("fprintf_test.txt", "w"); // "w" defines "writing mode"
        /* write to file */
        fprintf(fptr, "Learning C with Guru99\n");
        fclose(fptr);
        return 0;
    }

Väljund:

1. Ülaltoodud programmis oleme loonud ja avanud kirjutusrežiimis faili nimega fprintf_test.txt.
2. Kui kirjutamisoperatsioon on tehtud funktsiooni fprintf() abil, kirjutades stringi, suletakse fail funktsiooni fclose abil.

Andmete lugemine failist

Andmete lugemiseks failist on kolm erinevat funktsiooni

• fgetc(file_pointer): Tagastab faili järgmise märgi, millele failikursor osutas. Kui faili lõpp on käes, saadetakse EOF tagasi.
• fgets(puhver, n, faili_osutaja): See loeb failist n-1 tähemärki ja salvestab stringi puhvrisse, kuhu lisatakse viimase märgina NULL-märk '\0'.
• fscanf(faili_osutaja, konversiooni_spetsifikaatorid, muutuja_aadressid): seda kasutatakse andmete sõelumiseks ja analüüsimiseks. See loeb failist tähemärke ja määrab sisendi loendile muutuvad osutid muutuja_aadressid, kasutades konversioonispetsifikaatoreid. Pidage meeles, et nagu ka scanfi puhul, lõpetab fscanf stringi lugemise tühiku või reavahetuse korral.

Järgmine programm demonstreerib lugemist failist fputs_test.txt, kasutades vastavalt funktsioone fgets(),fscanf() ja fgetc () :

#include <stdio.h>
int main() {
        FILE * file_pointer;
        char buffer[30], c;

        file_pointer = fopen("fprintf_test.txt", "r");
        printf("----read a line----\n");
        fgets(buffer, 50, file_pointer);
        printf("%s\n", buffer);

        printf("----read and parse data----\n");
        file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer
        char str1[10], str2[2], str3[20], str4[2];
        fscanf(file_pointer, "%s %s %s %s", str1, str2, str3, str4);
        printf("Read String1 |%s|\n", str1);
        printf("Read String2 |%s|\n", str2);
        printf("Read String3 |%s|\n", str3);
        printf("Read String4 |%s|\n", str4);

        printf("----read the entire file----\n");

        file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer
        while ((c = getc(file_pointer)) != EOF) printf("%c", c);

        fclose(file_pointer);
        return 0;
    }

Tulemus:

----read a line----
Learning C with Guru99

----read and parse data----
Read String1 |Learning|
Read String2 |C|
Read String3 |with|
Read String4 |Guru99|
----read the entire file----
Learning C with Guru99

1. Ülaltoodud programmis oleme avanud faili nimega "fprintf_test.txt", mis oli varem kirjutatud funktsiooniga fprintf() ja mis sisaldab stringi "Learning C with Guru99". Lugesime seda funktsiooni fgets() abil, mis loeb ridade kaupa, kus puhvri suurus peab olema piisav kogu rea käsitlemiseks.
2. Avame faili uuesti, et lähtestada kursorifail faili algusesse. Looge erinevaid stringimuutujaid, et käsitleda iga sõna eraldi. Nende sisu nägemiseks printige muutujad. Funktsiooni fscanf() kasutatakse peamiselt failist andmete eraldamiseks ja sõelumiseks.
3. Avage fail uuesti, et lähtestada kursorifail faili algusesse. Lugege andmeid ja printige need failist märgi haaval, kasutades funktsiooni getc(), kuni ilmneb EOF-lause
4. Pärast lugemistoimingu faili sooritamist erinevate variantide abil sulgesime faili uuesti funktsiooniga fclose.

Interaktiivne faili lugemine ja kirjutamine getc ja putc abil

Need on kõige lihtsamad failitoimingud. Getc tähistab get character ja putc tähendab put karakterit. Neid kahte funktsiooni kasutatakse korraga ainult ühe märgi käsitlemiseks.

Järgmine programm demonstreerib failihaldusfunktsioone "C" programmeerimisel:

#include <stdio.h>
int main() {
        FILE * fp;
        char c;
        printf("File Handling\n");
        //open a file
        fp = fopen("demo.txt", "w");
        //writing operation
        while ((c = getchar()) != EOF) {
            putc(c, fp);
        }
        //close file
        fclose(fp);
        printf("Data Entered:\n");
        //reading
        fp = fopen("demo.txt", "r");
        while ((c = getc(fp)) != EOF) {
            printf("%c", c);
        }
        fclose(fp);
        return 0;
    }

Väljund:

1. Ülaltoodud programmis oleme loonud ja avanud kirjutusrežiimis faili nimega demo.
2. Pärast kirjutamistoimingu sooritamist suletakse fail funktsiooni fclose abil.
3. Oleme taas avanud faili, mis sisaldab nüüd lugemisrežiimis andmeid. Ajatsükkel käivitatakse, kuni eof on leitud. Kui faili lõpp on leitud, operatsioon lõpetatakse ja andmed kuvatakse funktsiooni printf abil.
4. Pärast lugemistoimingu sooritamist suletakse fail uuesti funktsiooniga fclose.

kokkuvõte

• Fail on mäluruum, kuhu salvestatakse andmed.
• "C" programmeerimine pakub failiga tegelemiseks erinevaid funktsioone.
• Failidega manipuleerimise mehhanismi nimetatakse failihalduseks.
• Fail tuleb enne sellega toimingute tegemist avada.
• Faili saab avada lugemis-, kirjutamis- või lisamisrežiimis.
• Funktsioone Getc ja putc kasutatakse ühe märgi lugemiseks ja kirjutamiseks.
• Funktsioon fscanf() võimaldab failist andmeid lugeda ja sõeluda
• Saame lugeda (kasutades getc funktsioon) kogu faili silmuse abil, et katta kogu fail, kuni EOF-i avastatakse
• Funktsiooni abil saame faili kirjutada pärast selle nime loomist fprintf () ja sellel peab stringi teksti lõpus olema reavahetus.