C Tiedostot I/O: Luo, avaa, lue, kirjoita ja sulje tiedosto

C Tiedostonhallinta

Tiedostoa voidaan käyttää suuren määrän pysyviä tietoja tallentamiseen. Kuten monet muut kielet, C tarjoaa seuraavat tiedostonhallintatoiminnot,

1. Tiedoston luominen
2. Tiedoston avaaminen
3. Tiedoston lukeminen
4. Kirjoittaminen tiedostoon
5. Tiedoston sulkeminen

Seuraavassa on tärkeimmät tiedostojen hallintatoiminnot, jotka ovat saatavilla 'C:ssä'

toiminto	tarkoitus
fopen()	Tiedoston luominen tai olemassa olevan tiedoston avaaminen
fclose ()	Tiedoston sulkeminen
fprintf()	Tietolohkon kirjoittaminen tiedostoon
fscanf ()	Lohkotietojen lukeminen tiedostosta
getc ()	Lukee yhden merkin tiedostosta
putc ()	Kirjoittaa tiedostoon yhden merkin
getw ()	Lukee tiedostosta kokonaisluvun
putw ()	Kokonaisluvun kirjoittaminen tiedostoon
fseek ()	Asettaa tiedoston osoittimen sijainnin tiettyyn paikkaan
ftell ()	Palauttaa tiedostoosoittimen nykyisen sijainnin
kelaa taaksepäin ()	Asettaa tiedostoosoittimen tiedoston alkuun

Kuinka luoda tiedosto

Aina kun haluat käsitellä tiedostoa, ensimmäinen askel on luoda tiedosto. Tiedosto ei ole muuta kuin tilaa muistissa, johon tiedot tallennetaan.

Tiedoston luomiseen C-ohjelmassa käytetään seuraavaa syntaksia,

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

Yllä olevassa syntaksissa tiedosto on tietorakenne, joka on määritelty vakiokirjastossa.

fopen on vakiotoiminto, jota käytetään tiedoston avaamiseen.

• Jos tiedostoa ei ole järjestelmässä, se luodaan ja avataan.
• Jos tiedosto on jo järjestelmässä, se avataan suoraan käyttämällä tätä toiminto.

fp on tiedostoosoitin, joka osoittaa tyyppitiedostoon.

Aina kun avaat tai luot tiedoston, sinun on määritettävä, mitä aiot tehdä tiedostolla. C-ohjelmointitiedosto voidaan luoda tai avata luku-/kirjoitustarkoituksiin. Tilaa käytetään määrittämään, haluatko avata tiedoston johonkin alla mainituista tarkoituksista. Seuraavassa on erityyppiset C-ohjelmoinnin tilat, joita voidaan käyttää tiedoston kanssa työskennellessä.

Tiedostotila	Tuotetiedot
r	Avaa tiedosto lukemista varten. Jos tiedosto on lukutilassa, tietoja ei poisteta, jos tiedosto on jo järjestelmässä.
w	Avaa tiedosto kirjoittamista varten. Jos tiedosto on kirjoitustilassa, uusi tiedosto luodaan, jos tiedostoa ei ole ollenkaan. Jos tiedosto on jo järjestelmässä, kaikki tiedoston sisältämät tiedot katkaistaan ​​ja se avataan kirjoittamista varten.
a	Avaa tiedosto sisään liitetila. Jos tiedosto on lisäystilassa, tiedosto avataan. Tiedoston sisältö ei muutu.
r+	avoin lukemista ja kirjoittamista varten alusta alkaen
w+	avoinna lukemista ja kirjoittamista varten, tiedoston päällekirjoittamista
a+	avoinna lukemista ja kirjoittamista varten, liittäminen tiedostoon

Annetussa syntaksissa tiedoston nimi ja tila on määritetty merkkijonoina, joten ne on aina oltava lainausmerkkien sisällä.

Esimerkiksi:

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

lähtö:

Tiedosto luodaan samaan kansioon, johon olet tallentanut koodisi.

Voit määrittää polun, johon haluat luoda tiedoston

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

Kuinka sulkea tiedosto

Tiedosto tulee aina sulkea aina, kun tiedoston toiminnot ovat ohi. Se tarkoittaa, että tiedoston sisältö ja linkit on lopetettu. Tämä estää tiedoston vahingossa vahingoittumisen.

"C" tarjoaa fclose-toiminnon tiedoston sulkemiseen. Fclose-syntaksi on seuraava,

fclose (file_pointer);

Esimerkiksi:

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

Fclose-funktio ottaa tiedostoosoittimen argumenttina. Tiedostoosoittimeen liittyvä tiedosto suljetaan sitten fclose-toiminnon avulla. Se palauttaa 0:n, jos sulkeminen onnistui, ja EOF:n (tiedoston loppu), jos tiedostoa suljettaessa on tapahtunut virhe.

Tiedoston sulkemisen jälkeen samaa tiedostoosoitinta voidaan käyttää myös muiden tiedostojen kanssa.

'C'-ohjelmoinnissa tiedostot suljetaan automaattisesti, kun ohjelma lopetetaan. Tiedoston sulkeminen manuaalisesti kirjoittamalla fclose-toiminto on hyvä ohjelmointikäytäntö.

Kirjoittaminen tiedostoon

C:ssä, kun kirjoitat tiedostoon, rivinvaihtomerkit '\n' on lisättävä erikseen.

Stdio-kirjasto tarjoaa tarvittavat toiminnot tiedostoon kirjoittamiseen:

• fputc(merkki, tiedosto_osoitin): Se kirjoittaa merkin tiedostoon, johon file_pointer osoittaa.
• fputs(str, tiedosto_osoitin): Se kirjoittaa merkkijonon tiedostoon, johon file_pointer osoittaa.
• fprintf(tiedoston_osoitin, str, muuttujien_luettelot): Se tulostaa merkkijonon tiedostoon, johon file_pointer osoittaa. Merkkijono voi valinnaisesti sisältää muotomääritteitä ja luettelon muuttujista variable_lists.

Alla oleva ohjelma näyttää kuinka kirjoittaa tiedostoon:

fputc()-funktio:

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

lähtö:

Yllä oleva ohjelma kirjoittaa yhden merkin fputc_test.txt tiedostoa, kunnes se saavuttaa seuraavan rivisymbolin "\n", joka osoittaa, että lause on kirjoitettu onnistuneesti. Prosessi on ottaa taulukon jokainen merkki ja kirjoittaa se tiedostoon.

1. Yllä olevassa ohjelmassa olemme luoneet ja avanneet tiedoston nimeltä fputc_test.txt kirjoitustilassa ja ilmoittaneet merkkijonomme, joka kirjoitetaan tiedostoon.
2. Kirjoitamme merkki kerrallaan käyttämällä for-silmukkaa ja laitamme jokaisen merkin tiedostoomme, kunnes \n-merkki kohtaamme, sitten tiedosto suljetaan fclose-funktiolla.

fputs () Toiminto:

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

lähtö:

1. Yllä olevassa ohjelmassa olemme luoneet ja avanneet tiedoston nimeltä fputs_test.txt kirjoitustilassa.
2. Kun teemme kirjoitustoiminnon fputs()-funktiolla kirjoittamalla kolme erilaista jouset
3. Sitten tiedosto suljetaan fclose-toiminnolla.

fprintf()-funktio:

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

lähtö:

1. Yllä olevassa ohjelmassa olemme luoneet ja avanneet tiedoston nimeltä fprintf_test.txt kirjoitustilassa.
2. Kun kirjoitustoiminto on suoritettu fprintf()-funktiolla kirjoittamalla merkkijono, tiedosto suljetaan fclose-funktiolla.

Tietojen lukeminen tiedostosta

Tietojen lukemiseen tiedostosta on kolme erilaista toimintoa

• fgetc(tiedoston_osoitin): Se palauttaa seuraavan merkin tiedostosta, johon tiedostoosoitin osoittaa. Kun tiedoston loppu on saavutettu, EOF lähetetään takaisin.
• fgets(puskuri, n, tiedosto_osoitin): Se lukee tiedostosta n-1 merkkiä ja tallentaa merkkijonon puskuriin, jonka viimeisenä merkkinä on NULL-merkki \0.
• fscanf(tiedoston_osoitin, muunnosmääritykset, muuttujan_osoitteet): Sitä käytetään tietojen jäsentämiseen ja analysointiin. Se lukee merkkejä tiedostosta ja määrittää syötteen luetteloon muuttuvat osoittimet variable_adresses käyttämällä muunnosmääritteitä. Muista, että kuten scanf:ssä, fscanf lopettaa merkkijonon lukemisen, kun välilyönti tai rivinvaihto kohtaavat.

Seuraava ohjelma näyttää lukemisen fputs_test.txt-tiedostosta käyttämällä fgets(),fscanf()- ja fgetc()-funktioita vastaavasti:

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

Tulos:

----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. Yllä olevassa ohjelmassa olemme avanneet tiedoston nimeltä “fprintf_test.txt”, joka on aiemmin kirjoitettu fprintf()-funktiolla, ja se sisältää tiedoston “Learning C with Guru99” merkkijono. Luemme sen fgets()-funktiolla, joka lukee rivi riviltä, ​​ja puskurin koon on oltava riittävä koko rivin käsittelemiseen.
2. Avaamme tiedoston uudelleen palauttaaksemme osoittimen osoittamaan tiedoston alkuun. Luomme erilaisia ​​merkkijonomuuttujia käsittelemään kutakin sanaa erikseen. Tulosta muuttujat nähdäksesi niiden sisällön. fscanf()-funktiota käytetään pääasiassa ...tract ja jäsentää tietoja tiedostosta.
3. Avaa tiedosto uudelleen palauttaaksesi osoitintiedoston osoittamaan tiedoston alkuun. Lue tiedot ja tulosta se tiedostosta merkki merkiltä käyttämällä getc()-funktiota, kunnes EOF-käsky löytyy
4. Suoritettuamme lukutoimintotiedoston eri muunnelmilla, suljemme tiedoston uudelleen fclose-toiminnolla.

Interaktiivinen tiedosto Lue ja kirjoita getc:llä ja putc:lla

Nämä ovat yksinkertaisimpia tiedostotoimintoja. Getc on lyhenne sanoista get character, ja putc tarkoittaa put character. Näitä kahta toimintoa käytetään käsittelemään vain yhtä merkkiä kerrallaan.

Seuraava ohjelma esittelee C-ohjelmoinnin tiedostojenkäsittelytoiminnot:

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

lähtö:

1. Yllä olevassa ohjelmassa olemme luoneet ja avaneet tiedoston nimeltä demo kirjoitustilassa.
2. Kun kirjoitus on suoritettu, tiedosto suljetaan fclose-toiminnolla.
3. Avasimme jälleen tiedoston, joka sisältää nyt dataa lukutilassa. While-silmukka suoritetaan, kunnes eof on löydetty. Kun tiedoston loppu on löydetty, toiminto lopetetaan ja tiedot näytetään printf-toiminnolla.
4. Lukutoiminnon suorittamisen jälkeen tiedosto suljetaan uudelleen fclose-toiminnolla.

Yhteenveto

• Tiedosto on muistitila, johon tietoja tallennetaan.
• C-ohjelmointi tarjoaa erilaisia ​​toimintoja tiedoston käsittelemiseen.
• Tiedostojen käsittelymekanismia kutsutaan tiedostonhallinnaksi.
• Tiedosto on avattava ennen toimintojen suorittamista.
• Tiedosto voidaan avata luku-, kirjoitus- tai lisäystilassa.
• Getc- ja putc-funktioita käytetään yhden merkin lukemiseen ja kirjoittamiseen.
• Funktio fscanf() sallii tietojen lukemisen ja jäsentämisen tiedostosta
• Voimme lukea (käyttäen getc funktio) koko tiedosto loo:n toimestaping peittää koko tiedoston, kunnes kohtaa EOF:n
• Voimme kirjoittaa tiedostoon sen nimen luomisen jälkeen käyttämällä funktiota fprintf() ja siinä on oltava rivinvaihtomerkki merkkijonotekstin lopussa.