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 teisedki keeled, pakub ka C järgmist failihaldust funktsioonid,

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,

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 funktsiooni abil otse.

fp on fail pointer mis viitab 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.

Antud süntaksis on failinimi ja režiim määratud järgmiselt stringid seega tuleb need alati jutumärkidesse panna.

Näiteks:

#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äiteks:

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

Funktsioon fclose võtab argumendina faili kursorit. Seejärel suletakse faili kursoriga seotud fail fclose funktsiooni abil. See tagastab 0, kui sulgemine oli edukas, ja EOF (faili lõpp), kui faili sulgemisel tekkis viga.

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, file_pointer): See kirjutab file_pointer poolt viidatud faili märgi.
• fputs(str, file_pointer): See kirjutab stringi faili, millele file_pointer viitab.
• fprintf(file_pointer, str, variable_lists): See prindib stringi faili, millele file_pointer viitab. String võib valikuliselt sisaldada vormingu täpsustajaid ja muutujate loendit variable_lists.

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 faili fputc_test.txt ühe tähemärgi, kuni jõuab järgmise rea sümbolini „\n“, mis näitab, et lause kirjutati edukalt. Protsessi käigus võetakse massiivi iga tähemärk ja kirjutatakse see faili.

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 oleme funktsiooni fputs() abil kirjutanud kolm erinevat stringi
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 failist, millele failipointer osutab, järgmise märgi. Kui faili lõpp on saavutatud, saadetakse tagasi EOF.
• fgets(buffer, n, file_pointer): See loeb failist n-1 tähemärki ja salvestab stringi puhvrisse, mille viimaseks tähemärgiks on lisatud NULL-märk '\0'.
• fscanf(file_pointer, conversion_specifiers, variable_adresses): Seda kasutatakse andmete parsimiseks ja analüüsimiseks. See loeb failist märke ja määrab sisendi muutujate pointerite loendile variable_adresses, kasutades konversioonispetsifikatsioone. Pidage meeles, et nagu ka scanf 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 avasime faili nimega „fprintf_test.txt”, mis on eelnevalt kirjutatud funktsiooniga fprintf() ja see sisaldab teksti „C keele õppimine”. Guru99” string. Loeme seda funktsiooni fgets() abil, mis loeb rida-realt, kusjuures puhvri suurus peab olema piisav kogu rea käsitlemiseks.
2. Avame faili uuesti, et lähtestada pointerifail osutama faili algusesse. Loome erinevaid stringmuutujaid, et käsitleda iga sõna eraldi. Prindime muutujad välja, et näha nende sisu. Fscanf()-d kasutatakse peamiselt ...tract ja parsib andmeid failist.
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.

KKK