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.

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,
- Fájl létrehozása
- Fájl megnyitása
- Fájl olvasása
- Fájlba írás
- 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.
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é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:
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.
- 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.
- 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:
- A fenti programban létrehoztunk és megnyitottunk egy fputs_test.txt nevű fájlt írási módban.
- 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
- 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:
- A fenti programban létrehoztunk és megnyitottunk egy fprintf_test.txt nevű fájlt írási módban.
- 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
- 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.
- Ú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.
- 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
- 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:
- A fenti programban létrehoztunk és megnyitottunk egy demo nevű fájlt írási módban.
- Az írási művelet végrehajtása után a fájl bezárásra kerül az fclose funkcióval.
- 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.
- Az olvasási művelet végrehajtása után a fájl ismét bezárásra kerül az fclose funkcióval.











