C Fájlok I/O: Fájl létrehozása, megnyitása, olvasása, írása és bezárása

C Fájlkezelés

Egy fájl nagy mennyiségű állandó adat tárolására használható. Sok más nyelvhez hasonlóan a „C” a következő fájlkezelési funkciókat kínálja,

1. Fájl létrehozása
2. Fájl megnyitása
3. Fájl olvasása
4. Fájlba írás
5. Fájl bezárása

Az alábbiakban felsoroljuk a „C” nyelven elérhető legfontosabb fájlkezelő funkciókat

funkció	cél
fopen()	Fájl létrehozása vagy meglévő fájl megnyitása
fclose ()	Fájl bezárása
fprintf()	Adatblokk írása fájlba
fscanf ()	Blokkadatok olvasása fájlból
getc ()	Egyetlen karaktert olvas be egy fájlból
putc ()	Egyetlen karaktert ír egy fájlba
getw ()	Egész számot olvas be egy fájlból
putw ()	Egész szám írása fájlba
fseek ()	Beállítja a fájlmutató pozícióját egy megadott helyre
ftell ()	Egy fájlmutató aktuális pozícióját adja vissza
visszatekerés ()	A fájl mutatóját a fájl elejére állítja

Fájl létrehozása

Amikor egy fájllal szeretne dolgozni, az első lépés egy fájl létrehozása. A fájl nem más, mint hely a memóriában, ahol az adatok tárolódnak.

Fájl létrehozásához egy „C” programban a következő szintaxist kell használni:

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

A fenti szintaxis szerint a fájl egy adatstruktúra, amely a szabványos könyvtárban van definiálva.

Az fopen egy szabványos funkció, amely egy fájl megnyitására szolgál.

• Ha a fájl nem található a rendszeren, akkor létrejön, majd megnyitja.
• Ha egy fájl már jelen van a rendszerben, akkor közvetlenül ezzel nyitható meg funkció.

Az fp egy fájlmutató, amely a típusfájlra mutat.

Amikor megnyit vagy létrehoz egy fájlt, meg kell adnia, hogy mit fog tenni a fájllal. A 'C' programozású fájl létrehozható vagy megnyitható olvasási/írási célokra. Egy mód annak meghatározására szolgál, hogy meg kíván-e nyitni egy fájlt az alábbiakban megadott célok valamelyikére. Az alábbiakban bemutatjuk a 'C' programozás különféle módozatait, amelyek egy fájllal való munka közben használhatók.

Fájl mód	Leírás
r	Nyisson meg egy fájlt olvasásra. Ha egy fájl olvasási módban van, akkor a rendszer nem törli az adatokat, ha egy fájl már jelen van a rendszerben.
w	Nyisson meg egy fájlt íráshoz. Ha egy fájl írási módban van, akkor új fájl jön létre, ha a fájl egyáltalán nem létezik. Ha egy fájl már jelen van a rendszeren, akkor a fájlban lévő összes adat csonkolásra kerül, és megnyílik írás céljából.
a	Nyisson meg egy fájlt hozzáfűzés mód. Ha egy fájl hozzáfűzés módban van, akkor a fájl megnyílik. A fájl tartalma nem változik.
r+	az elejétől kezdve nyitva áll az olvasásra és az írásra
w+	megnyílik olvasásra és írásra, fájl felülírására
a+	olvasásra és írásra nyitva, fájlhoz fűzve

Az adott szintaxisban a fájlnév és a mód karakterláncként van megadva, ezért ezeket mindig idézőjelbe kell tenni.

Példa:

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

output:

A fájl ugyanabban a mappában jön létre, ahová a kódot mentette.

Megadhatja az elérési utat, ahol létre szeretné hozni a fájlt

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

Hogyan zárjunk be egy fájlt

Mindig be kell zárni egy fájlt, amikor a fájlon végzett műveletek véget értek. Ez azt jelenti, hogy a fájl tartalma és hivatkozásai megszűntek. Ez megakadályozza a fájl véletlen sérülését.

A „C” az fclose funkciót biztosítja a fájlbezárási művelet végrehajtásához. Az fclose szintaxisa a következő:

fclose (file_pointer);

Példa:

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

Az fclose függvény egy fájlmutatót vesz argumentumként. A fájlmutatóhoz társított fájl ezután bezárásra kerül az fclose függvény segítségével. 0-t ad vissza, ha a bezárás sikeres volt, és EOF-t (fájl vége), ha hiba történt a fájl bezárásakor.

A fájl bezárása után ugyanaz a fájlmutató más fájlokkal is használható.

A „C” programozás során a fájlok automatikusan bezáródnak, amikor a program leáll. A fájl manuális bezárása fclose függvény beírásával jó programozási gyakorlat.

Írás fájlba

C nyelven, amikor egy fájlba ír, a '\n' újsor karaktereket kifejezetten hozzá kell adni.

Az stdio könyvtár a fájlba íráshoz szükséges funkciókat kínálja:

• fputc(karakter, fájl_mutató): Egy karaktert ír a file_pointer által mutatott fájlba.
• fputs(str, file_pointer): Egy karakterláncot ír a file_pointer által mutatott fájlba.
• fprintf(fájl_mutató, str, változó_listák): Egy karakterláncot nyomtat a file_pointer által mutatott fájlhoz. A karakterlánc opcionálisan tartalmazhat formátumspecifikációkat és változók listáját változó_listák.

Az alábbi program bemutatja, hogyan kell fájlba írni:

fputc() függvény:

#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;
    }

output:

A fenti program egyetlen karaktert ír a fputc_test.txt fájlt, amíg el nem éri a következő „\n” sorszimbólumot, amely azt jelzi, hogy a mondat sikeresen meg lett írva. A folyamat abból áll, hogy a tömb minden egyes karakterét be kell írni a fájlba.

1. A fenti programban létrehoztunk és megnyitottunk egy fputc_test.txt nevű fájlt írási módban, és deklaráltuk a karakterláncunkat, amely be lesz írva a fájlba.
2. Karakterenként írási műveletet végzünk a for ciklus használatával, és minden karaktert a fájlunkba helyezünk, amíg a „\n” karaktert nem találjuk, majd a fájlt az fclose funkcióval bezárjuk.

fputs () Funkció:

#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);
    }

output:

1. A fenti programban létrehoztunk és megnyitottunk egy fputs_test.txt nevű fájlt írási módban.
2. Miután írási műveletet végzünk az fputs() függvény használatával, három különböző írással húrok
3. Ezután a fájl bezárásra kerül az fclose funkcióval.

fprintf()függvény:

#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;
    }

output:

1. A fenti programban létrehoztunk és megnyitottunk egy fprintf_test.txt nevű fájlt írási módban.
2. Miután egy írási műveletet végrehajtottunk az fprintf() függvény használatával egy karakterlánc beírásával, a fájl bezárásra kerül az fclose függvény segítségével.

Adatok olvasása fájlból

Három különböző funkció szolgál az adatok fájlból történő olvasására

• fgetc(fájl_mutató): Visszaadja a következő karaktert a fájlból, amelyre a fájlmutató mutatott. Amikor elérte a fájl végét, az EOF visszaküldésre kerül.
• fgets(puffer, n, fájl_mutató): n-1 karaktert beolvas a fájlból, és a karakterláncot egy pufferben tárolja, amelyben a NULL karakter „\0” van hozzáfűzve utolsó karakterként.
• fscanf(file_pointer, conversion_specifiers, variable_adresses): Adatok elemzésére és elemzésére szolgál. Beolvassa a karaktereket a fájlból, és hozzárendeli a bemenetet egy listához változó mutatók változó_címek konverziós specifikátorok használatával. Ne feledje, hogy a scanf-hez hasonlóan az fscanf is leállítja a karakterlánc olvasását, ha szóközt vagy újsort talál.

A következő program bemutatja az fputs_test.txt fájl olvasását az fgets(),fscanf() és fgetc () függvényekkel:

#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;
    }

Eredmény:

----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. A fenti programban megnyitottuk az „fprintf_test.txt” nevű fájlt, amelyet korábban fprintf() függvénnyel írtunk, és a „C Learning C with Guru99” karakterláncot tartalmazza. Az fgets() függvény segítségével olvassuk ki, amely soronként olvassa be, ahol a puffer méretének elegendőnek kell lennie a teljes sor kezelésére.
2. Újra megnyitjuk a fájlt, hogy visszaállítsuk a mutatófájlt a fájl elejére. Hozzon létre különböző karakterlánc-változókat, hogy minden szót külön kezeljen. Nyomtassa ki a változókat a tartalmuk megtekintéséhez. Az fscanf() főként adatok kinyerésére és elemzésére szolgál egy fájlból.
3. Nyissa meg újra a fájlt, hogy visszaállítsa a mutatófájlt a fájl elejére. Olvassa el az adatokat, és a getc() függvény segítségével karakterenként nyomtatja ki, amíg az EOF utasítás meg nem találja
4. Miután végrehajtottunk egy olvasási műveletfájlt különböző változatokkal, ismét bezártuk a fájlt az fclose funkcióval.

Interaktív fájl olvasása és írása a getc és putc segítségével

Ezek a legegyszerűbb fájlműveletek. A Getc a get karaktert, a putc pedig a put karaktert jelenti. Ez a két függvény egyszerre csak egy karakter kezelésére szolgál.

A következő program bemutatja a fájlkezelési funkciókat a 'C' programozásban:

#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;
    }

output:

1. A fenti programban létrehoztunk és megnyitottunk egy demo nevű fájlt írási módban.
2. Az írási művelet végrehajtása után a fájl bezárásra kerül az fclose funkcióval.
3. Ismét megnyitottunk egy fájlt, amely immár olvasási módban tartalmaz adatokat. A while ciklus addig fut, amíg meg nem találja az eof-t. Miután megtalálta a fájl végét, a művelet leáll, és az adatok megjelennek a printf funkcióval.
4. Az olvasási művelet végrehajtása után a fájl ismét bezárásra kerül az fclose funkcióval.

Összegzésként

• A fájl egy memóriaterület, ahol adatok tárolódnak.
• A „C” programozás különféle funkciókat biztosít a fájl kezeléséhez.
• A fájlokkal való manipuláció mechanizmusát fájlkezelésnek nevezik.
• A műveletek végrehajtása előtt meg kell nyitni egy fájlt.
• A fájl megnyitható olvasási, írási vagy hozzáfűzési módban.
• A Getc és putc függvények egyetlen karakter olvasására és írására szolgálnak.
• Az fscanf() függvény lehetővé teszi adatok olvasását és elemzését egy fájlból
• Tudunk olvasni (használva a getc függvény) egy teljes fájlt hurkolással, hogy lefedje az összes fájlt, amíg az EOF nem találkozik
• Egy fájlba a nevének létrehozása után írhatunk, a függvény segítségével fprintf () és a karakterlánc végén kell lennie az újsor karakternek.