C File I/O: crea, apre, legge, scrive e chiude un file

C Gestione dei file

Un file può essere utilizzato per memorizzare un grande volume di dati persistenti. Come molti altri linguaggi, il linguaggio 'C' fornisce la seguente gestione dei file. funzioni,

1. Creazione di un file
2. Apertura di un file
3. Leggere un file
4. Scrittura su un file
5. Chiusura di un file

Di seguito sono riportate le funzioni di gestione dei file più importanti disponibili in 'C',

Come creare un file

Ogni volta che vuoi lavorare con un file, il primo passo è creare un file. Un file non è altro che spazio in una memoria in cui vengono archiviati i dati.

Per creare un file in un programma 'C' viene utilizzata la seguente sintassi,

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

Nella sintassi precedente, il file è una struttura dati definita nella libreria standard.

fopen è una funzione standard che viene utilizzata per aprire un file.

• Se il file non è presente nel sistema, viene creato e quindi aperto.
• Se un file è già presente nel sistema, viene aperto direttamente utilizzando questa funzione.

fp è un file pointer che punta al file di tipo.

Ogni volta che apri o crei un file, devi specificare cosa farai con il file. Un file nella programmazione 'C' può essere creato o aperto per scopi di lettura/scrittura. Una modalità viene utilizzata per specificare se vuoi aprire un file per uno degli scopi indicati di seguito. Di seguito sono riportati i diversi tipi di modalità nella programmazione 'C' che possono essere utilizzati mentre si lavora con un file.

Nella sintassi indicata, il nome del file e la modalità sono specificati come stringhe pertanto devono essere sempre racchiusi tra virgolette doppie.

Per esempio:

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

Produzione:

Il file viene creato nella stessa cartella in cui hai salvato il codice.

Puoi specificare il percorso in cui desideri creare il tuo file

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

Come chiudere un file

Si dovrebbe sempre chiudere un file ogni volta che le operazioni sul file sono terminate. Significa che i contenuti e i collegamenti al file sono terminati. Ciò impedisce danni accidentali al file.

'C' fornisce la funzione fclose per eseguire l'operazione di chiusura del file. La sintassi di fclose è la seguente,

fclose (file_pointer);

Per esempio:

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

La funzione fclose accetta come argomento un puntatore a un file. Il file associato al puntatore viene quindi chiuso tramite la funzione fclose. Restituisce 0 se la chiusura è andata a buon fine e EOF (fine del file) se si è verificato un errore durante la chiusura del file.

Dopo aver chiuso il file, lo stesso puntatore al file può essere utilizzato anche con altri file.

Nella programmazione 'C', i file vengono chiusi automaticamente quando il programma viene terminato. Chiudere manualmente un file scrivendo la funzione fclose è una buona pratica di programmazione.

Scrittura su un file

In C, quando scrivi su un file, i caratteri di nuova riga '\n' devono essere aggiunti esplicitamente.

La libreria stdio offre le funzioni necessarie per scrivere su un file:

• fputc(char, file_pointer): Scrive un carattere nel file puntato da file_pointer.
• fputs(str, file_pointer): Scrive una stringa nel file puntato da file_pointer.
• fprintf(file_pointer, str, variable_lists): Stampa una stringa nel file puntato da file_pointer. La stringa può facoltativamente includere specificatori di formato e un elenco di variabili variable_lists.

Il programma seguente mostra come eseguire la scrittura su un file:

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

Produzione:

Il programma sopra riportato scrive un singolo carattere nel file fputc_test.txt fino a raggiungere il simbolo di riga successiva "\n", che indica che la frase è stata scritta correttamente. Il processo consiste nel prendere ogni carattere dell'array e scriverlo nel file.

1. Nel programma sopra, abbiamo creato e aperto un file chiamato fputc_test.txt in modalità scrittura e dichiariamo la nostra stringa che verrà scritta nel file.
2. Eseguiamo un'operazione di scrittura carattere per carattere utilizzando il ciclo for e inseriamo ogni carattere nel nostro file finché non viene incontrato il carattere "\n", quindi il file viene chiuso utilizzando la funzione fclose.

fputs() Funzione:

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

Produzione:

1. Nel programma sopra, abbiamo creato e aperto un file chiamato fputs_test.txt in modalità scrittura.
2. Dopo aver eseguito un'operazione di scrittura utilizzando la funzione fputs() scrivendo tre stringhe diverse
3. Quindi il file viene chiuso utilizzando la funzione fclose.

fprintf()Funzione:

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

Produzione:

1. Nel programma sopra abbiamo creato e aperto un file chiamato fprintf_test.txt in modalità scrittura.
2. Dopo che un'operazione di scrittura viene eseguita utilizzando la funzione fprintf() scrivendo una stringa, il file viene chiuso utilizzando la funzione fclose.

Lettura dei dati da un file

Esistono tre diverse funzioni dedicate alla lettura dei dati da un file

• fgetc(file_pointer): Restituisce il carattere successivo dal file puntato dal puntatore. Quando viene raggiunta la fine del file, viene restituito EOF.
• fgets(buffer, n, puntatore_file): Legge n-1 caratteri dal file e memorizza la stringa in un buffer in cui il carattere NULL '\0' viene aggiunto come ultimo carattere.
• fscanf(puntatore_file, specificatori_di_conversione, indirizzi_variabili): Viene utilizzato per analizzare i dati. Legge i caratteri dal file e assegna l'input a un elenco di puntatori a variabili, indirizzi_variabili, utilizzando specificatori di conversione. Tieni presente che, come per scanf, fscanf interrompe la lettura di una stringa quando incontra uno spazio o un carattere di nuova riga.

Il seguente programma dimostra la lettura dal file fputs_test.txt utilizzando rispettivamente le funzioni fgets(), fscanf() e 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;
    }

Risultato:

----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. Nel programma precedente, abbiamo aperto il file chiamato "fprintf_test.txt" che è stato precedentemente scritto usando la funzione fprintf() e contiene "Imparare C con GuruStringa da 99". La leggiamo usando la funzione fgets() che legge riga per riga, dove la dimensione del buffer deve essere sufficiente a gestire l'intera riga.
2. Riapriamo il file per reimpostare il puntatore del file in modo che punti all'inizio del file. Creiamo varie variabili stringa per gestire ogni parola separatamente. Stampiamo le variabili per visualizzarne il contenuto. La funzione fscanf() viene utilizzata principalmente pertract e analizzare i dati da un file.
3. Riaprire il file per reimpostare il file del puntatore in modo che punti all'inizio del file. Leggi i dati e stampali dal file carattere per carattere utilizzando la funzione getc() finché non viene incontrata l'istruzione EOF
4. Dopo aver eseguito un'operazione di lettura del file utilizzando diverse varianti, abbiamo nuovamente chiuso il file utilizzando la funzione fclose.

Lettura e scrittura di file interattivi con getc e putc

Queste sono le operazioni sui file più semplici. Getc sta per get carattere e putc sta per put carattere. Queste due funzioni vengono utilizzate per gestire solo un singolo carattere alla volta.

Il programma seguente illustra le funzioni di gestione dei file nella programmazione '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;
    }

Produzione:

1. Nel programma sopra abbiamo creato e aperto un file chiamato demo in modalità scrittura.
2. Dopo aver eseguito un'operazione di scrittura, il file viene chiuso utilizzando la funzione fclose.
3. Abbiamo nuovamente aperto un file che ora contiene dati in modalità lettura. Verrà eseguito un ciclo while finché non verrà trovato eof. Una volta trovata la fine del file, l'operazione verrà terminata e i dati verranno visualizzati utilizzando la funzione printf.
4. Dopo aver eseguito un'operazione di lettura, il file viene nuovamente chiuso utilizzando la funzione fclose.

DOMANDE FREQUENTI