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

⚡ Okos összefoglaló

A C nyelvű fájlkezelés az állandó adatokat a lemezen tárolja az stdio könyvtáron keresztül, amely az fopen paranccsal nyit meg egy fájlt, az fputc, fputs vagy fprintf paranccsal ír, az fgetc, fgets vagy fscanf paranccsal olvas, és az fclose paranccsal zárja be.

  • 📁 Fájl módok: Az fopen függvénynek átadott mód karakterlánc — r, w, a, r+, w+ vagy a+ — dönti el, hogy egy fájlt olvas, felülír vagy hozzáfűz.
  • ✍️ Adatok írása: Az fputc egy karaktert, az fputs egy karakterláncot, az fprintf pedig formázott szöveget ír a fájlmutatóba.
  • ???? Adatok olvasása: Az fgetc beolvas egy karaktert, az fgets beolvas egy sort egy pufferbe, az fscanf pedig formázott tokeneket elemez a fájlból.
  • 🔒 Fájlok bezárása: Az fclose kiüríti a pufferelt adatokat és felszabadítja a fájlt, siker esetén 0-t, hiba esetén pedig EOF-ot ad vissza.
  • 🔁 Interaktív I/O: A getc és a putc egyszerre csak egy karaktert kezel, a bemenetet egyből egy fájlba mozgatja, majd onnan ki.
  • 🤖 AI segítség: A GitHub Copilot és a mesterséges intelligencia asszisztensei az fopen, fprintf és fgets rutinokat állítják össze, és jelzik a hiányzó NULL ellenőrzéseket vagy a lezáratlan fájlokat.

C Fájlok I/O

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ést biztosítja: funkciók,

  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éltudat
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 létezik a rendszeren, akkor az közvetlenül megnyitható ezzel a függvénnyel.

Az fp egy fájl mutató ami 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 Fájl megnyitása hozzáfűző módban. Ha egy fájl hozzáfűző 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

A megadott szintaxisban a fájlnév és a mód a következőképpen van megadva: húrok ezért mindig idézőjelek közé kell tenni őket.

Például:

#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.

Fájl létrehozása C programkimenetben

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

Hozz létre egy fájlt megadott elérési úttal C-ben

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éldául:

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

Az fclose függvény argumentumként egy fájlmutatót fogad el. A fájlmutatóhoz társított fájlt ezután az fclose függvény segítségével zárja be. 0-t ad vissza, ha a bezárás sikeres volt, és EOF-et (fájl vége), ha hiba történt a fájl bezárása közben.

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(char, file_pointer): 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(file_pointer, str, variable_lists): Kinyomtat egy karakterláncot a file_pointer által mutatott fájlhoz. A karakterlánc opcionálisan tartalmazhat formátumleírókat és a variable_lists változók listáját.

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:

fputc() függvény kimenete C-ben

A fenti program egyetlen karaktert ír az fputc_test.txt fájlba, amíg el nem éri a következő sor szimbólumát, a „\n”-t, amely azt jelzi, hogy a mondat sikeresen megírásra került. A folyamat abból áll, hogy a tömb minden egyes karakterét beírja a fájlba.

C nyelven írt fputc_test.txt fájl tartalma

  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:

fputs() függvény kimenete C-ben

fputs_test.txt fájl tartalma C-ben

  1. A fenti programban létrehoztunk és megnyitottunk egy fputs_test.txt nevű fájlt írási módban.
  2. Miután az fputs() függvénnyel írási műveletet végeztünk három különböző karakterlánc írásával
  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:

fprintf() függvény kimenete C-ben

fprintf_test.txt fájl tartalma C-ben

  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(file_pointer): Visszaadja a fájlból a mutató által jelzett következő karaktert. Amikor a fájl végére ér, az EOF visszaküldésre kerül.
  • fgets(buffer, n, file_pointer): n-1 karaktert olvas be a fájlból, és egy pufferben tárolja a karakterláncot, amelyhez utolsó karakterként a '\0' NULL karaktert fűzi hozzá.
  • fscanf(file_pointer, conversion_specifiers, variable_adresses): Adatok elemzésére és elemzésére szolgál. Karakterek beolvasása a fájlból, és a bemenetet egy változó_címek listához rendeli konverziós specifikátorok használatával. Ne feledd, hogy a scanf-hez hasonlóan az fscanf is leállítja a karakterláncok olvasását, ha szóköz vagy sortörés található.

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

Adatok olvasása egy fájlból C kimenetben

  1. A fenti programban megnyitottuk az „fprintf_test.txt” nevű fájlt, amelyet korábban az fprintf() függvénnyel írtunk, és amely a „C nyelv tanulása” részt tartalmazza. Guru99”-os karakterlánc. Az fgets() függvénnyel olvassuk be, amely soronként olvassa be a szöveget, ahol a puffer méretének elegendőnek kell lennie a teljes sor kezeléséhez.
  2. Újra megnyitjuk a fájlt, hogy a mutatófájlt visszaállítsuk a fájl elejére. Hozzunk létre különböző karakterlánc-változókat az egyes szavak külön kezeléséhez. Nyomtassuk ki a változókat a tartalmuk megtekintéséhez. Az fscanf() függvényt főként a következőkre használjuk:tract és elemzi az adatokat 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:

Interaktív fájlolvasás és -írás C kimenetben

getc és putc fájlok kezelése C-ben

  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.

GYIK

A szöveges mód a sortörés karaktereket az operációs rendszernek megfelelően alakítja át, míg a bináris mód, amelyet az „rb” vagy „wb” paranccsal nyitnak meg, pontosan úgy írja ki a bájtokat, ahogyan azok vannak. A bináris módot képek, hanganyagok vagy bármilyen olyan adat esetén használja, ahol a pontos bájtelrendezést meg kell őrizni.

Az fopen függvény NULL értéket ad vissza, ha egy fájl nem nyitható meg, például hiányzó fájl, megtagadt hozzáférés vagy megtelt lemez esetén. Olvasás vagy írás előtt mindig tesztelje a visszaadott mutatót NULL értékkel szemben, különben a program érvénytelen mutatót használ, és általában összeomlik.

A „w” írási mód csonkol egy meglévő fájlt, törli annak tartalmát az írás előtt, és akkor hozza létre a fájlt, amikor az hiányzik. Az „a” hozzáfűzési mód megőrzi a meglévő adatokat, és a végére új tartalmat ad hozzá, így semmi, ami már tárolva van, nem vész el.

Az fseek függvény a fájlmutatót a SEEK_SET, SEEK_CUR vagy SEEK_END paramétertől mért bájt eltolással egyenértékűre mozgatja. Az ftell függvény visszaadja a mutató aktuális bájtpozícióját, a rewind függvény pedig visszaküldi azt a fájl elejére. Együttesen véletlenszerű hozzáférést biztosítanak a szekvenciális olvasás helyett.

fgets beolvas egy egész sort, majd megállping új sor karakternél vagy n-1 karakter után, így tiszteletben tartja a puffer méretét. Az fscanf formázott, szóközzel elválasztott tokeneket olvas, és képes túlcsordulni egy rövid tömböt. Teljes sorok biztonságos olvasásához az fgets a jobb választás.

Az EOF egy konstans, általában -1, amely a fájl végét jelzi. Az olyan olvasási függvények, mint a getc, fgetc és fscanf, EOF-et adnak vissza, ha már nincs több adat, ezért a ciklusok az olvasás leállításához összehasonlítják az eredményüket az EOF-fel.

Igen. Egy mesterséges intelligencia által támogatott kódolási asszisztens képes fopen, fprintf és fgets rutinokat generálni egy egyszerű nyelvi promptból, elmagyarázni az egyes fájlmódokat, és hibákat, például hiányzó NULL ellenőrzést vagy lezáratlan fájlokat észlelni. Mindig fordítsd le és teszteld a mesterséges intelligencia által javasolt kódot, mielőtt megbízol benne.

GitHub másodpilóta C fájlkezelő kódot ír, amely egy rövid megjegyzésből vagy függvénynévből teljes fopen, fputs és fscanf blokkokat javasol. Gyakran hozzáadja a megfelelő fclose hívást és egy hibaellenőrzést, bár továbbra is érdemes áttekinteni a generált logikát.

Foglald össze ezt a bejegyzést a következőképpen: