C-filer I / O: Skapa, öppna, läsa, skriva och stänga en fil

C Filhantering

En fil kan användas för att lagra en stor volym beständiga data. Liksom många andra språk erbjuder C C följande filhanteringsfunktioner,

Skapande av en fil
Öppna en fil
Läser en fil
Skriva till en fil
Stänga en fil

Följande är de viktigaste filhanteringsfunktionerna som finns i 'C'

fungera	ändamål
fopen ()	Skapa en fil eller öppna en befintlig fil
fclose ()	Stänga en fil
fprintf ()	Skriva ett datablock till en fil
fscanf ()	Läser blockdata från en fil
getc ()	Läser ett enda tecken från en fil
putc ()	Skriver ett enda tecken till en fil
getw ()	Läser ett heltal från en fil
putw ()	Skriva ett heltal till en fil
fseek ()	Ställer in en filpekares position till en viss plats
ftell ()	Returnerar den aktuella positionen för en filpekare
spola tillbaka ()	Ställer in filpekaren i början av en fil

I den här handledningen lär du dig-

Hur man skapar en fil
Hur man stänger en fil:
Skriva till en fil

fputc () -funktion:
fputs () Funktion:
fprintf () Funktion:

Läser data från en fil
Interaktiv fil läsa och skriva med getc och putc

Hur man skapar en fil

När du vill arbeta med en fil är det första steget att skapa en fil. En fil är bara utrymme i ett minne där data lagras.

För att skapa en fil i ett 'C' -program används följande syntax,

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

I ovanstående syntax är filen en datastruktur som definieras i standardbiblioteket.

fopen är en standardfunktion som används för att öppna en fil.

Om filen inte finns i systemet skapas den och öppnas sedan.
Om det redan finns en fil i systemet öppnas den direkt med den här funktionen.

fp är en filpekare som pekar på typfilen.

När du öppnar eller skapar en fil måste du ange vad du ska göra med filen. En fil i C-programmering kan skapas eller öppnas för läs- / skrivändamål. Ett läge används för att ange om du vill öppna en fil för något av nedanstående syften. Nedan följer de olika typerna av lägen i 'C' programmering som kan användas när du arbetar med en fil.

Filläge	Beskrivning
r	Öppna en fil för läsning. Om en fil är i läsläge raderas inga data om en fil redan finns i ett system.
w	Öppna en fil för att skriva. Om en fil är i skrivläge skapas en ny fil om en fil inte alls finns. Om det redan finns en fil i ett system, trunkeras all information i filen och den öppnas för skrivändamål.
a	Öppna en fil i append-läge. Om en fil är i tilläggsläge öppnas filen. Innehållet i filen ändras inte.
r +	öppet för läsning och skrivning från början
w +	öppen för läsning och skrivning, överskrivning av en fil
a +	öppen för läsning och skrivning, bifogad fil

I den angivna syntaxen anges filnamnet och läget som strängar, därför måste de alltid omges av dubbla citat.

Exempel:

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

Produktion:

Fil skapas i samma mapp där du har sparat din kod.

Du kan ange sökvägen där du vill skapa din fil

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

Hur man stänger en fil

Man bör alltid stänga en fil när operationerna på filen är över. Det betyder att innehållet och länkarna till filen avslutas. Detta förhindrar oavsiktlig skada på filen.

'C' tillhandahåller fclose-funktionen för att utföra filstängning. Syntaxen för fclose är som följer,

fclose (file_pointer);

Exempel:

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

Funktionen fclose tar en filpekare som ett argument. Filen som är associerad med filpekaren stängs sedan med hjälp av fclose-funktionen. Den returnerar 0 om stängningen lyckades och EOF (slutet av filen) om det finns ett fel inträffade när filen stängdes.

Efter att filen har stängts kan samma filpekare också användas med andra filer.

Vid 'C' programmering stängs filer automatiskt när programmet avslutas. Att stänga en fil manuellt genom att skriva fclose-funktionen är en bra programmeringsmetod.

Skriva till en fil

I C, när du skriver till en fil, måste nya linjetecken '\ n' läggas till uttryckligen.

Stdio-biblioteket erbjuder nödvändiga funktioner för att skriva till en fil:

fputc (char, file_pointer) : Den skriver ett tecken till filen som file_pointer pekar på.
fputs (str, file_pointer) : Den skriver en sträng till filen pekad av file_pointer.
fprintf (file_pointer, str, variable_lists) : Den skriver ut en sträng till filen som fil_pointer pekar på. Strängen kan valfritt inkludera formatspecifikatorer och en lista med variabler variabel_listor.

Programmet nedan visar hur man skriver till en fil:

fputc () -funktion:

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

Produktion:

Ovanstående program skriver en enda karaktär i filen fputc_test.txt tills den når nästa radsymbol "\ n" vilket indikerar att meningen skrivits framgångsrikt. Processen är att ta varje tecken i matrisen och skriva in den i filen.

I ovanstående program har vi skapat och öppnat en fil som heter fputc_test.txt i ett skrivläge och deklarerar vår sträng som kommer att skrivas in i filen.
Vi gör en tecken för teckenskrivning med hjälp av for loop och lägger in varje tecken i vår fil tills "\ n" -tecknet påträffas och sedan stängs filen med fclose-funktionen.

fputs () Funktion:

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

PRODUKTION:

I ovanstående program har vi skapat och öppnat en fil som heter fputs_test.txt i ett skrivläge.
När vi gör en skrivoperation med fputs () -funktionen genom att skriva tre olika strängar
Sedan stängs filen med fclose-funktionen.

fprintf () Funktion:

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

PRODUKTION:

I programmet ovan har vi skapat och öppnat en fil som heter fprintf_test.txt i ett skrivläge.
Efter att en skrivoperation har utförts med funktionen fprintf () genom att skriva en sträng, stängs filen med funktionen fclose.

Läser data från en fil

Det finns tre olika funktioner som är avsedda för att läsa data från en fil

fgetc (file_pointer): Den returnerar nästa tecken från filen som pekaren pekar på. När slutet på filen har nåtts skickas EOF tillbaka.
fgets (buffert, n, fil_pointer): Den läser n-1 tecken från filen och lagrar strängen i en buffert där NULL-tecknet '\ 0' läggs till som det sista tecknet.
fscanf (file_pointer, conversion_specifiers, variable_adresses) : Den används för att analysera och analysera data. Den läser tecken från filen och tilldelar ingången till en lista med variabla pekare variabeladresser med hjälp av konverteringsspecifikationer. Tänk på att som med scanf slutar fscanf att läsa en sträng när utrymme eller ny linje påträffas.

Följande program visar läsning från fputs_test.txt-filen med funktionerna fgets (), fscanf () respektive fgetc ():

#include 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 pointerchar 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 pointerwhile ((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

I ovanstående program har vi öppnat filen som heter "fprintf_test.txt" som tidigare skrevs med funktionen fprintf () och den innehåller "Learning C med Guru99" -sträng. Vi läser den med funktionen fgets () som läser rad för rad där buffertstorleken måste vara tillräcklig för att hantera hela raden.
Vi öppnar filen igen för att återställa pekaren till punkten i början av filen. Skapa olika strängvariabler för att hantera varje ord separat. Skriv ut variablerna för att se deras innehåll. Fscanf () används främst för att extrahera och analysera data från en fil.
Öppna filen igen för att återställa pekaren till punkten i början av filen. Läs data och skriv ut från filtecken för tecken med hjälp av getc () -funktionen tills EOF-uttalandet påträffas
Efter att ha utfört en läsningsfil med olika varianter stängde vi igen filen med funktionen fclose.

Interaktiv fil läsa och skriva med getc och putc

Det här är de enklaste filåtgärderna. Getc står för get character, och putc står för put character. Dessa två funktioner används för att hantera bara en enda karaktär åt gången.

Följande program visar filhanteringsfunktionerna i 'C' programmering:

#include int main() {FILE * fp;char c;printf("File Handling\n");//open a filefp = fopen("demo.txt", "w");//writing operationwhile ((c = getchar()) != EOF) {putc(c, fp);}//close filefclose(fp);printf("Data Entered:\n");//readingfp = fopen("demo.txt", "r");while ((c = getc(fp)) != EOF) {printf("%c", c);}fclose(fp);return 0;}

Produktion:

I ovanstående program har vi skapat och öppnat en fil som heter demo i ett skrivläge.
Efter att en skrivoperation har utförts stängs filen med fclose-funktionen.
Vi har åter öppnat en fil som nu innehåller data i ett läsläge. En stundslinga kommer att köras tills eof hittas. När filens slut har hittats avslutas operationen och data visas med printf-funktionen.
Efter en läsoperation stängs filen igen med fclose-funktionen.

Sammanfattning

En fil är ett utrymme i ett minne där data lagras.
'C' programmering ger olika funktioner för att hantera en fil.
En mekanism för att manipulera med filerna kallas filhantering.
En fil måste öppnas innan du utför åtgärder på den.
En fil kan öppnas i läs-, skriv- eller tilläggsläge.
Getc- och putc-funktioner används för att läsa och skriva en enda karaktär.
Funktionen fscanf () tillåter att läsa och analysera data från en fil
Vi kan läsa (med hjälp av getc- funktionen) en hel fil genom att loopa för att täcka hela filen tills EOF påträffas
Vi kan skriva till en fil efter att ha skapat dess namn med funktionen fprintf () och den måste ha den nya linjetecknet i slutet av strängtexten.