C Tiedostot I/O: Luo, avaa, lue, kirjoita ja sulje tiedosto
Benjamin kävelijä
C Tiedostonhallinta
Tiedostoa voidaan käyttää suuren määrän pysyviä tietoja tallentamiseen. Kuten monet muut kielet, C tarjoaa seuraavat tiedostonhallintatoiminnot,
- Tiedoston luominen
- Tiedoston avaaminen
- Tiedoston lukeminen
- Kirjoittaminen tiedostoon
- 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.
- Yllä olevassa ohjelmassa olemme luoneet ja avanneet tiedoston nimeltä fputc_test.txt kirjoitustilassa ja ilmoittaneet merkkijonomme, joka kirjoitetaan tiedostoon.
- 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ö:
- Yllä olevassa ohjelmassa olemme luoneet ja avanneet tiedoston nimeltä fputs_test.txt kirjoitustilassa.
- Kun teemme kirjoitustoiminnon fputs()-funktiolla kirjoittamalla kolme erilaista jouset
- 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ö:
- Yllä olevassa ohjelmassa olemme luoneet ja avanneet tiedoston nimeltä fprintf_test.txt kirjoitustilassa.
- 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
- Yllä olevassa ohjelmassa olemme avanneet tiedoston nimeltä "fprintf_test.txt", joka on aiemmin kirjoitettu fprintf()-funktiolla ja joka sisältää "Learning C with Guru99" -merkkijonon. Luimme sen käyttämällä fgets()-funktiota, joka lukee rivi riviltä, jossa puskurin koon on oltava riittävä käsittelemään koko riviä.
- Avaamme tiedoston uudelleen palauttaaksemme osoitintiedoston osoittamaan tiedoston alkuun. Luo erilaisia merkkijonomuuttujia käsitelläksesi jokaista sanaa erikseen. Tulosta muuttujat nähdäksesi niiden sisällön. Fscanf()-funktiota käytetään pääasiassa tietojen poimimiseen ja jäsentämiseen tiedostosta.
- 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
- 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ö:
- Yllä olevassa ohjelmassa olemme luoneet ja avaneet tiedoston nimeltä demo kirjoitustilassa.
- Kun kirjoitus on suoritettu, tiedosto suljetaan fclose-toiminnolla.
- 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.
- 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 toiminto) koko tiedoston silmukalla peittämään koko tiedoston, kunnes EOF havaitaan
- Voimme kirjoittaa tiedostoon sen nimen luomisen jälkeen käyttämällä funktiota fprintf() ja siinä on oltava rivinvaihtomerkki merkkijonotekstin lopussa.
