C Filer I/O: Opprett, åpne, les, skriv og lukk en fil

C Filbehandling

En fil kan brukes til å lagre store mengder permanente data. Som mange andre språk tilbyr «C» følgende filhåndtering funksjoner,

1. Oppretting av en fil
2. Åpne en fil
3. Leser en fil
4. Skriver til en fil
5. Lukke en fil

Følgende er de viktigste filbehandlingsfunksjonene som er tilgjengelige i 'C,'

Hvordan lage en fil

Når du vil jobbe med en fil, er det første trinnet å lage en fil. En fil er ikke annet enn plass i et minne hvor data lagres.

For å lage en fil i et 'C'-program brukes følgende syntaks,

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

I syntaksen ovenfor er filen en datastruktur som er definert i standardbiblioteket.

fopen er en standardfunksjon som brukes til å åpne en fil.

• Hvis filen ikke finnes på systemet, blir den opprettet og deretter åpnet.
• Hvis en fil allerede finnes på systemet, åpnes den direkte ved hjelp av denne funksjonen.

fp er en fil pekeren som peker til typefilen.

Hver gang du åpner eller oppretter en fil, må du spesifisere hva du skal gjøre med filen. En fil i 'C'-programmering kan opprettes eller åpnes for lese-/skriveformål. En modus brukes til å spesifisere om du vil åpne en fil for noen av de nedenfor angitte formålene. Følgende er de forskjellige typene moduser i 'C'-programmering som kan brukes mens du arbeider med en fil.

I den gitte syntaksen er filnavnet og modusen spesifisert som strenger derfor må de alltid omsluttes av doble anførselstegn.

For eksempel:

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

Utgang:

Filen opprettes i samme mappe der du har lagret koden.

Du kan spesifisere banen der du vil opprette filen

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

Hvordan lukke en fil

Man bør alltid lukke en fil når operasjonene på filen er over. Det betyr at innholdet og lenkene til filen er avsluttet. Dette forhindrer utilsiktet skade på filen.

'C' gir fclose-funksjonen for å utføre fillukking. Syntaksen til fclose er som følger,

fclose (file_pointer);

For eksempel:

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

FCLOSE-funksjonen tar en filpeker som et argument. Filen som er tilknyttet filpekeren lukkes deretter ved hjelp av FCLOSE-funksjonen. Den returnerer 0 hvis lukkingen var vellykket og EOF (slutt på fil) hvis det har oppstått en feil under fillukkingen.

Etter å ha lukket filen, kan den samme filpekeren også brukes med andre filer.

I 'C'-programmering lukkes filene automatisk når programmet avsluttes. Å lukke en fil manuelt ved å skrive fclose-funksjonen er en god programmeringspraksis.

Skrive til en fil

I C, når du skriver til en fil, må nylinjetegn '\n' eksplisitt legges til.

Stdio-biblioteket tilbyr de nødvendige funksjonene for å skrive til en fil:

• fputc(char, file_pointer): Den skriver et tegn til filen som file_pointer peker til.
• fputs(str, file_pointer): Den skriver en streng til filen som file_pointer peker til.
• fprintf(file_pointer, str, variable_lists): Den skriver ut en streng til filen som file_pointer peker til. Strengen kan eventuelt inneholde formatspesifikasjoner og en liste over variabler variable_lists.

Programmet nedenfor viser hvordan du skriver til en fil:

fputc() funksjon:

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

Utgang:

Programmet ovenfor skriver ett enkelt tegn inn i fputc_test.txt-filen til det når neste linjesymbol «\n», som indikerer at setningen ble skrevet. Prosessen er å ta hvert tegn i tabellen og skrive det inn i filen.

1. I programmet ovenfor har vi opprettet og åpnet en fil kalt fputc_test.txt i en skrivemodus og erklærer vår streng som vil bli skrevet inn i filen.
2. Vi utfører en tegn-for-tegn-skriveoperasjon med for loop og legger hvert tegn i filen vår til "\n"-tegnet blir påtruffet, deretter lukkes filen ved å bruke fclose-funksjonen.

fputs () Funksjon:

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

Utgang:

1. I programmet ovenfor har vi laget og åpnet en fil kalt fputs_test.txt i skrivemodus.
2. Etter at vi har utført en skriveoperasjon med fputs()-funksjonen ved å skrive tre forskjellige strenger
3. Deretter lukkes filen ved å bruke fclose-funksjonen.

fprintf() Funksjon:

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

Utgang:

1. I programmet ovenfor har vi laget og åpnet en fil kalt fprintf_test.txt i skrivemodus.
2. Etter at en skriveoperasjon er utført ved å bruke fprintf()-funksjonen ved å skrive en streng, lukkes filen ved å bruke fclose-funksjonen.

Lese data fra en fil

Det er tre forskjellige funksjoner dedikert til å lese data fra en fil

• fgetc(file_pointer): Returnerer det neste tegnet fra filen som pekeren peker til. Når slutten av filen er nådd, sendes EOF tilbake.
• fgets(buffer, n, file_pointer): Den leser n-1 tegn fra filen og lagrer strengen i en buffer der NULL-tegnet '\0' er lagt til som siste tegn.
• fscanf(file_pointer, conversion_specifiers, variable_adresses): Den brukes til å analysere data. Den leser tegn fra filen og tilordner input til en liste med variable pekere variable_adresses ved hjelp av konverteringsspesifikatorer. Husk at som med scanf, stopper fscanf å lese en streng når det oppstår mellomrom eller linjeskift.

Følgende program demonstrerer lesing fra filen fputs_test.txt ved å bruke henholdsvis fgets(),fscanf() og fgetc() funksjoner:

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

Resultat:

----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. I programmet ovenfor har vi åpnet filen kalt «fprintf_test.txt», som tidligere ble skrevet med fprintf()-funksjonen, og den inneholder «Lære C med Guru99” streng. Vi leser den ved hjelp av fgets()-funksjonen som leser linje for linje, der bufferstørrelsen må være nok til å håndtere hele linjen.
2. Vi åpner filen på nytt for å tilbakestille pekerfilen slik at den peker i begynnelsen av filen. Opprett forskjellige strengvariabler for å håndtere hvert ord separat. Skriv ut variablene for å se innholdet. fscanf() brukes hovedsakelig til å f.eks.tract og analysere data fra en fil.
3. Åpne filen på nytt for å tilbakestille pekerfilen til å peke på begynnelsen av filen. Les data og skriv det ut fra filen tegn for tegn ved å bruke getc()-funksjonen til EOF-setningen påtreffes
4. Etter å ha utført en leseoperasjonsfil med forskjellige varianter, lukket vi igjen filen ved å bruke fclose-funksjonen.

Interaktiv fil les og skriv med getc og putc

Dette er de enkleste filoperasjonene. Getc står for get character, og putc står for put character. Disse to funksjonene brukes til å håndtere kun ett enkelt tegn om gangen.

Følgende program demonstrerer filhåndteringsfunksjonene i '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;
    }

Utgang:

1. I programmet ovenfor har vi laget og åpnet en fil kalt demo i skrivemodus.
2. Etter at en skriveoperasjon er utført, lukkes filen ved å bruke fclose-funksjonen.
3. Vi har igjen åpnet en fil som nå inneholder data i lesemodus. En while-løkke vil kjøres til eof er funnet. Når slutten av filen er funnet, vil operasjonen bli avsluttet og data vil vises ved hjelp av printf-funksjonen.
4. Etter å ha utført en leseoperasjon lukkes filen igjen med fclose-funksjonen.

Spørsmål og svar