File

1
INFORMATICAI file
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.

3
File

• In C i periferici sono visti come streams, cioè
  sequenze di byte che fluiscono verso il programma
  (input streams) o vengono generati dal programma
  (output streams).
• In particolare in C risultano predefiniti alcuni
  valori ai quali fanno riferimento diretto le
  funzioni di I/O 
• stdin periferico standard di input (associato
  alla tastiera)
• stdout periferico standard di output (associato
  al monitor)
• stderr periferico su cui inviare i messaggi
  derrore (generalmente associato al monitor).

4
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).

5
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 di fine 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.

6
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.

7
Funzione fopen

• Per questo, prima di chiamare la fopen, occorre
  dichiarare un puntatore 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")

8
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

9
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.

10
Funzione fopen

• Esempio di apertura di un file
•  
• 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)
• fprintf (stderr, "Errore apertura MIOFILE.DAT
  in input\n")
• / oppure printf ( Errore apertura MIOFILE.DAT
  in input \n) /
• else
• / apertura completata con successo ora si
  può operare sul file /
• .........................

11
Funzione fclose

• Al termine delle operazioni, è necessario che il
  file venga chiuso 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.

12
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 e chiusura 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).

13
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.).

14
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 stringa tipo_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.

15
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 /

16
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.

17
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)!

18
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 ltstdio.hgt
• include ltstdlib.hgt
• define NUM_DATI 10
•  
• main()
• int dato, ndati
• FILE fdati
• char nomefile50
•  
• printf (\nIntroduci il nome del file ")
• scanf ("s", nomefile)

19
Esempio

• if ((fdati fopen (nomefile, "w")) NULL)
  / crea il file /
• printf ("\nErrore apertura del file s",
  nomefile)
• exit (0)
•  
• for (dato 1 dato lt 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 /

20
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 /

21
Schema generale di apertura di un file

• Spesso nei programmi deve essere elaborato più di
  un file. Lo schema proposto in precedenza (a
  proposito della fopen) per lapertura potrebbe in
  qualche caso risultare scomodo.
• Ricordando che il main in definitiva è una
  funzione (lunica che può avere quel nome),
  possiamo strutturare lapertura nel modo
  seguente
• FILE inp_file /
  dichiarazione del puntatore al file /
• ...........................
• if ((inp_file fopen (nomefile, "r") NULL)
• printf (\nErrore in apertura di s,
  nomefile)
• exit (0)
• / apertura completata con successo ora si
  può operare sul file /

22
Schema generale di lettura da file

• Le lettura di un file è in genere regolata
  mediante un ciclo
• leggi un dato dal file
• finché (non è finito il file )
• processa il dato
• leggi un dato dal file
• La condizione non è finito il file può essere
  realizzata in vari modi
• usando i valori restituiti dalle funzioni di
  input
• usando feof.

23
Schema di lettura da file

• Lettura di un file formattato (es. un intero per
  riga).

while ( !feof (fp)) fscanf (fp,
d, val) elabora il dato (val)
res fscanf (fp, d, val) while (res !
EOF) elabora il dato (val)
res fscanf (fp, d, val)
24
Lettura da file

• 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
• In questo modo non è necessario eseguire una
  lettura preventiva prima di entrare nel ciclo!

25
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

diff.dat
estremi.dat
-9 -9 13 18 1
23 32 2 11 19 6 23 5 3 2
26
Esempio

• include ltstdio.hgt
• int main()
• FILE fpin, fpout
• int x, y
• / apertura del primo file
  /
• if ((fpin fopen (estremi.dat, r))
  NULL)
• fprintf (stderr, Errore nellapertura di
  estremi.dat\n)
• exit (0)

27
Esempio

• / apertura del secondo file /
• if (( fpout fopen (diff.dat, w)) NULL)
  
• fprintf (stderr, Errore nellapertura di
  diff.dat\n)
• exit (1)
• while ( fscanf (fpin, dd, x, y) ! EOF)
• / ora ho a disposizione x e y
  /
• fprintf (fpout, d\n, x - y)
• fclose (fpin)
• fclose (fpout)

28
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.

29
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 della scrittura 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.)