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

C Filhåndtering

En fil kan bruges til at gemme en stor mængde vedvarende data. Som mange andre sprog giver 'C' følgende filhåndteringsfunktioner,

  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,'

funktion formål
fopen() Oprettelse af en fil eller åbning af en eksisterende fil
fluk () Lukning af en fil
fprintf() At skrive en blok af data til en fil
fscanf () Læsning af blokdata fra en fil
getc () Læser et enkelt tegn fra en fil
putc () Skriver et enkelt tegn til en fil
få () Læser et heltal fra en fil
putw () At skrive et heltal til en fil
fseek () Indstiller placeringen af ​​en filmarkør til en specificeret placering
ftell () Returnerer den aktuelle position for en filmarkør
spole tilbage () Indstiller filmarkøren i begyndelsen af ​​en fil

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 er til stede på systemet, åbnes den direkte ved hjælp af denne funktion.

fp er en filmarkør, 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.

Filtilstand Description
r Åbn en fil til læsning. Hvis en fil er i læsetilstand, slettes ingen data, hvis en fil allerede er til stede på et system.
w Åbn en fil til skrivning. Hvis en fil er i skrivetilstand, oprettes en ny fil, hvis en fil slet ikke eksisterer. Hvis en fil allerede er til stede på et system, afkortes alle data inde i filen, og den åbnes til skriveformål.
a Åbn en fil i
tilføje tilstand. Hvis en fil er i tilføjelsestilstand, åbnes filen. Indholdet i filen ændres ikke.
r+ åben for læsning og skrivning fra begyndelsen
w+ åben til læsning og skrivning, overskrivning af en fil
a+ åben for læsning og skrivning, vedhæftet fil

I den givne syntaks er filnavnet og tilstanden angivet som strenge, så de skal altid være omgivet af dobbelte anførselstegn.

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.

Sådan opretter du en fil

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 opretter du en fil

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

Eksempel:

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

Funktionen fclose tager en filmarkør som et argument. Filen tilknyttet filmarkøren lukkes derefter ved hjælp af fclose-funktionen. Den returnerer 0, hvis lukningen lykkedes, og EOF (slut på filen), hvis der er opstået 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 filen, der peges på af file_pointer.
  • fputs(str, file_pointer): Den skriver en streng til filen, der peges på af file_pointer.
  • fprintf(fil_pointer, str, variable_lister): Den udskriver en streng til filen, der peges på af file_pointer. Strengen kan eventuelt inkludere formatspecifikationer og en liste over variable 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:

Skrivning til en fil

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

Skrivning til en fil

  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:

Skrivning til en fil

Skrivning til en fil

  1. I ovenstående program har vi oprettet og åbnet en fil kaldet fputs_test.txt i en skrivetilstand.
  2. Efter at vi har lavet en skriveoperation ved hjælp af fputs() funktion ved at skrive tre forskellige strygere
  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:

Skrivning til en fil

Skrivning til en fil

  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(fil_pointer): Det returnerer det næste tegn fra filen, som filmarkøren peger på. Når slutningen af ​​filen er nået, sendes EOF 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(fil_pointer, konverteringsspecifikationer, variable_adresser): Det bruges til at parse og analysere data. Den læser tegn fra filen og tildeler input til en liste over variable pointer variable_adresser ved hjælp af konverteringsspecifikationer. Husk, at som med scanf, stopper fscanf med at læse en streng, når der stødes på mellemrum eller ny linje.

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

Læsning af data fra en fil

  1. I ovenstående program har vi åbnet filen kaldet "fprintf_test.txt", som tidligere blev skrevet med fprintf()-funktionen, og den indeholder "Learning C with Guru99"-strengen. Vi læser det ved hjælp af fgets()-funktionen, som læser linje for linje, hvor bufferstørrelsen skal være nok til at håndtere hele linjen.
  2. Vi genåbner filen for at nulstille markørfilen til at pege i begyndelsen af ​​filen. Opret forskellige strengvariabler for at håndtere hvert ord separat. Udskriv variablerne for at se deres indhold. fscanf() bruges hovedsageligt til at udtrække 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:

Interaktiv fil Læs og skriv med getc og putc

Interaktiv fil Læs og skriv med getc og putc

  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.

Resumé

  • En fil er et rum i en hukommelse, hvor data gemmes.
  • 'C'-programmering giver forskellige funktioner til at håndtere en fil.
  • En mekanisme til at manipulere med filerne kaldes filhåndtering.
  • En fil skal åbnes, før du udfører handlinger på den.
  • En fil kan åbnes i læse-, skrive- eller tilføjelsestilstand.
  • Getc og putc funktioner bruges til at læse og skrive et enkelt tegn.
  • Funktionen fscanf() tillader at læse og parse data fra en fil
  • Vi kan læse (ved hjælp af den getc funktion) en hel fil ved at sløjfe for at dække hele filen, indtil EOF stødes på
  • Vi kan skrive til en fil efter at have oprettet dens navn ved at bruge funktionen fprintf() og den skal have et linjeskifttegn i slutningen af ​​strengteksten.