+La funzione esegue lo scarico dei dati bufferizzati in uscita e scarta quelli
+in ingresso, chiudendo tutti i file. Questa funzione è provvista solo per i
+casi di emergenza, quando si è verificato un errore ed il programma deve
+essere abortito, ma si vuole compiere qualche altra operazione dopo aver
+chiuso i file e prima di uscire (si ricordi quanto visto in
+sez.~\ref{sec:proc_conclusion}).
+
+
+\subsection{Gestione dell'I/O e posizionamento su uno \textit{stream}}
+ \label{sec:file_io}
+
+ Una delle caratteristiche più utili dell'interfaccia degli \textit{stream} è
+ la ricchezza delle funzioni disponibili per le operazioni di lettura e
+ scrittura sui file. Sono infatti previste ben tre diverse modalità modalità di
+ input/output non formattato:
+ \begin{itemize}
+ \item\textsl{binario} in cui si leggono e scrivono blocchi di dati di
+ dimensione arbitraria, (analogo della modalità ordinaria dell'I/O sui file
+ descriptor), trattato in sez.~\ref{sec:file_binary_io}.
+ \item\textsl{a caratteri} in cui si legge e scrive un carattere alla volta,
+ con la bufferizzazione che viene gestita automaticamente dalla libreria,
+ trattato in sez.~\ref{sec:file_char_io}.
+ \item\textsl{di linea} in cui si legge e scrive una linea alla volta,
+ (terminata dal carattere di newline \verb|'\n'|), trattato in
+ sez.~\ref{sec:file_line_io}.
+ \end{itemize}
+ a cui si aggiunge la modalità di input/output formattato, trattato in
+ sez.~\ref{sec:file_formatted_io}.
+
+ Ognuna di queste modalità utilizza per l'I/O delle funzioni specifiche che
+ vedremo nelle sezioni citate, affronteremo qui tutte gli argomenti e le
+ funzioni che si applicano in generale a tutte le modalità di I/O.
+
+ A differenza di quanto avviene con l'interfaccia dei file descriptor, con gli
+ \textit{stream} il raggiungimento della fine del file viene considerato un
+ errore, e viene notificato come tale dai valori di uscita delle varie
+ funzioni. Nella maggior parte dei casi questo avviene con la restituzione del
+ valore intero (di tipo \ctyp{int}) \val{EOF} definito anch'esso nell'header
+ \headfile{stdlib.h}. La costante deve essere negativa perché in molte
+ funzioni un valore positivo indica la quantità di dati scritti, le
+ \acr{glibc} usano il valore $-1$, ma altre implementazioni possono avere
+ valori diversi.
+
+ Dato che le funzioni dell'interfaccia degli \textit{stream} sono funzioni di
+ libreria che si appoggiano a delle \textit{system call}, esse non impostano
+ direttamente la variabile \var{errno}, che mantiene sempre il valore
+ impostato dalla \textit{system call} invocata internamente che ha riportato
+ l'errore.
+
+ Siccome la condizione di \textit{end-of-file} è anch'essa segnalata come
+ errore, nasce il problema di come distinguerla da un errore effettivo;
+ basarsi solo sul valore di ritorno della funzione e controllare il valore di
+ \var{errno} infatti non basta, dato che quest'ultimo potrebbe essere stato
+ impostato in una altra occasione, (si veda sez.~\ref{sec:sys_errno} per i
+ dettagli del funzionamento di \var{errno}).
+
+ Per questo motivo tutte le implementazioni delle librerie standard mantengono
+ per ogni \textit{stream} almeno due flag all'interno dell'oggetto \type{FILE},
+ il flag di \textit{end-of-file}, che segnala che si è raggiunta la fine del
+ file in lettura, e quello di errore, che segnala la presenza di un qualche
+ errore nelle operazioni di input/output; questi due flag possono essere
+ riletti dalle funzioni \funcd{feof} e \funcd{ferror}, i cui prototipi sono:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{int feof(FILE *stream)}
+\fdesc{Controlla il flag di \textit{end-of-file} di uno \textit{stream}.}
+\fdecl{int ferror(FILE *stream)}
+\fdesc{Controlla il flag di errore di uno \textit{stream}.}
+}
+
+{Le funzioni ritornano un valore diverso da zero se i relativi flag sono
+ impostati, e non prevedono condizioni di errore.}
+\end{funcproto}
+
+Si tenga presente comunque che la lettura di questi flag segnala soltanto che
+c'è stato un errore o che si è raggiunta la fine del file in una qualunque
+operazione sullo \textit{stream}, il controllo su quanto avvenuto deve quindi
+essere effettuato ogni volta che si chiama una funzione di libreria.
+
+Entrambi i flag (di errore e di \textit{end-of-file}) possono essere
+cancellati usando la funzione \funcd{clearerr}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{void clearerr(FILE *stream)}
+\fdesc{Cancella i flag di errore ed \textit{end-of-file} di uno
+ \textit{stream}.}
+}
+
+{La funzione non ritorna nulla e prevede condizioni di errore.}
+\end{funcproto}
+
+In genere si usa questa funzione una volta che si sia identificata e corretta
+la causa di un errore per evitare di mantenere i flag attivi, così da poter
+rilevare una successiva ulteriore condizione di errore. Di questa funzione
+esiste una analoga \funcm{clearerr\_unlocked} (con lo stesso argomento e
+stessi valori di ritorno) che non esegue il blocco dello \textit{stream}
+(tratteremo il significato di blocco di uno \textit{stream} in
+sez.~\ref{sec:file_stream_thread}).
+
+Come per i file descriptor anche per gli \textit{stream} è possibile spostarsi
+all'interno di un file per effettuare operazioni di lettura o scrittura in un
+punto prestabilito, sempre che l'operazione di riposizionamento sia supportata
+dal file sottostante lo \textit{stream}, nel caso cioè in cui si ha a che
+fare con quello che viene detto un file ad \textsl{accesso casuale}. Dato che
+in un sistema Unix esistono vari tipi di file, come le fifo ed i
+\index{file!di~dispositivo} file di dispositivo (ad esempio i terminali), non
+è scontato che questo sia vero in generale, pur essendolo sempre nel caso di
+file di dati.
+
+Con Linux ed in generale in ogni sistema unix-like la posizione nel file, come
+abbiamo già visto in sez.~\ref{sec:file_lseek}, è espressa da un intero
+positivo, rappresentato dal tipo \type{off\_t}. Il problema è che alcune delle
+funzioni usate per il riposizionamento sugli \textit{stream} originano dalle
+prime versioni di Unix, in cui questo tipo non era ancora stato definito, e
+che in altri sistemi non è detto che la posizione su un file venga sempre
+rappresentata con il numero di caratteri dall'inizio: ad esempio nel VMS dove
+esistono i file a record (in cui cioè l'I/O avviene per blocchi, i record, di
+dimensione fissa), essa può essere rappresentata come un numero di record, più
+l'offset rispetto al record corrente.
+
+Tutto questo comporta la presenza di diverse funzioni che eseguono
+sostanzialmente le stesse operazioni, ma usano argomenti di tipo diverso. Le
+funzioni tradizionali usate per eseguire una modifica della posizione corrente
+sul file con uno \textit{stream} sono \funcd{fseek} e \funcd{rewind}, i
+rispettivi prototipi sono:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{int fseek(FILE *stream, long offset, int whence)}
+\fdesc{Sposta la posizione nello \textit{stream}.}
+\fdecl{void rewind(FILE *stream)}
+\fdesc{Riporta la posizione nello \textit{stream} all'inizio del file.}
+}
+
+{La funzione \func{fseek} ritorna $0$ in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà i valori di \func{lseek},
+ \func{rewind} non ritorna nulla e non ha condizioni di errore.}
+\end{funcproto}
+
+L'uso di \func{fseek} è del tutto analogo a quello di \func{lseek} per i file
+descriptor (vedi sez.~\ref{sec:file_lseek}). Anche gli argomenti, a parte il
+tipo, hanno esattamente lo stesso significato. In particolare \param{whence}
+deve assumere gli stessi valori già visti nella prima parte di
+tab.~\ref{tab:lseek_whence_values}. La funzione restituisce 0 in caso di
+successo e -1 in caso di errore.
+
+La funzione \func{rewind} riporta semplicemente la posizione corrente sul file
+all'inizio dello \textit{stream}, ma non è esattamente equivalente ad aver
+eseguito una \code{fseek(stream, 0L, SEEK\_SET)}, in quanto con l'uso della
+funzione vengono cancellati anche i flag di errore e di fine del file.
+
+Per ottenere la posizione corrente sul file di uno \textit{stream} lo standard
+ANSI C prescrive l'uso della funzione \funcd{ftell}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{long ftell(FILE *stream)}
+\fdesc{Legge la posizione attuale nello \textit{stream}.}
+}
+
+{La funzione ritorna la posizione corrente in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà i valori di \func{lseek}.}
+\end{funcproto}
+
+\noindent che restituisce la posizione come numero di byte dall'inizio dello
+\textit{stream}.
+
+Sia \func{fseek} che \func{ftell} esprimono la posizione nel file con un
+intero di tipo \ctyp{long}. Dato che in certi casi, ad esempio quando si usa
+un filesystem indicizzato a 64 bit su una macchina con architettura a 32 bit,
+questo può non essere possibile lo standard POSIX ha introdotto le nuove
+funzioni \funcd{fgetpos} e \funcd{fsetpos}, che invece usano il nuovo tipo
+\type{fpos\_t}, ed i cui prototipi sono:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{int fsetpos(FILE *stream, fpos\_t *pos)}
+\fdesc{Imposta la posizione corrente sul file.}
+\fdecl{int fgetpos(FILE *stream, fpos\_t *pos)}
+\fdesc{Legge la posizione corrente sul file.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà i valori di \func{lseek}.}
+\end{funcproto}
+
+In Linux, a partire dalle glibc 2.1, sono presenti anche le due funzioni
+\func{fseeko} e \func{ftello}, che sono assolutamente identiche alle
+precedenti \func{fseek} e \func{ftell} ma hanno argomenti di tipo
+\type{off\_t} anziché di tipo \ctyp{long int}. Dato che \ctyp{long} è nella
+gran parte dei casi un intero a 32 bit, questo diventa un problema quando la
+posizione sul file viene espressa con un valore a 64 bit come accade nei
+sistemi più moderni.
+
+% TODO: mettere prototipi espliciti fseeko e ftello o menzione?
+
+
+
+\subsection{Input/output binario}
+\label{sec:file_binary_io}
+
+La prima modalità di input/output non formattato ricalca quella della
+interfaccia dei file descriptor, e provvede semplicemente la scrittura e la
+lettura dei dati da un buffer verso un file e viceversa. In generale questa è
+la modalità che si usa quando si ha a che fare con dati non formattati. Le due
+funzioni che si usano per l'I/O binario sono \funcd{fread} ed \funcd{fwrite};
+i rispettivi prototipi sono:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{size\_t fread(void *ptr, size\_t size, size\_t nmemb, FILE *stream)}
+\fdesc{Legge i dati da uno \textit{stream}.}
+\fdecl{size\_t fwrite(const void *ptr, size\_t size, size\_t nmemb,
+ FILE *stream)}
+\fdesc{Scrive i dati su uno \textit{stream}.}
+}
+
+{Le funzioni ritornano il numero di elementi letti o scritti, in caso di
+ errore o fine del file viene restituito un numero di elementi inferiore al
+ richiesto.}
+\end{funcproto}
+
+Le funzioni rispettivamente leggono e scrivono \param{nmemb} elementi di
+dimensione \param{size} dal buffer \param{ptr} al file \param{stream}. In
+genere si usano queste funzioni quando si devono trasferire su file blocchi di
+dati binari in maniera compatta e veloce; un primo caso di uso tipico è quello
+in cui si salva un vettore (o un certo numero dei suoi elementi) con una
+chiamata del tipo:
+\includecodesnip{listati/WriteVect.c}
+in questo caso devono essere specificate le dimensioni di ciascun
+elemento ed il numero di quelli che si vogliono scrivere. Un secondo
+caso è invece quello in cui si vuole trasferire su file una struttura;