C Files I/O: Creați, deschideți, citiți, scrieți și închideți un fișier

C Gestionarea fișierelor

Un fișier poate fi folosit pentru a stoca un volum mare de date persistente. La fel ca multe alte limbi, „C” oferă următoarele funcții de gestionare a fișierelor,

1. Crearea unui fișier
2. Deschiderea unui fișier
3. Citirea unui fișier
4. Scrierea într-un fișier
5. Închiderea unui fișier

Următoarele sunt cele mai importante funcții de gestionare a fișierelor disponibile în „C”,

funcţie	scop
fopen()	Crearea unui fișier sau deschiderea unui fișier existent
fclose ()	Închiderea unui fișier
fprintf()	Scrierea unui bloc de date într-un fișier
fscanf ()	Citirea unui bloc de date dintr-un fișier
getc ()	Citește un singur caracter dintr-un fișier
putc ()	Scrie un singur caracter într-un fișier
getw ()	Citește un număr întreg dintr-un fișier
putw ()	Scrierea unui număr întreg într-un fișier
fseek ()	Setează poziția unui pointer de fișier într-o locație specificată
ftell ()	Returnează poziția curentă a unui indicator de fișier
derulează înapoi ()	Setează indicatorul fișierului la începutul unui fișier

Cum se creează un fișier

Ori de câte ori doriți să lucrați cu un fișier, primul pas este să creați un fișier. Un fișier nu este altceva decât spațiu într-o memorie în care sunt stocate datele.

Pentru a crea un fișier într-un program „C” se folosește următoarea sintaxă,

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

În sintaxa de mai sus, fișierul este o structură de date care este definită în biblioteca standard.

fopen este o funcție standard care este folosită pentru a deschide un fișier.

• Dacă fișierul nu este prezent în sistem, atunci acesta este creat și apoi deschis.
• Dacă un fișier este deja prezent pe sistem, atunci acesta este deschis direct folosind aceasta funcţie.

fp este un indicator de fișier care indică fișierul de tip.

Ori de câte ori deschideți sau creați un fișier, trebuie să specificați ce veți face cu fișierul. Un fișier în programarea „C” poate fi creat sau deschis pentru citire/scriere. Un mod este folosit pentru a specifica dacă doriți să deschideți un fișier pentru oricare dintre scopurile de mai jos. Următoarele sunt diferitele tipuri de moduri din programarea „C” care pot fi utilizate în timp ce lucrați cu un fișier.

Modul fișier	Description
r	Deschideți un fișier pentru citire. Dacă un fișier este în modul de citire, atunci nicio dată nu este ștearsă dacă un fișier este deja prezent pe un sistem.
w	Deschideți un fișier pentru scriere. Dacă un fișier este în modul de scriere, atunci un fișier nou este creat dacă un fișier nu există deloc. Dacă un fișier este deja prezent pe un sistem, atunci toate datele din interiorul fișierului sunt trunchiate și sunt deschise pentru scriere.
a	Deschideți un fișier în modul anexare. Dacă un fișier este în modul de adăugare, atunci fișierul este deschis. Conținutul din fișier nu se modifică.
r+	deschis pentru citit și scris de la început
w+	deschis pentru citire și scriere, suprascrierea unui fișier
a+	deschis pentru citire și scriere, atașat la fișier

În sintaxa dată, numele fișierului și modul sunt specificate ca șiruri de caractere, prin urmare, trebuie să fie întotdeauna cuprinse între ghilimele duble.

Exemplu:

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

ieșire:

Fișierul este creat în același folder în care ați salvat codul.

Puteți specifica calea în care doriți să creați fișierul

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

Cum se închide un fișier

Ar trebui să închideți întotdeauna un fișier ori de câte ori operațiunile din fișier se termină. Înseamnă că conținutul și linkurile către fișier sunt terminate. Acest lucru previne deteriorarea accidentală a fișierului.

„C” oferă funcția fclose pentru a efectua operația de închidere a fișierului. Sintaxa lui fclose este următoarea:

fclose (file_pointer);

Exemplu:

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

Funcția fclose ia ca argument un pointer de fișier. Fișierul asociat cu indicatorul fișierului este apoi închis cu ajutorul funcției fclose. Returnează 0 dacă închiderea a avut succes și EOF (sfârșitul fișierului) dacă a apărut o eroare la închiderea fișierului.

După închiderea fișierului, același indicator de fișier poate fi folosit și cu alte fișiere.

În programarea „C”, fișierele se închid automat când programul este terminat. Închiderea manuală a unui fișier prin scrierea funcției fclose este o practică bună de programare.

Scrierea într-un fișier

În C, atunci când scrieți într-un fișier, caracterele newline „\n” trebuie adăugate în mod explicit.

Biblioteca stdio oferă funcțiile necesare pentru a scrie într-un fișier:

• fputc(char, file_pointer): scrie un caracter în fișierul indicat de file_pointer.
• fputs(str, file_pointer): scrie un șir în fișierul la care indică file_pointer.
• fprintf(indicator_fișier, str, liste_variabile): imprimă un șir în fișierul la care indică file_pointer. Șirul poate include opțional specificatori de format și o listă de variabile liste_variabile.

Programul de mai jos arată cum să efectuați scrierea într-un fișier:

Funcția fputc():

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

ieșire:

Programul de mai sus scrie un singur caracter în fputc_test.txt fișier până când ajunge la următoarea linie simbol „\n” care indică faptul că propoziția a fost scrisă cu succes. Procesul este de a lua fiecare caracter al matricei și de a-l scrie în fișier.

1. În programul de mai sus, am creat și deschis un fișier numit fputc_test.txt într-un mod de scriere și declarăm șirul nostru care va fi scris în fișier.
2. Facem o operație de scriere caracter cu caracter folosind bucla for și punem fiecare caracter în fișierul nostru până când este întâlnit caracterul „\n”, apoi fișierul este închis folosind funcția fclose.

fputs () Funcția:

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

ieșire:

1. În programul de mai sus, am creat și deschis un fișier numit fputs_test.txt într-un mod de scriere.
2. După ce facem o operație de scriere folosind funcția fputs() scriind trei diferite siruri
3. Apoi fișierul este închis folosind funcția fclose.

fprintf()Funcția:

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

ieșire:

1. În programul de mai sus am creat și deschis un fișier numit fprintf_test.txt într-un mod de scriere.
2. După ce o operație de scriere este efectuată folosind funcția fprintf() prin scrierea unui șir, atunci fișierul este închis folosind funcția fclose.

Citirea datelor dintr-un fișier

Există trei funcții diferite dedicate citirii datelor dintr-un fișier

• fgetc(file_pointer): Returnează următorul caracter din fișierul indicat de indicatorul fișierului. Când s-a ajuns la sfârșitul fișierului, EOF este trimis înapoi.
• fgets(buffer, n, file_pointer): Citește n-1 caractere din fișier și stochează șirul într-un buffer în care caracterul NULL „\0” este adăugat ca ultimul caracter.
• fscanf(file_pointer, conversie_specificers, variabile_adresses): este folosit pentru a analiza și analiza date. Citește caractere din fișier și atribuie intrarea unei liste de indicatori variabili adrese_variabile folosind specificatorii de conversie. Rețineți că, ca și în cazul scanf, fscanf oprește citirea unui șir atunci când se întâlnește spațiu sau linie nouă.

Următorul program demonstrează citirea din fișierul fputs_test.txt folosind funcțiile fgets(), fscanf() și respectiv fgetc ():

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

Rezultat:

----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. În programul de mai sus, am deschis fișierul numit „fprintf_test.txt” care a fost scris anterior folosind funcția fprintf() și conține șirul „Learning C with Guru99”. O citim folosind funcția fgets() care citește linie cu linie unde dimensiunea tamponului trebuie să fie suficientă pentru a gestiona întreaga linie.
2. Redeschidem fișierul pentru a reseta fișierul pointer la începutul fișierului. Creați diverse variabile șiruri pentru a gestiona fiecare cuvânt separat. Imprimați variabilele pentru a le vedea conținutul. fscanf() este folosit în principal pentru a extrage și a analiza date dintr-un fișier.
3. Redeschideți fișierul pentru a reseta fișierul pointer la începutul fișierului. Citiți datele și imprimați-le din fișier caracter cu caracter folosind funcția getc() până când este întâlnită instrucțiunea EOF
4. După efectuarea unui fișier de operație de citire folosind diferite variante, am închis din nou fișierul folosind funcția fclose.

Citiți și scrieți fișiere interactive cu getc și putc

Acestea sunt cele mai simple operații de fișiere. Getc înseamnă get character, iar putc înseamnă put character. Aceste două funcții sunt folosite pentru a gestiona doar un singur caracter la un moment dat.

Următorul program demonstrează funcțiile de gestionare a fișierelor în programarea „C”:

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

ieșire:

1. În programul de mai sus am creat și deschis un fișier numit demo într-un mod de scriere.
2. După efectuarea unei operații de scriere, fișierul este închis folosind funcția fclose.
3. Am deschis din nou un fișier care conține acum date într-un mod de citire. O buclă while se va executa până când este găsită eof. Odată ce sfârșitul fișierului este găsit, operațiunea va fi încheiată și datele vor fi afișate folosind funcția printf.
4. După efectuarea unei operații de citire, fișierul este din nou închis folosind funcția fclose.

Rezumat

• Un fișier este un spațiu dintr-o memorie în care sunt stocate datele.
• Programarea „C” oferă diverse funcții pentru a trata un fișier.
• Un mecanism de manipulare a fișierelor se numește gestionarea fișierelor.
• Un fișier trebuie deschis înainte de a efectua operațiuni asupra acestuia.
• Un fișier poate fi deschis într-un mod de citire, scriere sau anexare.
• Funcțiile Getc și putc sunt folosite pentru a citi și scrie un singur caracter.
• Funcția fscanf() permite citirea și analizarea datelor dintr-un fișier
• Putem citi (folosind getc funcția) un fișier întreg prin buclă pentru a acoperi tot fișierul până când este întâlnit EOF
• Putem scrie într-un fișier după ce i-am creat numele, folosind funcția fprintf() și trebuie să aibă caracterul newline la sfârșitul textului șirului.