C Filer I/O: Opret, åbn, læs, skriv og luk en fil

C Filhåndtering

En fil kan bruges til at lagre en stor mængde persistente data. Ligesom mange andre sprog tilbyder 'C' følgende filhåndtering funktioner,

1. Oprettelse af en fil
2. Åbning af en fil
3. Læser en fil
4. Skriver til en fil
5. Lukning af en fil

Følgende er de vigtigste filhåndteringsfunktioner, der er tilgængelige i 'C,'

Sådan opretter du en fil

Når du vil arbejde med en fil, er det første skridt at oprette en fil. En fil er intet andet end plads i en hukommelse, hvor data gemmes.

For at oprette en fil i et 'C'-program bruges følgende syntaks,

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

I ovenstående syntaks er filen en datastruktur, som er defineret i standardbiblioteket.

fopen er en standardfunktion, som bruges til at åbne en fil.

• Hvis filen ikke er til stede på systemet, oprettes den og åbnes derefter.
• Hvis en fil allerede findes på systemet, åbnes den direkte ved hjælp af denne funktion.

fp er en fil pointer som peger på typefilen.

Når du åbner eller opretter en fil, skal du angive, hvad du vil gøre med filen. En fil i 'C'-programmering kan oprettes eller åbnes til læse-/skriveformål. En tilstand bruges til at angive, om du vil åbne en fil til nogen af ​​de nedenfor angivne formål. Følgende er de forskellige typer tilstande i 'C'-programmering, som kan bruges, mens du arbejder med en fil.

I den givne syntaks er filnavnet og tilstanden angivet som strygere derfor skal de altid omsluttes af dobbelte anførselstegn.

For eksempel:

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

Output:

Filen oprettes i samme mappe, hvor du har gemt din kode.

Du kan angive stien, hvor du vil oprette din fil

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

Sådan lukkes en fil

Man bør altid lukke en fil, når handlingerne på filen er overstået. Det betyder, at indholdet og links til filen er afsluttet. Dette forhindrer utilsigtet beskadigelse af filen.

'C' giver fclose-funktionen til at udføre fillukningsoperation. Syntaksen for fclose er som følger,

fclose (file_pointer);

For eksempel:

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

Funktionen fclose tager en filpointer som argument. Filen, der er knyttet til filpointeren, lukkes derefter ved hjælp af fclose-funktionen. Den returnerer 0, hvis lukningen lykkedes, og EOF (slut på fil), hvis der opstod en fejl under fillukningen.

Efter lukning af filen kan den samme filmarkør også bruges med andre filer.

I 'C'-programmering lukkes filer automatisk, når programmet afsluttes. At lukke en fil manuelt ved at skrive fclose-funktionen er en god programmeringspraksis.

Skrivning til en fil

I C, når du skriver til en fil, skal nylinjetegn '\n' udtrykkeligt tilføjes.

Stdio-biblioteket tilbyder de nødvendige funktioner til at skrive til en fil:

• fputc(char, file_pointer): Den skriver et tegn til den fil, som file_pointer peger på.
• fputs(str, file_pointer): Den skriver en streng til den fil, som file_pointer peger på.
• fprintf(file_pointer, str, variable_lists): Den udskriver en streng til den fil, som file_pointer peger på. Strengen kan eventuelt indeholde formatspecifikationer og en liste over variabler variable_lists.

Programmet nedenfor viser, hvordan man skriver til en fil:

fputc() Funktion:

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

Ovenstående program skriver et enkelt tegn ind i filen fputc_test.txt, indtil det når næste linjesymbol "\n", hvilket angiver, at sætningen blev skrevet korrekt. Processen er at tage hvert tegn i arrayet og skrive det ind i filen.

1. I ovenstående program har vi oprettet og åbnet en fil kaldet fputc_test.txt i en skrivetilstand og erklærer vores streng, som vil blive skrevet ind i filen.
2. Vi laver en tegn-for-tegn-skriveoperation ved at bruge for loop og sætter hvert tegn i vores fil, indtil "\n"-tegnet bliver stødt på, hvorefter filen lukkes ved hjælp af fclose-funktionen.

fputs () Funktion:

#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. I ovenstående program har vi oprettet og åbnet en fil kaldet fputs_test.txt i en skrivetilstand.
2. Efter vi har udført en skriveoperation ved hjælp af funktionen fputs() ved at skrive tre forskellige strenge
3. Derefter lukkes filen ved hjælp af fclose-funktionen.

fprintf() Funktion:

#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. I ovenstående program har vi oprettet og åbnet en fil kaldet fprintf_test.txt i en skrivetilstand.
2. Efter en skriveoperation er udført ved hjælp af fprintf()-funktionen ved at skrive en streng, lukkes filen ved hjælp af fclose-funktionen.

Læsning af data fra en fil

Der er tre forskellige funktioner dedikeret til at læse data fra en fil

• fgetc(file_pointer): Returnerer det næste tegn fra den fil, som filpointeren peger på. Når slutningen af ​​filen er nået, sendes EOF'en tilbage.
• fgets(buffer, n, file_pointer): Den læser n-1 tegn fra filen og gemmer strengen i en buffer, hvor NULL-tegnet '\0' er tilføjet som det sidste tegn.
• fscanf(file_pointer, conversion_specifiers, variable_adresses): Den bruges til at parse og analysere data. Den læser tegn fra filen og tildeler inputtet til en liste af variable pointere variable_adresses ved hjælp af konverteringsspecifikationer. Husk, at ligesom med scanf stopper fscanf med at læse en streng, når der opstår mellemrum eller linjeskift.

Følgende program demonstrerer læsning fra fputs_test.txt fil ved hjælp af henholdsvis fgets(),fscanf() og fgetc() funktioner:

#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 ovenstående program har vi åbnet filen kaldet “fprintf_test.txt”, som tidligere blev skrevet ved hjælp af funktionen fprintf(), og den indeholder “Learning C with Guru99” streng. Vi læser den ved hjælp af funktionen fgets(), som læser linje for linje, hvor bufferstørrelsen skal være tilstrækkelig til at håndtere hele linjen.
2. Vi genåbner filen for at nulstille pointerfilen til at pege i starten af ​​filen. Opret forskellige strengevariabler til at håndtere hvert ord separat. Udskriv variablerne for at se deres indhold. fscanf() bruges primært til at f.eks.tract og parse data fra en fil.
3. Åbn filen igen for at nulstille markørfilen til at pege i begyndelsen af ​​filen. Læs data og udskriv dem fra filen tegn for tegn ved hjælp af getc()-funktionen, indtil EOF-sætningen stødes på
4. Efter at have udført en læseoperationsfil ved hjælp af forskellige varianter, lukkede vi igen filen ved hjælp af fclose-funktionen.

Interaktiv fil Læs og skriv med getc og putc

Dette er de enkleste filhandlinger. Getc står for get character, og putc står for put character. Disse to funktioner bruges til kun at håndtere et enkelt tegn ad gangen.

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

Output:

1. I ovenstående program har vi oprettet og åbnet en fil kaldet demo i en skrivetilstand.
2. Efter en skriveoperation er udført, lukkes filen ved hjælp af fclose-funktionen.
3. Vi har igen åbnet en fil, som nu indeholder data i en læsetilstand. En while-løkke vil udføres, indtil eof er fundet. Når slutningen af ​​filen er fundet, vil operationen blive afsluttet, og data vil blive vist ved hjælp af printf-funktionen.
4. Efter at have udført en læseoperation lukkes filen igen ved hjælp af fclose-funktionen.

Ofte Stillede Spørgsmål