Gestione di file e Stream in C

Come leggere un file e distinguere fine ed errore

Tutte le variabili, gli array e le strutture che abbiamo creato finora vivono nella memoria centrale (RAM): non appena il programma termina (o si spegne il computer), tutti i dati in RAM svaniscono nel nulla!

Per conservare i dati in modo permanente (persistenza) o elaborare grandi quantità di informazioni salvate su disco (SSD/Hard Disk), un programma deve saper leggere e scrivere File.

Il linguaggio C affronta questo problema con una straordinaria eleganza progettuale: estende ai file su disco la stessa identica astrazione di Stream (Flusso di byte) che abbiamo già usato nella Lezione 2.3.1 per la tastiera (stdin) e lo schermo (stdout). Una volta aperto un file e ottenuto un puntatore di controllo FILE *, leggerlo o scriverlo con fscanf e fprintf è quasi identico a usare scanf e printf!


L’Astrazione di Stream, FILE * e File di Testo vs File Binari

Il puntatore opaco FILE *

In <stdio.h> è definito un tipo struttura speciale chiamato FILE. Il programmatore non deve mai accedere direttamente ai campi interni di FILE (per questo si chiama tipo opaco o handle), ma interagisce sempre tramite un puntatore FILE *fp, che contiene tutte le informazioni necessarie al sistema operativo per gestire il flusso:

  • Il descrittore del file aperto nel sistema operativo.
  • Il buffer di memoria per velocizzare le letture/scritture su disco.
  • Il cursore di posizione corrente (file position indicator, l’indice del prossimo byte da leggere o scrivere).
  • I flag di stato (Fine del file EOF ed Errore di I/O).

File di Testo vs File Binari

  1. File di Testo (.txt, .csv, .c, .json):
    • I dati sono convertiti e salvati come sequenze di caratteri ASCII/UTF-8 leggibili da un essere umano (e apribili con qualsiasi editor di testo), organizzate in righe terminate da \n.
    • Esempio: il numero intero 123456 viene scritto come i 6 caratteri ASCII '1', '2', '3', '4', '5', '6' (6 byte).
  2. File Binari (.bin, .dat, immagini, eseguibili):
    • I byte contenuti nella memoria RAM delle variabili o delle struct vengono copiati direttamente su disco così come sono, senza alcuna conversione testuale!
    • Esempio: qualsiasi int (anche 123456 o 2000000000) occupa sempre esattamente 4 byte su disco, risultando più compatto e molto più veloce da leggere/scrivere in blocco, ma non leggibile con un normale blocco note.

Il Ciclo di Vita di un File: fopen, Controllo NULL e fclose

Ogni operazione su file segue rigorosamente 3 fasi obbligatorie:

flowchart LR
    OPEN["1. Apertura\nFILE *fp = fopen(nome, modo);"] --> CHK{"fp == NULL ?"}
    CHK -->|"Sì (Errore!)"| ERR["Gestione errore\nperror(\"Errore\");\nreturn 1;"]
    CHK -->|"No (Valido)"| RW["2. Lettura / Scrittura\nfscanf, fprintf, fgets,\nfread, fwrite, fseek"]
    RW --> CLOSE["3. Chiusura obbligatoria\nfclose(fp);"]

1. Apertura con fopen(percorso, modalita) e controllo if (fp == NULL)

FILE *fp = fopen("dati.txt", "r");
if (fp == NULL) {
    perror("Impossibile aprire dati.txt"); /* Stampa su stderr il motivo esatto dell'errore! */
    return 1;
}

Regola ferrea: fopen restituisce NULL se l’apertura fallisce (ad esempio perché il file da leggere non esiste, il percorso è sbagliato o non abbiamo i permessi di scrittura sul disco). Passare un puntatore fp == NULL a fscanf o fprintf provoca un immediato Segmentation Fault! Controlla sempre if (fp == NULL) subito dopo fopen.

Tabella completa delle Modalità di apertura (mode)

Modalità TestoModalità BinariaOperazioni consentiteSe il file ESISTE giàSe il file NON ESISTE
"r""rb"Sola Lettura (Read)Legge dall’inizio del fileFallisce e restituisce NULL!
"w""wb"Sola Scrittura (Write)CANCELLA TUTTO il vecchio contenuto (tronca a 0 byte)!Lo crea nuovo
"a""ab"Aggiunta in Coda (Append)Scrive sempre in fondo senza cancellare il vecchio contenutoLo crea nuovo
"r+""r+b"Lettura e ScritturaLegge/scrive dall’inizio senza cancellareFallisce e restituisce NULL!
"w+""w+b"Lettura e ScritturaCancella tutto il vecchio contenuto!Lo crea nuovo
"a+""a+b"Lettura e Aggiunta in codaLegge ovunque, ma scrive sempre in fondoLo crea nuovo

2. Chiusura con fclose(fp)

Quando abbiamo finito di usare il file, dobbiamo sempre chiuderlo con:

fclose(fp);

Perché fclose è così importante? Perché le scritture su disco sono bufferizzate in RAM per motivi di efficienza: se il programma termina bruscamente o dimentica fclose(fp), gli ultimi dati scritti potrebbero rimanere nel buffer in RAM e non finire mai sul disco (oppure potremmo esaurire il numero massimo di file apribili contemporaneamente dal processo).


Operazioni su File di Testo e la Trappola di feof(fp)!

Tutte le funzioni di <stdio.h> viste per tastiera e schermo hanno la loro gemella per i file:

Su Standard Stream (stdin / stdout)Su File di Testo (FILE *fp)Comportamento e Valore di ritorno per fine file / errore
printf("fmt", ...)fprintf(fp, "fmt", ...)Scrive testo formattato sul file fp. (Nota: fprintf(stdout, ...) equivale a printf(...)!).
scanf("fmt", ...)fscanf(fp, "fmt", ...)Legge dati formattati da fp. Restituisce il numero di variabili lette con successo, oppure EOF a fine file.
fgets(buf, dim, stdin)fgets(buf, dim, fp)Legge una riga intera (fino a \n o dim-1 byte). Restituisce buf, oppure NULL a fine file!
getchar()fgetc(fp)Legge un singolo carattere (ritorno int!). Restituisce EOF a fine file.
putchar(c)fputc(c, fp)Scrive il carattere c sul file fp.

Perché NON bisogna MAI usare while (!feof(fp)) prima della lettura!

Questo è l’errore più diffuso in assoluto nella programmazione C sui file:

/* CODICE SBAGLIATO: stampa o elabora L'ULTIMA RIGA DUE VOLTE! */
while (!feof(fp)) {
    fscanf(fp, "%d", &x); /* Quando finisce il file, questa fscanf FALLISCE... */
    printf("%d\n", x);    /* ...ma il ciclo esegue comunque printf stampando il VECCHIO x! */
}

Spiegazione tecnica: La funzione feof(fp) restituisce Vero (!= 0) SOLO DOPO che un’operazione di lettura ha tentato di leggere oltre la fine del file ed è fallita (non “indovina” in anticipo che il file sta per finire!).
Se quindi usate while (!feof(fp)), dopo aver letto l’ultimo numero del file feof(fp) è ancora Falso; il programma entra nel ciclo un’ultima volta, fscanf fallisce perché il file è finito (lasciando in x il valore del giro precedente!) e voi elaborate o stampate l’ultimo dato due volte!

Modo CORRETTO e universale per leggere un file fino alla fine:
Mettere direttamente la funzione di lettura nella condizione del while controllandone il valore di ritorno:

  • Con fscanf: while (fscanf(fp, "%d", &x) == 1) { ... }
  • Con fgets: while (fgets(buf, sizeof(buf), fp) != NULL) { ... }
  • Con fgetc: while ((c = fgetc(fp)) != EOF) { ... }

Operazioni su File Binari (fread, fwrite) e Navigazione (fseek, ftell)

1. Lettura e scrittura in blocco su file binari: fread e fwrite

Per leggere o scrivere un array o una struct direttamente in binario (file aperto con "rb" o "wb"):

size_t fread(void *ptr, size_t dim_elemento, size_t num_elementi, FILE *fp);
size_t fwrite(const void *ptr, size_t dim_elemento, size_t num_elementi, FILE *fp);

Entrambe restituiscono il numero di elementi effettivamente letti o scritti (che deve essere uguale a num_elementi se tutto è andato bene):

Studente s = {101, "Anna", 29.5};
/* Scriviamo 1 elemento di dimensione sizeof(Studente) sul file binario fp: */
fwrite(&s, sizeof(Studente), 1, fp);
 
/* Oppure scriviamo un intero vettore di 50 int in un colpo solo: */
int v[50];
fwrite(v, sizeof(int), 50, fp);

2. Accesso diretto (Random Access): fseek, ftell e rewind

Non siamo obbligati a leggere un file solo dall’inizio alla fine! Possiamo spostare il cursore del file in qualsiasi byte usando:

  • fseek(fp, offset_in_byte, origine): sposta il cursore di offset_in_byte (tipo long, anche negativo) rispetto a origine, che può essere:
    • SEEK_SET: dall’inizio del file (byte 0).
    • SEEK_CUR: dalla posizione corrente del cursore.
    • SEEK_END: dalla fine del file.
  • long pos = ftell(fp): restituisce la posizione corrente del cursore in byte dall’inizio del file. (Trucco classico: fare fseek(fp, 0, SEEK_END); long dim = ftell(fp); permette di sapere quanti byte è grande un file binario!).
  • rewind(fp): riporta il cursore all’inizio del file (equivale a fseek(fp, 0, SEEK_SET)).

Controllare il risultato delle operazioni sui file

Elaboriamo un record binario soltanto se fread(&record, sizeof record, 1, fp) == 1. Se la lettura si ferma, ferror(fp) segnala un errore del flusso. feof(fp) indica che una lettura ha raggiunto la fine. Un ultimo record parziale va gestito come formato incompleto quando il formato richiede record interi. Per riconoscerlo, leggiamo byte con fread(buf, 1, dimensione_record, fp) e controlliamo il numero effettivo, prima di interpretare il contenuto.

Controlliamo anche il valore restituito da fwrite e il risultato di fclose su un file in scrittura. Un errore può comparire soltanto quando si svuota il buffer. Se il file deve essere scambiato tra ambienti diversi, specifichiamo come codificare ogni campo. La rappresentazione binaria di una struct dipende da padding, dimensioni dei tipi e ordine dei byte.


Esempi guidati

Esempio 1: Lettura di numeri da un file di testo e scrittura di statistiche su un altro file

Leggiamo tutti i voti presenti in voti.txt e scriviamo il conteggio e la media in report.txt.

#include <stdio.h>
 
int main(void) {
    FILE *in = fopen("voti.txt", "r");
    if (in == NULL) {
        perror("Errore apertura voti.txt");
        return 1;
    }
 
    int voto;
    int somma = 0;
    int cont = 0;
 
    /* Ciclo di lettura CORRETTO senza usare feof! */
    while (fscanf(in, "%d", &voto) == 1) {
        somma += voto;
        cont++;
    }
    fclose(in); /* Chiudiamo subito il file di input */
 
    FILE *out = fopen("report.txt", "w");
    if (out == NULL) {
        perror("Errore apertura report.txt");
        return 1;
    }
 
    if (cont > 0) {
        fprintf(out, "Esami registrati: %d\nMedia aritmetica: %.2f\n",
                cont, (double)somma / cont);
    } else {
        fprintf(out, "Nessun voto presente nel file.\n");
    }
 
    fclose(out);
    return 0;
}

Esempio 2: Salvataggio e rilettura ad accesso diretto (fseek) di struct su File Binario

Salviamo un vettore di 3 strutture Prodotto in un file binario catalogo.bin, e poi leggiamo direttamente il secondo prodotto (indice 1) saltando il primo grazie a fseek!

#include <stdio.h>
 
typedef struct {
    int id;
    char nome[20];
    double prezzo;
} Prodotto;
 
int main(void) {
    Prodotto elenco[3] = {
        {1, "Tastiera", 45.00},
        {2, "Mouse",    25.50},
        {3, "Monitor", 199.90}
    };
 
    /* 1. Scrittura binaria dell'intero array di 3 strutture */
    FILE *fp = fopen("catalogo.bin", "wb");
    if (fp == NULL) return 1;
    fwrite(elenco, sizeof(Prodotto), 3, fp);
    fclose(fp);
 
    /* 2. Riapertura in lettura binaria e salto diretto al record di indice 1 ("Mouse") */
    fp = fopen("catalogo.bin", "rb");
    if (fp == NULL) return 1;
 
    /* Ci spostiamo di 1 * sizeof(Prodotto) byte dall'inizio del file (SEEK_SET) */
    fseek(fp, 1L * (long)sizeof(Prodotto), SEEK_SET);
 
    Prodotto letto;
    if (fread(&letto, sizeof(Prodotto), 1, fp) == 1) {
        printf("Record letto direttamente: ID=%d, Nome=%s, Prezzo=%.2f\n",
               letto.id, letto.nome, letto.prezzo);
    }
 
    fclose(fp);
    return 0;
}

Errori frequenti

Errori da evitare

  1. Aprire un file importante con "w" quando si voleva solo leggere ("r") o aggiungere in fondo ("a")
    La modalità "w" distrugge istantaneamente tutto il contenuto preesistente del file nel momento stesso in cui viene eseguita fopen!
  2. Usare while (!feof(fp)) come guardia del ciclo di lettura
    Come dimostrato sopra, causa l’elaborazione duplicata dell’ultimo record. Controlla sempre il valore restituito da fscanf, fgets, fgetc o fread.
  3. Dimenticare fclose(fp) o chiudere un puntatore fp che vale NULL
    Chiamare fclose(NULL) quando fopen è fallita ha comportamento indefinito. Controlla sempre prima if (fp == NULL) return 1;.

Esercizi di prova

Esercizio 1. Modalità di apertura di fopen (Base)

Indica quale stringa di modalità ("r", "w", "a", "rb", "r+", ecc.) bisogna passare a fopen in ciascuno dei seguenti scenari:
a) Aggiungere una riga di log in fondo a un file di testo eventi.log senza cancellare i log precedenti (creando il file se non esiste).
b) Leggere un array di double salvato in formato binario dal file misure.dat.
c) Leggere e modificare sul posto alcuni record di un file binario archivio.bin già esistente senza cancellarne il contenuto all’apertura.

Esercizio 2. Copia di un file carattere per carattere (Base)

Scrivi un programma C che copi interamente il contenuto del file origine.txt in un nuovo file copia.txt leggendo un carattere alla volta con fgetc e scrivendolo con fputc, controllando correttamente gli errori di apertura.

Esercizio 3. Conteggio delle righe di un file di testo con fgets (Intermedio)

Scrivi una funzione int conta_righe_file(const char *nome_file) che apra in lettura il file indicato, conti quante righe contiene usando fgets (assumendo righe di lunghezza massima 255 caratteri), chiuda il file e restituisca il numero di righe (oppure -1 se il file non può essere aperto).

Esercizio 4. Calcolo della dimensione in byte di un file con fseek e ftell (Intermedio)

Scrivi una funzione long dimensione_file(const char *nome_file) che determini e restituisca il numero totale di byte di un file qualsiasi posizionando il cursore alla fine del file con fseek e interrogandolo con ftell (o -1 in caso di errore).

Esercizio 5. Filtro da file di testo strutturato a righe (Avanzato)

Un file di testo studenti.txt contiene su ogni riga: matricola cognome voto (es. 10425 Rossi 28).
Scrivi una funzione int salva_promossi(const char *file_in, const char *file_out, int voto_minimo) che legga tutte le righe di file_in con fscanf, scriva in file_out solo gli studenti con voto >= voto_minimo e restituisca il numero di studenti salvati (o -1 in caso di errore di apertura file).

Esercizio 6. Aggiornamento in-place di un record in un file binario con r+b e fseek (Avanzato)

Un file binario conti.bin contiene una sequenza di strutture typedef struct { int id_conto; double saldo; } Conto;.
Scrivi una funzione int accredita_su_conto(const char *nome_file, int indice_record, double importo) che apra il file in modalità "r+b", salti direttamente al record di posizione indice_record (), lo legga con fread, aggiunga importo al campo saldo e riscriva il record aggiornato esattamente nella stessa posizione sul file!


Provenienza del materiale

  • Dispensa ufficiale del corso: C1PROG1U3L6-Dispensa_Stream.pdf (Unità 3, Lezione 6a — Gestione di file di testo e binari e astrazione di Stream in C).
  • WG14, bozza C11 N1570, §§ 7.21.5.1, 7.21.8.1–7.21.8.2 e 7.21.10.