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

C Bestandsbeheer

Een bestand kan worden gebruikt om een grote hoeveelheid persistente gegevens op te slaan. Net als veel andere talen biedt 'C' de volgende functies voor bestandsbeheer,

Een bestand maken
Een bestand openen
Een bestand lezen
Schrijven naar een bestand
Een bestand sluiten

Hieronder volgen de belangrijkste bestandsbeheerfuncties die beschikbaar zijn in 'C',

functie doel fopen () Een bestand maken of een bestaand bestand openenfclose () Een bestand sluitenfprintf () Een gegevensblok naar een bestand schrijvenfscanf () Een blokgegevens uit een bestand lezengetc () Leest een enkel teken uit een bestandputc () Schrijft een enkel teken naar een bestandgetw () Leest een geheel getal uit een bestandputw () Een geheel getal naar een bestand schrijvenfseek () Stelt de positie van een bestandsaanwijzer in op een opgegeven locatieftell () Retourneert de huidige positie van een bestandsaanwijzerterugspoelen () Zet de bestandsaanwijzer aan het begin van een bestand

In deze tutorial leer je-

Een bestand maken
Een bestand sluiten:
Schrijven naar een bestand
fputc() Functie:
fputs () Functie:
fprintf()Functie:
Gegevens uit een bestand lezen
Interactief bestand lezen en schrijven met getc en putc

Een bestand maken

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 waar 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 een bestand al op het systeem aanwezig is, wordt het direct geopend met deze functie.

fp is een bestandsaanwijzer die naar het typebestand verwijst.

Telkens wanneer u een bestand opent of aanmaakt, moet u specificeren 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 aan te geven of u een bestand wilt openen voor een van de onderstaande doeleinden. Hieronder volgen de verschillende soorten modi in 'C'-programmering die kunnen worden gebruikt tijdens het werken met een bestand.

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

In de gegeven syntaxis worden de bestandsnaam en de modus gespecificeerd als strings, daarom moeten ze altijd tussen dubbele aanhalingstekens staan.

Voorbeeld:

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

Uitgang:

Het bestand wordt gemaakt in dezelfde map waarin u uw code hebt opgeslagen.

U kunt het pad specificeren waar u uw bestand wilt maken

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

Een bestand sluiten

Men moet altijd een bestand sluiten wanneer de bewerkingen in het bestand voorbij zijn. Het 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 de bewerking voor het sluiten van bestanden 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 bij de bestandsaanwijzer hoort, wordt dan gesloten met behulp van de fclose-functie. Het geeft 0 terug 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 met andere bestanden worden gebruikt.

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

Schrijven naar een bestand

Als u in C naar een bestand schrijft, moeten de nieuwe regeltekens '\n' expliciet worden toegevoegd.

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

fputc(char, file_pointer) :Het schrijft een teken naar het bestand waarnaar file_pointer verwijst.
fputs(str, file_pointer) :Het schrijft een string naar het bestand waarnaar file_pointer verwijst.
fprintf(file_pointer, str, variable_lists) :Het drukt een string af naar het bestand waarnaar wordt verwezen door file_pointer. De tekenreeks kan optioneel opmaakspecificaties en een lijst met variabelen variable_lists 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;
    }

Uitgang:

Het bovenstaande programma schrijft een enkel teken in de fputc_test.txt bestand totdat het het volgende regelsymbool "\n" bereikt dat aangeeft dat de zin met succes is geschreven. Het proces is om elk teken van de array te nemen en het in het bestand te schrijven.

In het bovenstaande programma hebben we een bestand met de naam fputc_test.txt in een schrijfmodus gemaakt en geopend en onze tekenreeks aangegeven die in het bestand zal worden geschreven.
We voeren een teken-voor-teken-schrijfbewerking uit met behulp van de for-lus en plaatsen elk teken in ons bestand totdat het "\n"-teken wordt aangetroffen, waarna het bestand wordt gesloten met behulp van de fclose-functie.

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

UITGANG:

In het bovenstaande programma hebben we een bestand gemaakt en geopend met de naam fputs_test.txt in een schrijfmodus.
Nadat we een schrijfbewerking hebben uitgevoerd met de functie fputs() door drie verschillende tekenreeksen te schrijven
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;
    }

UITGANG:

In het bovenstaande programma hebben we een bestand gemaakt en geopend met de naam fprintf_test.txt in een schrijfmodus.
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 voor het lezen van gegevens uit een bestand

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

Het volgende programma demonstreert het lezen van het bestand fputs_test.txt met 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

In het bovenstaande programma hebben we het bestand met de naam "fprintf_test.txt" geopend dat eerder is geschreven met de functie fprintf() en het bevat de tekenreeks "Learning C with Guru99". We lezen het met de functie fgets() die regel voor regel leest, waarbij de buffergrootte voldoende moet zijn om de hele regel te verwerken.
We heropenen het bestand om de pointerfile opnieuw in te stellen naar het begin van het bestand. Maak verschillende stringvariabelen 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 ontleden.
Open het bestand opnieuw om de pointerfile naar het begin van het bestand te laten wijzen. Lees gegevens en print ze uit het bestand teken voor teken met de functie getc() totdat de EOF-instructie wordt aangetroffen
Na het uitvoeren van een leesbewerkingsbestand met verschillende varianten, hebben we het bestand opnieuw gesloten met behulp van de fclose-functie.

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

Uitgang:

In het bovenstaande programma hebben we een bestand met de naam demo gemaakt en geopend in een schrijfmodus.
Nadat een schrijfbewerking is uitgevoerd, wordt het bestand gesloten met de functie fclose.
We hebben opnieuw een bestand geopend dat nu gegevens in leesmodus bevat. 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 de gegevens weergegeven met de functie printf.
Na het uitvoeren van een leesbewerking wordt het bestand opnieuw gesloten met behulp van de fclose-functie.

Samenvatting

Een bestand is een ruimte in een geheugen waar gegevens worden opgeslagen.
'C'-programmering biedt verschillende functies om met een bestand om te gaan.
Een mechanisme om met de bestanden te manipuleren wordt bestandsbeheer genoemd.
Een bestand moet worden geopend voordat er bewerkingen op worden uitgevoerd.
Een bestand kan worden geopend in een lees-, schrijf- of toevoegmodus.
Getc- en putc-functies worden gebruikt om een enkel teken te lezen en te schrijven.
De functie fscanf() staat toe om gegevens uit een bestand te lezen en te ontleden
We kunnen lezen (met behulp van de getc functie) een heel bestand door een lus te maken om het hele bestand te bedekken totdat de EOF wordt aangetroffen
We kunnen naar een bestand schrijven nadat de naam is aangemaakt, met behulp van de functie fprintf() en het moet het teken van de nieuwe regel hebben aan het einde van de tekenreekstekst.

Opslagklassen in C:auto, extern, statisch, registerklasse in C Functies in C-programmering met voorbeelden:recursief en inline

C Taal