C Bestanden I/O: een bestand maken, openen, lezen, schrijven en sluiten

C Bestandsbeheer

Een bestand kan worden gebruikt om een ​​groot volume aan persistente gegevens op te slaan. Zoals veel andere talen biedt 'C' de volgende bestandsbeheerfuncties,

1. Aanmaak van een bestand
2. Een bestand openen
3. Een bestand lezen
4. Schrijven naar een bestand
5. Een bestand sluiten

Hieronder staan ​​de belangrijkste bestandsbeheerfuncties die beschikbaar zijn in 'C':

functie	doel
foppen ()	Een bestand maken of een bestaand bestand openen
fsluiten ()	Een bestand sluiten
fprintf()	Een gegevensblok naar een bestand schrijven
fscanf ()	Blokgegevens uit een bestand lezen
haal ()	Leest een enkel teken uit een bestand
putc ()	Schrijft één teken naar een bestand
krijg ()	Leest een geheel getal uit een bestand
zet ()	Een geheel getal naar een bestand schrijven
fzoek ()	Stelt de positie in van een bestandsaanwijzer naar een opgegeven locatie
vertel ()	Geeft de huidige positie van een bestandsaanwijzer terug
terugspoelen ()	Stelt de bestandsaanwijzer in aan het begin van een bestand

Hoe u een bestand maakt

Wanneer u met een bestand wilt werken, is de eerste stap het maken van een bestand. Een bestand is niets anders dan ruimte in een geheugen waarin gegevens worden opgeslagen.

Om een ​​bestand in een 'C'-programma te maken, wordt de volgende syntaxis gebruikt:

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

In de bovenstaande syntaxis is het bestand een gegevensstructuur die is gedefinieerd in de standaardbibliotheek.

fopen is een standaardfunctie die wordt gebruikt om een ​​bestand te openen.

• Als het bestand niet op het systeem aanwezig is, wordt het gemaakt en vervolgens geopend.
• Als er al een bestand op het systeem aanwezig is, wordt het hiermee direct geopend functie.

fp is een bestandsaanwijzer die naar het typebestand verwijst.

Wanneer u een bestand opent of maakt, moet u opgeven wat u met het bestand gaat doen. Een bestand in 'C'-programmering kan worden gemaakt of geopend voor lees-/schrijfdoeleinden. Een modus wordt gebruikt om op te geven of u een bestand wilt openen voor een van de hieronder gegeven doeleinden. Hieronder staan ​​de verschillende typen modi in 'C'-programmering die kunnen worden gebruikt tijdens het werken met een bestand.

Bestandsmodus	Beschrijving
r	Open een bestand om te lezen. Als een bestand zich in de leesmodus bevindt, worden er geen gegevens verwijderd als er al een bestand op een systeem aanwezig is.
w	Open een bestand om te schrijven. Als een bestand zich in de schrijfmodus bevindt, wordt er een nieuw bestand gemaakt als het bestand helemaal niet bestaat. Als een bestand al op een systeem aanwezig is, worden alle gegevens in het bestand afgekapt en geopend voor schrijfdoeleinden.
a	Open een bestand in modus toevoegen. Als een bestand zich in de toevoegmodus bevindt, wordt het bestand geopend. De inhoud in het bestand verandert niet.
r+	vanaf het begin open voor lezen en schrijven
w+	open voor lezen en schrijven, een bestand overschrijven
a+	open voor lezen en schrijven, toevoegen aan bestand

In de gegeven syntaxis worden de bestandsnaam en de modus opgegeven als tekenreeksen. Deze moeten daarom altijd tussen dubbele aanhalingstekens worden geplaatst.

Voorbeeld:

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

Output:

Het bestand wordt aangemaakt in dezelfde map waarin u uw code heeft opgeslagen.

U kunt het pad opgeven waar u uw bestand wilt maken

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

Hoe een bestand te sluiten

Je moet een bestand altijd sluiten wanneer de bewerkingen op het bestand zijn voltooid. Dit betekent dat de inhoud en links naar het bestand worden beëindigd. Dit voorkomt onbedoelde schade aan het bestand.

'C' biedt de fclose-functie om een ​​bestandssluitbewerking uit te voeren. De syntaxis van fclose is als volgt:

fclose (file_pointer);

Voorbeeld:

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

De functie fclose neemt een bestandsaanwijzer als argument. Het bestand dat aan de bestandsaanwijzer is gekoppeld, wordt vervolgens gesloten met behulp van de fclose-functie. Het retourneert 0 als het sluiten succesvol was en EOF (einde van het bestand) als er een fout is opgetreden tijdens het sluiten van het bestand.

Na het sluiten van het bestand kan dezelfde bestandsaanwijzer ook bij andere bestanden worden gebruikt.

Bij 'C'-programmering worden bestanden automatisch gesloten wanneer het programma wordt beëindigd. Het handmatig sluiten van een bestand door de fclose-functie te schrijven is een goede programmeerpraktijk.

Schrijven naar een bestand

Wanneer u in C naar een bestand schrijft, moeten de nieuweregeltekens '\n' expliciet worden toegevoegd.

De stdio-bibliotheek biedt de nodige functies om naar een bestand te schrijven:

• fputc(char, bestandswijzer): Het schrijft een teken naar het bestand waarnaar wordt verwezen door file_pointer.
• fputs(str, file_pointer): Het schrijft een string naar het bestand waarnaar file_pointer verwijst.
• fprintf(bestandsaanwijzer, str, variabele_lijsten): Het drukt een string af naar het bestand waarnaar file_pointer verwijst. De tekenreeks kan optioneel formaatspecificaties en een lijst met variabelen variabele_lijsten bevatten.

Het onderstaande programma laat zien hoe u naar een bestand schrijft:

fputc() Functie:

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

Het bovenstaande programma schrijft een enkel teken in het fputc_test.txt bestand totdat het het volgende regelsymbool “\n” bereikt, wat aangeeft dat de zin met succes is geschreven. Het proces bestaat uit het nemen van elk teken van de array en het in het bestand schrijven.

1. In het bovenstaande programma hebben we een bestand met de naam fputc_test.txt gemaakt en geopend in een schrijfmodus en declareren we onze string die in het bestand zal worden geschreven.
2. We voeren een schrijfbewerking teken voor teken uit met behulp van een for-lus en plaatsen elk teken in ons bestand totdat het teken “\n” wordt aangetroffen. Vervolgens wordt het bestand gesloten met behulp van de functie fclose.

fputs () Functie:

#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. In het bovenstaande programma hebben we een bestand met de naam fputs_test.txt gemaakt en geopend in een schrijfmodus.
2. Nadat we een schrijfbewerking hebben uitgevoerd met behulp van de fputs()-functie door drie verschillende strings
3. Vervolgens wordt het bestand gesloten met de functie fclose.

fprintf()Functie:

#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. In het bovenstaande programma hebben we een bestand met de naam fprintf_test.txt gemaakt en geopend in een schrijfmodus.
2. Nadat een schrijfbewerking is uitgevoerd met de functie fprintf() door een tekenreeks te schrijven, wordt het bestand gesloten met de functie fclose.

Gegevens uit een bestand lezen

Er zijn drie verschillende functies gewijd aan het lezen van gegevens uit een bestand

• fgetc(bestandsaanwijzer): Het retourneert het volgende teken uit het bestand waarnaar door de bestandsaanwijzer wordt verwezen. Wanneer het einde van het bestand is bereikt, wordt de EOF teruggestuurd.
• fgets(buffer, n, bestandspointer): Er worden n-1 tekens uit het bestand gelezen en de tekenreeks wordt in een buffer opgeslagen, waarbij het NULL-teken '\0' als laatste teken wordt toegevoegd.
• fscanf(bestandsaanwijzer, conversiespecificaties, variabele_adressen): Het wordt gebruikt om gegevens te parseren en analyseren. Het leest tekens uit het bestand en wijst de invoer toe aan een lijst met variabele wijzers variabele_adressen met behulp van conversiespecificaties. Houd er rekening mee dat fscanf, net als bij scanf, stopt met het lezen van een tekenreeks wanneer er een spatie of nieuwe regel wordt aangetroffen.

Het volgende programma demonstreert het lezen van een fputs_test.txt-bestand met behulp van respectievelijk de functies fgets(), fscanf() en 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;
    }

Resultaat:

----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. In het bovenstaande programma hebben we het bestand "fprintf_test.txt" geopend, dat eerder is geschreven met de fprintf()-functie, en het bevat de string "Learning C with Guru99". We lezen het met de fgets()-functie die regel voor regel leest, waarbij de buffergrootte groot genoeg moet zijn om de hele regel te verwerken.
2. We openen het bestand opnieuw om de pointerfile opnieuw in te stellen zodat deze naar het begin van het bestand wijst. Maak verschillende tekenreeksvariabelen om elk woord afzonderlijk te verwerken. Druk de variabelen af ​​om hun inhoud te zien. De fscanf() wordt voornamelijk gebruikt om gegevens uit een bestand te extraheren en te parseren.
3. Open het bestand opnieuw om de pointerfile opnieuw in te stellen zodat deze naar het begin van het bestand wijst. Lees de gegevens en druk deze teken voor teken af ​​vanuit het bestand met de functie getc() totdat de EOF-instructie wordt aangetroffen
4. Nadat we een leesbewerking van het bestand hadden uitgevoerd met behulp van verschillende varianten, sloten we het bestand opnieuw met behulp van de functie fclose.

Interactief bestand lezen en schrijven met getc en putc

Dit zijn de eenvoudigste bestandsbewerkingen. Getc staat voor get character, en putc staat voor put character. Deze twee functies worden gebruikt om slechts één teken tegelijk te verwerken.

Het volgende programma demonstreert de bestandsverwerkingsfuncties in 'C'-programmering:

#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. In het bovenstaande programma hebben we een bestand met de naam demo in schrijfmodus gemaakt en geopend.
2. Nadat een schrijfbewerking is uitgevoerd, wordt het bestand gesloten met de functie fclose.
3. We hebben opnieuw een bestand geopend dat nu gegevens bevat in een leesmodus. Een while-lus wordt uitgevoerd totdat de eof is gevonden. Zodra het einde van het bestand is gevonden, wordt de bewerking beëindigd en worden gegevens weergegeven met behulp van de printf-functie.
4. Nadat een leesbewerking is uitgevoerd, wordt het bestand opnieuw gesloten met behulp van de functie fclose.

Samenvatting

• Een bestand is een ruimte in een geheugen waar gegevens worden opgeslagen.
• 'C'-programmeren biedt verschillende functies om met een bestand om te gaan.
• Een mechanisme voor het manipuleren van de bestanden wordt bestandsbeheer genoemd.
• Voordat u bewerkingen kunt uitvoeren, moet u een bestand openen.
• Een bestand kan worden geopend in lees-, schrijf- of toevoegmodus.
• Getc- en putc-functies worden gebruikt om één teken te lezen en te schrijven.
• De functie fscanf() maakt het mogelijk om gegevens uit een bestand te lezen en te parseren
• We kunnen lezen (met de getc functie) een heel bestand door een lus te maken om het hele bestand te bestrijken totdat de EOF wordt aangetroffen
• We kunnen naar een bestand schrijven nadat de naam ervan is gemaakt, met behulp van de functie fprintf() en het moet het nieuweregelteken aan het einde van de tekenreekstekst hebben.