INFORMATICA I file

© Piero Demichelis 2 File Per rendere più uniforme possibile il comportamento dei programmi in relazione alla grande varietà dei dispositivi periferici, i linguaggi moderni fanno riferimento ad un modello: i periferici sono visti come file o flusso sequenziale, cioè come una struttura dati. Tuttavia nellaccezione più comune del termine il file è un archivio di dati memorizzato su un dispositivo periferico, normalmente il disco magnetico. Un file è una sequenza, teoricamente illimitata, di componenti tutti dello stesso tipo. E una struttura ad accesso sequenziale: per accedere all'n-esimo elemento occorre accedere prima agli n-1 elementi che lo precedono.

© Piero Demichelis 3 File I file si distinguono in due categorie: file di tipo testo e file binari. Nei file di tipo testo i dati, che allinterno dell'elaboratore sono codificati in binario, vengono trasferiti all'esterno come sequenze di caratteri, dopo aver subito una conversione (da floating point a decimale, da complemento a 2 a decimale, ecc.). Nei file binari i dati sono trasferiti all'esterno come pacchetti di bit senza alcuna manipolazione (i dati sono pertanto unimmagine perfetta della loro rappresentazione in memoria).

© Piero Demichelis 4 File Mentre i file di tipo testo si possono visualizzare e stampare, i file binari si possono solo conservare e rileggere. Nei file di tipo testo sono previste informazioni esplicite difine linea (new-line, lo stesso carattere utilizzato per loutput sul monitor) e di fine file (end-of-file) Sostanzialmente scrivere su un file di tipo testo è assai simile a scrivere sul monitor così come leggere da un file di testo corrisponde a leggere da tastiera.

© Piero Demichelis 5 Funzione fopen Per poter operare sui file, siano essi dispositivi periferici o file su disco, occorre instaurare una connessione che renda possibile la comunicazione tra programma e file: questa predisposizione è detta apertura del file. Lo standard del C prevede che gli stream standard (stdin, stdout, stderr ) siano sempre predisposti e non necessitino quindi di essere aperti. Gli altri file possono essere utilizzati solo dopo averli aperti mediante la funzione di libreria fopen la quale effettua l'aggancio con il file e restituisce un certo numero di informazioni inerenti il file stesso, in una struttura dati a cui si può accedere tramite un puntatore.

© Piero Demichelis 6 Funzione fopen Per questo, prima di chiamare la fopen, occorre dichiarare unpuntatore al file, utilizzando una struttura predefinita in stdio.h come nel seguente esempio: FILE *miofile; dove miofile è un puntatore ad un file. FILE deve essere scritto in maiuscolo: in realtà si tratta di una struttura definita nel file stdio.h. La chiamata della fopen ha la seguente forma: fopen ("nome_file ", "tipo_apertura");

© Piero Demichelis 7 Funzione fopen nome_file è una stringa contenente il nome del file nel formato richiesto dal sistema che si utilizza (ad esempio, per MSDOS è un nome preceduto dal path, come "C:\\WORK\\MIOFILE.DAT", dove il doppio backslash è la notazione richiesta dal C per il singolo backslash); tipo_apertura è una stringa che specifica il tipo di azioni che si vogliono compiere sul file e può assumere i valori seguenti: r : apre un file già esistente in lettura (for reading). w : crea ed apre un file in scrittura (for writing): se il file non esiste, lo crea; se esiste, lo rimpiazza (attenzione: il contenuto del file precedente viene irrimediabilmente perso); a : apre un file per aggiungere dati (for appending): i dati vengono aggiunti in coda ad un file esistente oppure viene creato un nuovo file;

© Piero Demichelis 8 Funzione fopen r+ : apre un file in lettura e scrittura; w+ : crea ed apre un file in lettura e scrittura: se il file esiste già, viene rimpiazzato; a+ : apre un file per leggere ed aggiungere: i dati vengono aggiunti in coda ad un file esistente oppure viene creato un nuovo file. La fopen restituisce l'indirizzo di una struttura di tipo FILE (puntatore al file ) se l'operazione è andata bene; se invece si è verificato qualche inconveniente (file inesistente, disco protetto in scrittura, disco pieno, ecc.), restituisce un puntatore con valore NULL.

© Piero Demichelis 9 Funzione fopen Esempio di apertura di un file (in lettura): FILE *inp_file; /* dichiarazione del puntatore al file */ /* apertura: se capita errore scrive il messaggio su stderr */ if ((inp_file = fopen("C:\\WORK\\MIOFILE.DAT", "r")) == NULL) { printf (\nErrore apertura MIOFILE.DAT in input"); exit (0); /* Interrompi il programma */ } /* apertura completata con successo: ora si può operare sul file */

© Piero Demichelis 10 Funzione fclose Al termine delle operazioni, è necessario che il file vengachiuso: si utilizza per questa operazione la funzione fclose che ha come parametro il puntatore al file. Sintassi: fclose (puntatore); puntatore : puntatore al file aperto in precedenza con la fopen La fclose restituisce un valore intero pari a 0 se la chiusura è avvenuta correttamente, pari a EOF in caso di errore.

© Piero Demichelis 11 Funzione fclose Questa funzione non solo libera la struttura che era stata creata per immagazzinare le informazioni relative a quel file, ma effettua le operazioni di completamento echiusura del file. Le operazioni di completamento assumono rilevanza quando il file è in scrittura: infatti le operazioni fisiche di scrittura dei dati non vengono eseguite immediatamente: i dati vengono prima immagazzinati in appositi buffer di memoria gestiti dal sistema operativo. Il trasferimento al dispositivo esterno avviene solo quando in questi buffer si forma almeno un blocco completo di dati da scrivere (ad esempio un settore del disco).

© Piero Demichelis 12 Funzione fclose Può succedere che quando il programma completa le operazioni di scrittura sul file siano ancora presenti in memoria (nei buffer) dei dati che devono essere trasferiti sul disco prima di poter chiudere definitivamente il file fisico. Questa operazione è nota col termine di flush del file: la funzione fclose svolge appunto questo compito. Le vere e proprie operazioni di chiusura del file sono demandate al sistema operativo (registrazione del file nel proprio direttorio, rilascio del file se era bloccato, ecc.).

© Piero Demichelis 13 Lettura e scrittura di file di testo Quando nella fopen manca l'esplicita richiesta che il file sia di tipo binario (aggiunta della lettera b nella stringatipo_apertura ), il file viene aperto by default di tipo testo. Per leggere e scrivere sui dispositivi non standard, quelli cioè che devono essere aperti con la fopen, e quindi, ovviamente, sui file residenti su disco, si devono usare funzioni con lo stesso nome di quelle degli standard streams ma precedute dalla lettera f. Pertanto a scanf corrisponde fscanf, a printf corrisponde fprintf, ecc. Occorre inoltre specificare il puntatore al file su cui devono operare.

© Piero Demichelis 14 Formato delle funzioni di I/O su file inp_file = fopen (nome, r); /* apertura in lettura */ out_file = fopen (nome, w); /* apertura in scrittura */ fscanf (inp_file, format", lista variabili); /* lettura da inp_file */ fprintf (out_file, format, lista variabili); /* scrittura su out_file */ carattere = fgetc (inp_file); /* lettura di un carattere da inp_file */ fputc (carattere, out_file); /* scrittura di un carattere su out_file */ fgets (stringa, n, inp_file); /* legge una riga (fino a n car.) in stringa */ fputs (stringa, out_file); /* scrive stringa in out_file */ fclose (inp_file); fclose (out_file); /* chiusura dei file */

© Piero Demichelis 15 Funzione feof Nella lettura di un file, spesso non si conosce con precisione quanti dati contiene. Daltra parte un tentativo di lettura oltre la fine del file (oltre lultimo record) provoca un errore irrimediabile e il programma viene interrotto. E necessario dunque sapere quando ci si deve fermare nella lettura, ovvero quando si sta leggendo lultimo record. A questo scopo il C possiede la funzione feof (puntatore) che restituisce il valore vero quando il puntatore è posizionato sullEOF, falso in caso contrario.

© Piero Demichelis 16 Funzioni di I/O su file Tutte le funzioni che operano su file richiedono ovviamente il puntatore al file. Queste funzioni si comportano alla stessa stregua di quelle operanti sugli standard streams, anche nei confronti dei fine linea e fine file. Non deve trarre in inganno il fatto che il linguaggio tratti le informazioni di fine linea e di fine file come caratteri: ad esempio, non è detto che per tutti i sistemi operativi la terminazione dei file di tipo testo sia costituita proprio da un carattere. Per questo motivo queste informazioni sono state definite con valori simbolici (EOF, \n)!

© Piero Demichelis 17 Esempio Esempio: programma che richiede il nome di un file, lo crea, lo riempie con i valori interi da 1 a 10 (uno per record) e successivamente ne visualizza il contenuto. #include #define NUM_DATI 10 main() { int dato, ndati; FILE *fdati; char nomefile[50]; printf (\nIntroduci il nome del file: "); scanf ("%s", nomefile);

© Piero Demichelis 18 Esempio if ((fdati = fopen (nomefile, "w")) == NULL) /* crea il file */ { printf ("\nErrore apertura del file %s", nomefile); exit (0); } for (dato = 1; dato <= NUM_DATI; dato++) { fprintf (fdati, "%d", dato); /* scrive un dato nel file */ if (dato != NUM_DATI) /* \n per tutte le righe tranne lultima */ fprintf (fdati, "\n"); } fclose (fdati); /* chiude il file */

© Piero Demichelis 19 Esempio printf ("\nVisualizza il contenuto del file\n"); if ((fdati = fopen (nomefile, "r")) == NULL) /* apre il file */ { printf ("\nErrore apertura del file %s", nomefile); exit (1); } while (!feof (fdati)) /* Finché non si raggiunge EOF */ { fscanf (fdati, "%d", &dato); /* legge un dato dal file */ printf ("%d\n", dato); /* visualizza il dato sul monitor */ } fclose (fdati); /* chiude il file */ }

© Piero Demichelis 20 Schema generale di lettura da file Le lettura di un file è in genere regolata mediante un ciclo: finché (non è finito il file ) { leggi un dato dal file; processa il dato; } La condizione non è finito il file può essere realizzata in vari modi: ­ usando i valori restituiti dalle funzioni di input; ­ usando feof.

© Piero Demichelis 21 Schema di lettura da file Lettura di un file formattato (es. un intero per riga). res = fscanf (fp, %d, &val); while (res != EOF) { elabora il dato (val) res = fscanf (fp, %d, val); } while ( !feof (fp)) { fscanf (fp, %d, &val); elabora il dato (val) } Sfruttando il fatto che fscanf restituisce il numero di valori letti correttamente è possibile usare quale condizione del while direttamente la funzione o, meglio, il valore che la funzione restituisce, così: while ( fscanf (fp, %d, &val) != EOF ) elabora val;

© Piero Demichelis 22 Esempio Nel file estremi.dat sono registrate coppie di numeri interi (x, y), una per riga. Leggere le coppie di numeri e scrivere in un secondo file diff.dat le differenze (x – y), una per riga. Esempio: … … estremi.dat diff.dat

© Piero Demichelis 23 Esempio #include int main() { FILE *fpin, *fpout; int x, y; /* apertura del primo file */ if ((fpin = fopen (estremi.dat, r)) == NULL) { printf (Errore nellapertura di estremi.dat\n); exit (0); }

© Piero Demichelis 24 Esempio /* creazione del secondo file */ if (( fpout = fopen (diff.dat, w)) == NULL) { printf (\nErrore nella creazione di diff.dat); exit (1); } while ( fscanf (fpin, %d%d, &x, &y) != EOF) { /* ora ho a disposizione x e y */ fprintf (fpout, %d\n, x - y); } fclose (fpin); fclose (fpout); }

© Piero Demichelis 25 Avvertenza E in generale sbagliato tentare di memorizzare il contenuto di un file in un vettore. La dimensione (numero di righe o di dati) di un file non è quasi mai nota a priori e un file è, per definizione, una sequenza illimitata di dati. Tuttavia, anche se la dimensione è nota, tipicamente è molto grande.

© Piero Demichelis 26 Scrittura di un file La struttura di scrittura di un file non è diversa dalla struttura di lettura: si tratterà tipicamente di un ciclo che scrive un certo numero di dati ad ogni iterazione. Non è necessario scrivere EOF. Infatti la marca di EOF è automaticamente scritta dal linguaggio alla fine del record corrente. E invece importante il formato dei dati. Se si scrive un file è perché prima o poi si desidera rileggerlo! Occorre dunque che i dati siano scritti in modo compatibile con le istruzioni di lettura (ad esempio inserire almeno uno spazio tra un dato e il successivo, ecc.)