1 \chapter{I file: l'interfaccia standard ANSI C}
2 \label{cha:files_std_interface}
4 Esamineremo in questo capitolo l'interfaccia standard ANSI C per i file,
5 quella che viene comunemente detta interfaccia degli \textit{stream}. Dopo
6 una breve sezione introduttiva tratteremo le funzioni base per la gestione
7 dell'input/output, mentre tratteremo le caratteristiche più avanzate
8 dell'interfaccia nell'ultima sezione.
11 \section{Introduzione}
12 \label{sec:file_stream_intro}
14 Come visto in \capref{cha:file_unix_interface} le operazioni di I/O sui file
15 sono gestibili a basso livello con l'interfaccia standard unix, che ricorre
16 direttamente alle system call messe a disposizione dal kernel.
18 Questa interfaccia però non provvede le funzionalità previste dallo standard
19 ANSI C, che invece sono realizzate attraverso opportune funzioni di libreria,
20 queste, insieme alle altre funzioni definite dallo standard, vengono a
21 costituire il nucleo\footnote{queste funzioni sono state implementate la prima
22 volta da Ritchie nel 1976 e da allora sono rimaste sostanzialmente
23 immutate.} delle \acr{glibc}.
26 \subsection{I \textit{file stream}}
27 \label{sec:file_stream}
29 Come più volte ribadito l'interfaccia dei file descriptor è una interfaccia di
30 basso livello, che non provvede nessuna forma di formattazione dei dati e
31 nessuna forma di bufferizzazione per ottimizzare le operazioni di I/O.
33 In \textit{Advanced Programming in the Unix Environment} Stevens descrive una
34 serie di test sull'influenza delle dimensioni del blocco di dati (il parametro
35 \param{buf} di \func{read} e \func{write}) nell'efficienza nelle operazioni di
36 I/O con i file descriptor, evidenziando come le prestazioni ottimali si
37 ottengano a partire da dimensioni del buffer dei dati pari a quelle dei
38 blocchi del filesystem (il valore dato dal campo \var{st\_blksize} di
41 Se il programmatore non si cura di effettuare le operazioni in blocchi di
42 dimensioni adeguate, le prestazioni sono inferiori. La caratteristica
43 principale dell'interfaccia degli stream è che essa provvede da sola alla
44 gestione dei dettagli della bufferizzazione e all'esecuzione delle operazioni
45 di lettura e scrittura in blocchi di dimensioni appropriate all'ottenimento
46 della massima efficienza.
48 Per questo motivo l'interfaccia viene chiamata anche interfaccia dei
49 \textit{file stream}, dato che non è più necessario doversi preoccupare
50 dei dettagli della comunicazione con il tipo di hardware sottostante
51 (come nel caso della dimensione dei blocchi del filesystem), ed un file
52 può essere sempre considerato come composto da un flusso continuo (da
53 cui il nome \textit{stream}) di dati.
55 A parte i dettagli legati alla gestione delle operazioni di lettura e
56 scrittura (sia per quel che riguarda la bufferizzazione, che le
57 formattazioni), i file stream restano del tutto equivalenti ai file descriptor
58 (sui quali sono basati), ed in particolare continua a valere quanto visto in
59 \secref{sec:file_sharing} a proposito dell'accesso condiviso ed in
60 \secref{sec:file_access_control} per il controllo di accesso.
63 \subsection{Gli oggetti \type{FILE}}
66 Per ragioni storiche la struttura di dati che rappresenta uno stream è stata
67 chiamata \type{FILE}, questi oggetti sono creati dalle funzioni di libreria e
68 contengono tutte le informazioni necessarie a gestire le operazioni sugli
69 stream, come la posizione corrente, lo stato del buffer e degli indicatori di
70 stato e di fine del file.
72 Per questo motivo gli utenti non devono mai utilizzare direttamente o
73 allocare queste strutture, ma usare sempre puntatori del tipo \type{FILE
74 *} ottenuti dalla libreria stessa (tanto che in certi casi il termine
75 di puntatore a file è diventato sinonimo di stream). Tutte le funzioni
76 della libreria che operano sui file accettano come parametri solo
77 variabili di questo tipo, che diventa accessibile includendo l'header
82 \subsection{Gli stream standard}
83 \label{sec:file_std_stream}
85 Ai tre file descriptor standard (vedi \secref{sec:file_std_descr})
86 aperti per ogni processo, corrispondono altrettanti stream, che
87 rappresentano i canali standard di input/output prestabiliti; anche
88 questi tre stream sono identificabili attraverso dei nomi simbolici
89 definiti nell'header \file{stdio.h} che sono:
92 \item \var{FILE *stdin} Lo \textit{standard input} cioè lo stream da
93 cui il processo riceve ordinariamente i dati in ingresso. Normalmente
94 è associato dalla shell all'input del terminale e prende i caratteri
96 \item \var{FILE *stdout} Lo \textit{standard input} cioè lo stream su
97 cui il processo invia ordinariamente i dati in uscita. Normalmente è
98 associato dalla shell all'output del terminale e scrive sullo schermo.
99 \item \var{FILE *stderr} Lo \textit{standard input} cioè lo stream su
100 cui il processo è supposto inviare i messaggi di errore. Normalmente
101 anch'esso è associato dalla shell all'output del terminale e scrive
105 Nelle \acr{glibc} \var{stdin}, \var{stdout} e \var{stderr} sono
106 effettivamente tre variabili di tipo \type{FILE *} che possono essere
107 usate come tutte le altre, ad esempio si può effettuare una redirezione
108 dell'output di un programma con il semplice codice:
109 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
111 stdout = fopen("standard-output-file", "w");
113 ma in altri sistemi queste variabili possono essere definite da macro, e
114 se si hanno problemi di portabilità e si vuole essere sicuri, diventa
115 opportuno usare la funzione \func{freopen}.
118 \subsection{Le modalità di bufferizzazione}
119 \label{sec:file_buffering}
121 La bufferizzazione è una delle caratteristiche principali della
122 interfaccia degli stream; lo scopo è quello di ridurre al minimo il
123 numero di system call (\func{read} o \func{write}) eseguite nelle
124 operazioni di input/output. Questa funzionalità è assicurata
125 automaticamente dalla libreria, ma costituisce anche una degli aspetti
126 più comunemente fraintesi, in particolare per quello che riguarda
127 l'aspetto della scrittura dei dati sul file.
129 I caratteri che vengono scritti su uno stream normalmente vengono
130 accumulati in un buffer e poi trasmessi in blocco in maniera asincrona
131 rispetto alla scrittura (quello che viene chiamato lo \textsl{scarico}
132 dei dati, dall'inglese \textit{flush}) tutte le volte che il buffer
133 viene riempito. Un comportamento analogo avviene anche in lettura (cioè
134 dal file viene letto un blocco di dati, anche se se ne sono richiesti
135 una quantità inferiore), ma la cosa ovviamente ha rilevanza inferiore,
136 dato che i dati letti sono sempre gli stessi; in caso di scrittura
137 invece, quando si ha un accesso contemporaneo allo stesso file (ad
138 esempio da parte di un altro processo) si potranno vedere solo le parti
139 effettivamente scritte, e non quelle ancora presenti nel buffer.
141 Allo stesso modo, se si sta facendo dell'input/output interattivo
142 bisognerà tenere presente le caratteristiche delle operazioni di scarico
143 dei dati, poiché non è detto che ad una scrittura sullo stream
144 corrisponda una immediata scrittura sul dispositivo.
146 Per rispondere ad esigenze diverse, lo standard definisce tre distinte
147 modalità in cui può essere eseguita la bufferizzazione, delle quali
148 occorre essere ben consapevoli, specie in caso di lettura e scrittura da
149 dispositivi interattivi:
151 \item \textit{unbuffered}: in questo caso non c'è bufferizzazione ed i
152 caratteri vengono trasmessi direttamente al file non appena possibile
153 (effettuando immediatamente una \func{write}).
154 \item \textit{line buffered}: in questo caso i caratteri vengono
155 normalmente trasmessi al file in blocco ogni volta che viene
156 incontrato un carattere di \textit{newline} (il carattere ASCII
158 \item \textit{fully buffered}: in questo caso i caratteri vengono
159 trasmessi da e verso il file in blocchi di dimensione opportuna.
162 Lo standard ANSI C specifica inoltre che lo standard output e lo
163 standard input siano aperti in modalità \textit{fully buffered} quando
164 non fanno riferimento ad un dispositivo interattivo, e che lo standard
165 error non sia mai aperto in modalità \textit{fully buffered}.
167 Linux, come BSD e SVr4, specifica il comportamento di default in maniera
168 ancora più precisa, e cioè impone che lo standard error sia sempre
169 \textit{unbuffered} (in modo che i messaggi di errore siano mostrati il più
170 rapidamente possibile) e che standard input e standard output siano aperti in
171 modalità \textit{line buffered} quando sono associati ad un terminale (od
172 altro dispositivo interattivo) ed in modalità \textit{fully buffered}
175 Il comportamento specificato per standard input e standard output vale anche
176 per tutti i nuovi stream aperti da un processo; la selezione comunque avviene
177 automaticamente, e la libreria apre lo stream nella modalità più opportuna a
178 seconda del file o del dispositivo scelto.
180 La modalità \textit{line buffered} è quella che necessita di maggiori
181 chiarimenti e attenzioni per quel che concerne il suo funzionamento. Come già
182 accennato nella descrizione, \emph{di norma} i dati vengono inviati al kernel
183 alla ricezione di un carattere di a capo; questo non è vero in tutti i casi,
184 infatti, dato che le dimensioni del buffer usato dalle librerie sono fisse, se
185 le si eccedono si può avere uno scarico dei dati anche prima che sia stato
186 inviato un carattere di \textit{newline}.
188 Un secondo punto da tenere presente, particolarmente quando si ha a che fare
189 con I/O interattivo, è che quando si effettua una lettura su uno stream che
190 comporta l'accesso al kernel\footnote{questo vuol dire sempre se lo stream da
191 cui si legge è in modalità \textit{unbuffered}.} viene anche eseguito lo
192 scarico di tutti i buffer degli stream in scrittura.
194 In \secref{sec:file_buffering_ctrl} vedremo come la libreria definisca delle
195 opportune funzioni per controllare le modalità di bufferizzazione e lo scarico
200 \section{Funzioni base}
201 \label{sec:file_ansi_base_func}
203 Esamineremo in questa sezione le funzioni base dell'interfaccia degli stream,
204 analoghe a quelle di \secref{sec:file_base_func} per i file descriptor. In
205 particolare vedremo come aprire, leggere, scrivere e cambiare la posizione
206 corrente in uno stream.
209 \subsection{Apertura e chiusura di uno stream}
210 \label{sec:file_fopen}
212 Le funzioni che si possono usare per aprire uno stream sono solo
213 tre\footnote{\func{fopen} e \func{freopen} fanno parte dello standard
214 ANSI C, \func{fdopen} è parte dello standard POSIX.1.}, i loro
218 \funcdecl{FILE *fopen(const char *path, const char *mode)}
219 Apre il file specificato da \param{path}.
220 \funcdecl{FILE *fdopen(int fildes, const char *mode)}
221 Associa uno stream al file descriptor \param{fildes}.
222 \funcdecl{FILE *freopen(const char *path, const char *mode, FILE *stream)}
223 Apre il file specificato da \param{path} associandolo allo stream
224 specificato da \param{stream}, se questo è già aperto prima lo chiude.
226 \bodydesc{Le funzioni ritornano un puntatore valido in caso di
227 successo e \macro{NULL} in caso di errore, in tal caso \var{errno}
228 viene settata al valore ricevuto dalla funzione sottostante di cui è
229 fallita l'esecuzione.
231 Gli errori pertanto possono essere quelli di \code{malloc} per tutte
232 e tre le funzioni, quelli \func{open} per \func{fopen}, quelli di
233 \func{fcntl} per \func{fdopen} e quelli di \func{fopen},
234 \func{fclose} e \func{fflush} per \func{freopen}.}
237 Normalmente la funzione che si usa per aprire uno stream è \func{fopen},
238 essa apre il file specificato nella modalità specificata da
239 \param{mode}, che è una stringa che deve iniziare con almeno uno dei
240 valori indicati in \tabref{tab:file_fopen_mode} (sono possibili varie
241 estensioni che vedremo in seguito).
243 L'uso più comune di \func{freopen} è per redirigere uno dei tre file
244 standard (vedi \secref{sec:file_std_stream}): il file \param{path} viene
245 associato a \param{stream} e se questo è uno stream già aperto viene
246 preventivamente chiuso.
248 Infine \func{fdopen} viene usata per associare uno stream ad un file
249 descriptor esistente ottenuto tramite una altra funzione (ad esempio con
250 una \func{open}, una \func{dup}, o una \func{pipe}) e serve quando si
251 vogliono usare gli stream con file come le fifo o i socket, che non
252 possono essere aperti con le funzioni delle librerie standard del C.
256 \begin{tabular}[c]{|l|p{8cm}|}
258 \textbf{Valore} & \textbf{Significato}\\
261 \texttt{r} & Il file viene aperto, l'accesso viene posto in sola
262 lettura, lo stream è posizionato all'inizio del file.\\
263 \texttt{r+} & Il file viene aperto, l'accesso viene posto in lettura e
264 scrittura, lo stream è posizionato all'inizio del file. \\
266 \texttt{w} & Il file viene aperto e troncato a lunghezza nulla (o
267 creato se non esiste), l'accesso viene posto in sola scrittura, lo
268 stream è posizionato all'inizio del file.\\
269 \texttt{w+} & Il file viene aperto e troncato a lunghezza nulla (o
270 creato se non esiste), l'accesso viene posto in scrittura e lettura,
271 lo stream è posizionato all'inizio del file.\\
273 \texttt{a} & Il file viene aperto (o creato se non esiste) in
274 \textit{append mode}, l'accesso viene posto in sola scrittura. \\
275 \texttt{a+} & Il file viene aperto (o creato se non esiste) in
276 \textit{append mode}, l'accesso viene posto in lettura e scrittura. \\
279 \caption{Modalità di apertura di uno stream dello standard ANSI C che
280 sono sempre presenti in qualunque sistema POSIX}
281 \label{tab:file_fopen_mode}
284 In realtà lo standard ANSI C prevede un totale di 15 possibili valori
285 diversi per \param{mode}, ma in \tabref{tab:file_fopen_mode} si sono
286 riportati solo i sei valori effettivi, ad essi può essere aggiunto pure
287 il carattere \texttt{b} (come ultimo carattere o nel mezzo agli altri per
288 le stringhe di due caratteri) che in altri sistemi operativi serve a
289 distinguere i file binari dai file di testo; in un sistema POSIX questa
290 distinzione non esiste e il valore viene accettato solo per
291 compatibilità, ma non ha alcun effetto.
293 Le \acr{glibc} supportano alcune estensioni, queste devono essere sempre
294 indicate dopo aver specificato il \param{mode} con uno dei valori di
295 \tabref{tab:file_fopen_mode}. L'uso del carattere \texttt{x} serve per
296 evitare di sovrascrivere un file già esistente (è analoga all'uso
297 dell'opzione \macro{O\_EXCL} in \func{open}), se il file specificato già
298 esiste e si aggiunge questo carattere a \param{mode} la \func{fopen}
301 Un'altra estensione serve a supportare la localizzazione, quando si
302 aggiunge a \param{mode} una stringa della forma \verb|",ccs=STRING"| il
303 valore \verb|STRING| è considerato il nome di una codifica dei caratteri
304 e \func{fopen} marca il file per l'uso dei caratteri estesi e abilita le
305 opportune funzioni di conversione in lettura e scrittura.
307 Nel caso si usi \func{fdopen} i valori specificati da \param{mode} devono
308 essere compatibili con quelli con cui il file descriptor è stato aperto.
309 Inoltre i modi \cmd{w} e \cmd{w+} non troncano il file. La posizione nello
310 stream viene settata a quella corrente nel file descriptor, e le variabili di
311 errore e di fine del file (vedi \secref{sec:file_io}) sono cancellate. Il file
312 non viene duplicato e verrà chiuso alla chiusura dello stream.
314 I nuovi file saranno creati secondo quanto visto in
315 \secref{sec:file_ownership} ed avranno i permessi di accesso settati al
316 valore \macro{S\_IRUSR|S\_IWUSR|S\_IRGRP|S\_IWGRP|S\_IROTH|S\_IWOTH}
317 (pari a \macro{0666}) modificato secondo il valore di \acr{umask} per il
318 processo (si veda \secref{sec:file_umask}).
320 In caso di file aperti in lettura e scrittura occorre ricordarsi che c'è
321 di messo una bufferizzazione; per questo motivo lo standard ANSI C
322 richiede che ci sia una operazione di posizionamento fra una operazione
323 di output ed una di input o viceversa (eccetto il caso in cui l'input ha
324 incontrato la fine del file), altrimenti una lettura può ritornare anche
325 il risultato di scritture precedenti l'ultima effettuata.
327 Per questo motivo è una buona pratica (e talvolta necessario) far seguire ad
328 una scrittura una delle funzioni \func{fflush}, \func{fseek}, \func{fsetpos} o
329 \func{rewind} prima di eseguire una rilettura; viceversa nel caso in cui si
330 voglia fare una scrittura subito dopo aver eseguito una lettura occorre prima
331 usare una delle funzioni \func{fseek}, \func{fsetpos} o \func{rewind}. Anche
332 una operazione nominalmente nulla come \code{fseek(file, 0, SEEK\_CUR)} è
333 sufficiente a garantire la sincronizzazione.
335 Una volta aperto lo stream, si può cambiare la modalità di bufferizzazione
336 (si veda \secref{sec:file_buffering_ctrl}) fintanto che non si è effettuato
337 alcuna operazione di I/O sul file.
339 Uno stream viene chiuso con la funzione \func{fclose} il cui prototipo è:
340 \begin{prototype}{stdio.h}{int fclose(FILE *stream)}
341 Chiude lo stream \param{stream}.
343 \bodydesc{Restituisce 0 in caso di successo e \macro{EOF} in caso di errore,
344 nel qual caso setta \var{errno} a \macro{EBADF} se il file descriptor
345 indicato da \param{stream} non è valido, o uno dei valori specificati
346 dalla sottostante funzione che è fallita (\func{close}, \func{write} o
350 La funzione effettua lo scarico di tutti i dati presenti nei buffer di uscita
351 e scarta tutti i dati in ingresso; se era stato allocato un buffer per lo
352 stream questo verrà rilasciato. La funzione effettua lo scarico solo per i
353 dati presenti nei buffer in user space usati dalle \acr{glibc}; se si vuole
354 essere sicuri che il kernel forzi la scrittura su disco occorrerà effettuare
355 una \func{sync} (vedi \secref{sec:file_sync}).
357 Linux supporta anche una altra funzione, \func{fcloseall}, come estensione GNU
358 implementata dalle \acr{glibc}, accessibile avendo definito
359 \macro{\_GNU\_SOURCE}, il suo prototipo è:
360 \begin{prototype}{stdio.h}{int fcloseall(void)}
361 Chiude tutti gli stream.
363 \bodydesc{Restituisce 0 se non ci sono errori ed \macro{EOF} altrimenti.}
365 \noindent la funzione esegue lo scarico dei dati bufferizzati in uscita
366 e scarta quelli in ingresso, chiudendo tutti i file. Questa funzione è
367 provvista solo per i casi di emergenza, quando si è verificato un errore
368 ed il programma deve essere abortito, ma si vuole compiere qualche altra
369 operazione dopo aver chiuso i file e prima di uscire (si ricordi quanto
370 visto in \secref{sec:proc_exit}).
373 \subsection{Lettura e scrittura su uno stream}
376 Una delle caratteristiche più utili dell'interfaccia degli stream è la
377 ricchezza delle funzioni disponibili per le operazioni di lettura e
378 scrittura sui file. Sono infatti previste ben tre diverse modalità
379 modalità di input/output non formattato:
381 \item\textsl{binario} in cui legge/scrive un blocco di dati alla
382 volta, vedi \secref{sec:file_binary_io}.
383 \item\textsl{a caratteri} in cui si legge/scrive un carattere alla
384 volta (con la bufferizzazione gestita automaticamente dalla libreria),
385 vedi \secref{sec:file_char_io}.
386 \item\textsl{di linea} in cui si legge/scrive una linea (terminata dal
387 carattere di newline \verb|\n|) alla volta, vedi
388 \secref{sec:file_line_io}.
390 ed inoltre la modalità di input/output formattato.
392 A differenza dell'interfaccia dei file descriptor, con gli stream il
393 raggiungimento della fine del file è considerato un errore, e viene
394 notificato come tale dai valori di uscita delle varie funzioni. Nella
395 maggior parte dei casi questo avviene con la restituzione del valore
396 intero (di tipo \type{int}) \macro{EOF}\footnote{la costante deve essere
397 negativa, le \acr{glibc} usano -1, altre implementazioni possono avere
398 valori diversi.} definito anch'esso nell'header \file{stdlib.h}.
400 Dato che le funzioni dell'interfaccia degli stream sono funzioni di libreria
401 che si appoggiano a delle system call, esse non settano direttamente la
402 variabile \var{errno}, che mantiene il valore settato dalla system call che ha
405 Siccome la condizione di end-of-file è anch'essa segnalata come errore, nasce
406 il problema di come distinguerla da un errore effettivo; basarsi solo sul
407 valore di ritorno della funzione e controllare il valore di \var{errno}
408 infatti non basta, dato che quest'ultimo potrebbe essere stato settato in una
409 altra occasione, (si veda \secref{sec:sys_errno} per i dettagli del
410 funzionamento di \var{errno}).
412 Per questo motivo tutte le implementazioni delle librerie standard
413 mantengono per ogni stream almeno due flag all'interno dell'oggetto
414 \type{FILE}, il flag di \textit{end-of-file}, che segnala che si è
415 raggiunta la fine del file in lettura, e quello di errore, che segnala
416 la presenza di un qualche errore nelle operazioni di input/output;
417 questi due flag possono essere riletti dalle funzioni:
420 \funcdecl{int feof(FILE *stream)}
421 Controlla il flag di end-of-file di \param{stream}.
422 \funcdecl{int ferror(FILE *stream)}
423 Controlla il flag di errore di \param{stream}.
425 \bodydesc{Entrambe le funzioni ritornano un valore diverso da zero se
426 i relativi flag sono settati.}
428 \noindent si tenga presente comunque che la lettura di questi flag segnala
429 soltanto che c'è stato un errore, o che si è raggiunta la fine del file in una
430 qualunque operazione sullo stream, il controllo quindi deve essere effettuato
431 ogni volta che si chiama una funzione di libreria.
433 Entrambi i flag (di errore e di end-of-file) possono essere cancellati usando
434 la funzione \func{clearerr}, il cui prototipo è:
435 \begin{prototype}{stdio.h}{void clearerr(FILE *stream)}
436 Cancella i flag di errore ed end-of-file di \param{stream}.
438 \noindent in genere si usa questa funziona una volta che si sia identificata e
439 corretta la causa di un errore per evitare di mantenere i flag attivi, così da
440 poter rilevare una successiva ulteriore condizione di errore. Di questa
441 funzione esiste una analoga \func{clearerr\_unlocked} che non esegue il blocco
442 dello stream (vedi \secref{sec:file_stream_thread}).
445 \subsection{Input/output binario}
446 \label{sec:file_binary_io}
448 La prima modalità di input/output non formattato ricalca quella della
449 interfaccia dei file descriptor, e provvede semplicemente la scrittura e
450 la lettura dei dati da un buffer verso un file e viceversa. In generale
451 questa è la modalità che si usa quando si ha a che fare con dati non
452 formattati. Le due funzioni che si usano per l'I/O binario sono:
456 \funcdecl{size\_t fread(void *ptr, size\_t size, size\_t nmemb, FILE
459 \funcdecl{size\_t fwrite(const void *ptr, size\_t size, size\_t
460 nmemb, FILE *stream)}
462 Rispettivamente leggono e scrivono \param{nmemb} elementi di dimensione
463 \param{size} dal buffer \param{ptr} al file \param{stream}.
465 \bodydesc{Entrambe le funzioni ritornano il numero di elementi letti o
466 scritti, in caso di errore o fine del file viene restituito un numero di
467 elementi inferiore al richiesto.}
470 In genere si usano queste funzioni quando si devono trasferire su file
471 blocchi di dati binari in maniera compatta e veloce; un primo caso di uso
472 tipico è quello in cui si salva un vettore (o un certo numero dei suoi
473 elementi) con una chiamata del tipo:
474 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
475 int WriteVect(FILE *stream, double *vec, size_t nelem)
479 if ( (nread = fwrite(vec, size, nelem, stream)) != nelem) {
480 perror("Write error");
485 in questo caso devono essere specificate le dimensioni di ciascun
486 elemento ed il numero di quelli che si vogliono scrivere. Un secondo
487 caso è invece quello in cui si vuole trasferire su file una struttura;
488 si avrà allora una chiamata tipo:
489 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
496 int WriteStruct(FILE *stream, struct histogram *histo, size_t nelem)
498 if ( fwrite(vec, sizeof(*histo), 1, stream) !=1) {
499 perror("Write error");
504 in cui si specifica la dimensione dell'intera struttura ed un solo
507 In realtà quello che conta nel trasferimento dei dati sono le dimensioni
508 totali, che sono sempre pari al prodotto \code{size * nelem}; la sola
509 differenza è che le funzioni non ritornano il numero di byte scritti,
510 ma il numero di elementi.
512 La funzione \func{fread} legge sempre un numero intero di elementi, se
513 incontra la fine del file l'oggetto letto parzialmente viene scartato
514 (lo stesso avviene in caso di errore). In questo caso la posizione dello
515 stream viene settata alla fine del file (e non a quella corrispondente
516 alla quantità di dati letti).
518 In caso di errore (o fine del file per \func{fread}) entrambe le
519 funzioni restituiscono il numero di oggetti effettivamente letti o
520 scritti, che sarà inferiore a quello richiesto. Contrariamente a quanto
521 avviene per i file descriptor, questo segnala una condizione di errore e
522 occorrerà usare \func{feof} e \func{ferror} per stabilire la natura del
525 Benché queste funzioni assicurino la massima efficienza per il
526 salvataggio dei dati, i dati memorizzati attraverso di esse presentano
527 lo svantaggio di dipendere strettamente dalla piattaforma di sviluppo
528 usata ed in genere possono essere riletti senza problemi solo dallo
529 stesso programma che li ha prodotti.
531 Infatti diversi compilatori possono eseguire ottimizzazioni diverse
532 delle strutture dati e alcuni compilatori (come il \cmd{gcc}) possono
533 anche scegliere se ottimizzare l'occupazione di spazio, impacchettando
534 più strettamente i dati, o la velocità inserendo opportuni
535 \textit{padding} per l'allineamento dei medesimi generando quindi output
536 binari diversi. Inoltre altre incompatibilità si possono presentare
537 quando entrano in gioco differenze di architettura hardware, come la
538 dimensione del bus o la modalità di ordinamento dei bit o il formato
539 delle variabili in floating point.
541 Per questo motivo quando si usa l'input/output binario occorre sempre
542 essere prendere le opportune precauzioni (in genere usare un formato di
543 più alto livello che permetta di recuperare l'informazione completa),
544 per assicurarsi che versioni diverse del programma siano in grado di
545 rileggere i dati tenendo conto delle eventuali differenze.
547 Le \acr{glibc} definiscono altre due funzioni per l'I/O binario, che
548 evitano il lock implicito dello stream, usato per dalla librerie per la
549 gestione delle applicazioni multi-thread (si veda
550 \secref{sec:file_stream_thread} per i dettagli):
554 \funcdecl{size\_t fread\_unlocked(void *ptr, size\_t size, size\_t
555 nmemb, FILE *stream)}
557 \funcdecl{size\_t fwrite\_unlocked(const void *ptr, size\_t size,
558 size\_t nmemb, FILE *stream)}
560 \bodydesc{Le funzioni sono identiche alle analoghe \func{fread} e
561 \func{fwrite} ma non acquisiscono il lock implicito sullo stream.}
563 \noindent entrambe le funzioni sono estensioni GNU previste solo dalle
567 \subsection{Input/output a caratteri}
568 \label{sec:file_char_io}
570 La seconda modalità di input/output è quella a caratteri, in cui si
571 trasferisce un carattere alla volta. Le funzioni per la lettura a
572 caratteri sono tre, \func{fgetc}, \func{getc} e \func{getchar}, i
573 rispettivi prototipi sono:
577 \funcdecl{int getc(FILE *stream)} Legge un byte da \param{stream} e lo
578 restituisce come intero. In genere è implementata come una macro.
580 \funcdecl{int fgetc(FILE *stream)} Legge un byte da \param{stream} e lo
581 restituisce come intero. È una sempre una funzione.
583 \funcdecl{int getchar(void)} Equivalente a \code{getc(stdin)}.
585 \bodydesc{Tutte queste funzioni leggono un byte alla volta, che viene
586 restituito come intero; in caso di errore o fine del file il valore
587 di ritorno è \macro{EOF}.}
590 A parte \func{getchar}, che si usa in genere per leggere un carattere da
591 tastiera, le altre due funzioni sono sostanzialmente equivalenti. La
592 differenza è che \func{getc} è ottimizzata al massimo e normalmente
593 viene implementata con una macro, per cui occorre stare attenti a cosa
594 le si passa come argomento, infatti \param{stream} può essere valutato
595 più volte nell'esecuzione, e non viene passato in copia con il
596 meccanismo visto in \secref{sec:proc_var_passing}; per questo motivo se
597 si passa una espressione si possono avere effetti indesiderati.
599 Invece \func{fgetc} è assicurata essere sempre una funzione, per questo
600 motivo la sua esecuzione normalmente è più lenta per via dell'overhead
601 della chiamata, ma è altresì possibile ricavarne l'indirizzo, che può
602 essere passato come parametro ad un altra funzione (e non si hanno i
603 problemi accennati in precedenza con \param{stream}).
605 Le tre funzioni restituiscono tutte un \type{unsigned char} convertito
606 ad \type{int} (si usa \type{unsigned char} in modo da evitare
607 l'espansione del segno). In questo modo il valore di ritorno è sempre
608 positivo, tranne in caso di errore o fine del file.
610 Nelle estensioni GNU che provvedono la localizzazione sono definite tre
611 funzioni equivalenti alle precedenti che invece di un carattere di un
612 byte restituiscono un carattere in formato esteso (cioè di tipo
613 \type{wint\_t}, il loro prototipo è:
618 \funcdecl{wint\_t getwc(FILE *stream)} Legge un carattere esteso da
619 \param{stream}. In genere è implementata come una macro.
621 \funcdecl{wint\_t fgetwc(FILE *stream)} Legge un carattere esteso da
622 \param{stream} È una sempre una funzione.
624 \funcdecl{wint\_t getwchar(void)} Equivalente a \code{getwc(stdin)}.
626 \bodydesc{Tutte queste funzioni leggono un carattere alla volta, in
627 caso di errore o fine del file il valore di ritorno è \macro{WEOF}.}
630 Per scrivere un carattere si possono usare tre funzioni analoghe alle
631 precedenti usate per leggere: \func{putc}, \func{fputc} e
632 \func{putchar}; i loro prototipi sono:
636 \funcdecl{int putc(int c, FILE *stream)} Scrive il carattere \param{c}
637 su \param{stream}. In genere è implementata come una macro.
639 \funcdecl{int fputc(FILE *stream)} Scrive il carattere \param{c} su
640 \param{stream}. È una sempre una funzione.
642 \funcdecl{int putchar(void)} Equivalente a \code{putc(stdin)}.
644 \bodydesc{Le funzioni scrivono sempre un carattere alla volta, il cui
645 valore viene restituito in caso di successo; in caso di errore o
646 fine del file il valore di ritorno è \macro{EOF}.}
649 Tutte queste funzioni scrivono sempre un byte alla volta, anche se
650 prendono come parametro un \type{int} (che pertanto deve essere ottenuto
651 con un cast da un \type{unsigned char}). Anche il valore di ritorno è
652 sempre un intero; in caso di errore o fine del file il valore di ritorno
655 Come nel caso dell'I/O binario le \acr{glibc} provvedono per ciascuna
656 delle funzioni precedenti, come estensione GNU, una seconda funzione, il
657 cui nome è ottenuto aggiungendo un \code{\_unlocked}, che esegue
658 esattamente le stesse operazioni evitando però il lock implicito dello
661 Per compatibilità con SVID sono provviste anche due funzioni per leggere
662 e scrivere una \textit{word} (che è sempre definita come \type{int}); i
667 \funcdecl{int getw(FILE *stream)} Legge una parola da \param{stream}.
668 \funcdecl{int putw(int w, FILE *stream)} Scrive la parola \param{w} su
671 \bodydesc{Le funzioni restituiscono la parola \param{w}, o \macro{EOF}
672 in caso di errore o di fine del file.}
674 \noindent l'uso di queste funzioni è deprecato in favore dell'uso di
675 \func{fread} e \func{fwrite}, in quanto non è possibile distinguere il
676 valore -1 da una condizione di errore che restituisce \macro{EOF}.
678 Una degli usi più frequenti dell'input/output a caratteri è nei
679 programmi di \textit{parsing} in cui si analizza il testo; in questo
680 contesto diventa utile poter analizzare il carattere successivo da uno
681 stream senza estrarlo effettivamente (la tecnica è detta \textit{peeking
682 ahead}) in modo che il programma possa regolarsi sulla base avendo
683 dato una \textsl{sbirciatina} a quello che viene dopo.
685 Nel nostro caso questo tipo di comportamento può essere realizzato prima
686 leggendo il carattere, e poi rimandandolo indietro, cosicché ridiventi
687 disponibile per una lettura successiva; la funzione che inverte la
688 lettura si chiama \func{ungetc} ed il suo prototipo è:
689 \begin{prototype}{stdio.h}{int ungetc(int c, FILE *stream)}
690 Rimanda indietro il carattere \param{c}, con un cast a \type{unsigned
691 char}, sullo stream \param{stream}.
693 \bodydesc{La funzione ritorna \param{c} in caso di successo e
694 \macro{EOF} in caso di errore.}
696 \noindent benché lo standard ANSI C preveda che l'operazione possa
697 essere ripetuta per un numero arbitrario di caratteri, alle
698 implementazioni è richiesto di garantire solo un livello; questo è
699 quello che fa la \acr{glibc}, che richiede che avvenga un'altra
700 operazione fra due \func{ungetc} successive.
702 Non è necessario che il carattere che si manda indietro sia l'ultimo che
703 si è letto, e non è necessario neanche avere letto nessun carattere
704 prima di usare \func{ungetc}, ma di norma la funzione è intesa per
705 essere usata per rimandare indietro l'ultimo carattere letto.
707 Nel caso \param{c} sia un \macro{EOF} la funzione non fa nulla, e
708 restituisce sempre \macro{EOF}; così si può usare \func{ungetc} anche
709 con il risultato di una lettura alla fine del file.
711 Se si è alla fine del file si può comunque rimandare indietro un
712 carattere, il flag di end-of-file verrà automaticamente cancellato
713 perché c'è un nuovo carattere disponibile che potrà essere riletto
716 Infine si tenga presente che \func{ungetc} non altera il contenuto del
717 file, ma opera esclusivamente sul buffer interno. Se si esegue una
718 qualunque delle operazioni di riposizionamento (vedi
719 \secref{sec:file_fseek}) i caratteri rimandati indietro vengono
723 \subsection{Input/output di linea}
724 \label{sec:file_line_io}
726 La terza ed ultima modalità di input/output non formattato è quella di
727 linea, in cui legge o scrive una riga alla volta; questa è una modalità
728 molto usata per l'I/O da terminale, ma che presenta le caratteristiche
731 Le funzioni previste dallo standard ANSI C per leggere una linea sono
732 sostanzialmente due, \func{gets} e \func{fgets}, i cui rispettivi
737 \funcdecl{char *gets(char *string)} Scrive su \param{string} una
738 linea letta da \var{stdin}.
740 \funcdecl{char *fgets(char *string, int size, FILE *stream)}
741 Scrive su \param{string} la linea letta da \param{stream} per un
742 massimo di \param{size} byte.
744 \bodydesc{Le funzioni restituiscono l'indirizzo \param{string} in caso
745 di successo o \macro{NULL} in caso di errore.}
748 Entrambe le funzioni effettuano la lettura (dal file specificato \func{fgets},
749 dallo standard input \func{gets}) di una linea di caratteri (terminata dal
750 carattere \textit{newline}, \verb|\n|, quello mappato sul tasto di ritorno a
751 capo della tastiera), ma \func{gets} sostituisce \verb|\n| con uno zero,
752 mentre \func{fgets} aggiunge uno zero dopo il \textit{newline}, che resta
753 dentro la stringa. Se la lettura incontra la fine del file (o c'è un errore)
754 viene restituito un \macro{NULL}, ed il buffer \param{buf} non viene toccato.
756 L'uso di \func{gets} è deprecato e deve essere assolutamente evitato; la
757 funzione infatti non controlla il numero di byte letti, per cui nel caso
758 la stringa letta superi le dimensioni del buffer, si avrà un
759 \textit{buffer overflow}, con sovrascrittura della memoria del processo
762 Questa è una delle vulnerabilità più sfruttate per guadagnare accessi
763 non autorizzati al sistema (i cosiddetti \textit{exploit}), basta
764 infatti inviare una stringa sufficientemente lunga ed opportunamente
765 forgiata per sovrascrivere gli indirizzi di ritorno nello stack
766 (supposto che la \func{gets} sia stata chiamata da una subroutine), in
767 modo da far ripartire l'esecuzione nel codice inviato nella stringa
768 stessa (in genere uno \textit{shell code} cioè una sezione di programma
771 La funzione \func{fgets} non ha i precedenti problemi di \func{gets} in
772 quanto prende in input la dimensione del buffer \param{size}, che non
773 verrà mai ecceduta in lettura. La funzione legge fino ad un massimo di
774 \param{size} caratteri (newline compreso), ed aggiunge uno zero di
775 terminazione; questo comporta che la stringa possa essere al massimo di
776 \var{size-1} caratteri. Se la linea eccede la dimensione del buffer
777 verranno letti solo \var{size-1} caratteri, ma la stringa sarà sempre
778 terminata correttamente con uno zero finale; sarà possibile leggere i
779 restanti caratteri in una chiamata successiva.
781 Per la scrittura di una linea lo standard ANSI C prevede altre due
782 funzioni, \func{fputs} e \func{puts}, analoghe a quelle di lettura, i
783 rispettivi prototipi sono:
787 \funcdecl{int puts(const char *string)} Scrive su \var{stdout} la
788 linea \param{string}.
790 \funcdecl{int fputs(const char *string, FILE *stream)} Scrive su
791 \param{stream} la linea \param{string}.
793 \bodydesc{Le funzioni restituiscono un valore non negativo in caso di
794 successo o \macro{EOF} in caso di errore.}
797 Dato che in questo caso si scrivono i dati in uscita \func{puts} non ha i
798 problemi di \func{gets} ed è in genere la forma più immediata per scrivere
799 messaggi sullo standard output; la funzione prende una stringa terminata da
800 uno zero ed aggiunge automaticamente il ritorno a capo. La differenza con
801 \func{fputs} (a parte la possibilità di specificare un file diverso da
802 \var{stdout}) è che quest'ultima non aggiunge il newline, che deve essere
803 previsto esplicitamente.
805 Come per le funzioni di input/output a caratteri esistono le estensioni
806 per leggere e scrivere caratteri estesi, i loro prototipi sono:
809 \funcdecl{wchar\_t *fgetws(wchar\_t *ws, int n, FILE *stream)}
810 Legge un massimo di \param{n} caratteri estesi dal file
811 \param{stream} al buffer \param{ws}.
813 \funcdecl{int fputws(const wchar\_t *ws, FILE *stream)} Scrive la
814 linea \param{ws} di caratteri estesi sul file \param{stream}.
816 \bodydesc{Le funzioni ritornano rispettivamente \param{ws} o un numero
817 non negativo in caso di successo e \macro{NULL} o \macro{EOF} in
818 caso di errore o fine del file.}
820 \noindent il comportamento è identico a quello di \func{fgets} e
821 \func{fputs} solo che tutto (numero di caratteri massimo, terminatore
822 della stringa, newline) è espresso in termini di caratteri estesi
823 anziché di caratteri ASCII.
825 Come nel caso dell'I/O binario e a caratteri nelle \acr{glibc} sono
826 previste una serie di altre funzioni, estensione di tutte quelle
827 illustrate finora (eccetto \func{gets} e \func{puts}), il cui nome si
828 ottiene aggiungendo un \code{\_unlocked}, e che eseguono esattamente le
829 stesse operazioni delle loro equivalenti, evitando però il lock
830 implicito dello stream (vedi \secref{sec:file_stream_thread}).
832 Come abbiamo visto, le funzioni di lettura per l'input/output di linea
833 previste dallo standard ANSI C presentano svariati inconvenienti. Benché
834 \func{fgets} non abbia i gravissimi problemi di \func{gets}, può
835 comunque dare risultati ambigui se l'input contiene degli zeri; questi
836 infatti saranno scritti sul buffer di uscita e la stringa in output
837 apparirà come più corta dei byte effettivamente letti. Questa è una
838 condizione che è sempre possibile controllare (deve essere presente un
839 newline prima della effettiva conclusione della stringa presente nel
840 buffer), ma a costo di una complicazione ulteriore della logica del
841 programma. Lo stesso dicasi quando si deve gestire il caso di stringa
842 che eccede le dimensioni del buffer.
844 Per questo motivo le \acr{glibc} prevedono, come estensione GNU, due
845 nuove funzioni per la gestione dell'input/output di linea, il cui uso
846 permette di risolvere questi problemi. L'uso di queste funzioni deve
847 essere attivato definendo la macro \macro{\_GNU\_SOURCE} prima di
848 includere \file{stdio.h}. La prima delle due, \func{getline}, serve per
849 leggere una linea terminata da un newline esattamente allo stesso modo
850 di \func{fgets}, il suo prototipo è:
851 \begin{prototype}{stdio.h}
852 {ssize\_t getline(char **buffer, size\_t *n, FILE *stream)} Legge una
853 linea dal file \param{stream} sul buffer indicato da \param{buffer}
854 riallocandolo se necessario (l'indirizzo del buffer e la sua
855 dimensione vengono sempre riscritte).
857 \bodydesc{La funzione ritorna il numero di caratteri letti in caso di
858 successo e -1 in caso di errore o di raggiungimento della fine del
862 La funzione permette di eseguire una lettura senza doversi preoccupare
863 della eventuale lunghezza eccessiva della stringa da leggere. Essa
864 prende come primo parametro l'indirizzo del puntatore al buffer su cui
865 si vuole leggere la linea. Quest'ultimo \emph{deve} essere stato
866 allocato in precedenza con una \func{malloc} (non si può passare
867 l'indirizzo di un puntatore ad una variabile locale); come secondo
868 parametro la funzione vuole l'indirizzo della variabile contenente le
869 dimensioni del buffer suddetto.
871 Se il buffer di destinazione è sufficientemente ampio la stringa viene
872 scritta subito, altrimenti il buffer viene allargato usando
873 \func{realloc} e la nuova dimensione ed il nuovo puntatore vengono
874 passata indietro (si noti infatti come per entrambi i parametri si siano
875 usati dei \textit{value result argument}, passando dei puntatori anzichè
876 i valori delle variabili, secondo la tecnica spiegata in
877 \secref{sec:proc_var_passing}).
879 Se si passa alla funzione l'indirizzo ad un puntatore settato a
880 \macro{NULL} e \var{*n} è zero, la funzione provvede da sola
881 all'allocazione della memoria necessaria a contenere la linea. In tutti
882 i casi si ottiene dalla funzione un puntatore all'inizio del testo della
883 linea. Un esempio di codice può essere il seguente:
884 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
890 nread = getline(&ptr, &n, file);
892 e per evitare memory leak occorre ricordarsi di liberare \var{ptr} con
895 Il valore di ritorno della funzione indica il numero di caratteri letti
896 dallo stream (quindi compreso il newline, ma non lo zero di
897 terminazione); questo permette anche di distinguere eventuali zeri letti
898 dallo stream da quello inserito dalla funzione per terminare la linea.
899 Se si è alla fine del file e non si è potuto leggere nulla o c'è stato
900 un errore la funzione restituisce -1.
902 La seconda estensione GNU è una generalizzazione di \func{getline} per
903 poter usare come separatore un carattere qualsiasi, la funzione si
904 chiama \func{getdelim} ed il suo prototipo è:
905 \begin{prototype}{stdio.h}
906 {ssize\_t getdelim(char **buffer, size\_t *n, int delim, FILE *stream)}
907 Identica a \func{getline} solo che usa \param{delim} al posto del
908 carattere di newline come separatore di linea.
911 Il comportamento di \func{getdelim} è identico a quello di \func{getline} (che
912 può essere implementata da questa passando \verb|'\n'| come valore di
916 \subsection{L'input/output formattato}
917 \label{sec:file_formatted_io}
919 L'ultima modalità di input/output è quella formattata, che è una delle
920 caratteristiche più utilizzate delle librerie standard del C; in genere questa
921 è la modalità in cui si esegue normalmente l'output su terminale poiché
922 permette di stampare in maniera facile e veloce dati, tabelle e messaggi.
924 L'output formattato viene eseguito con una delle 13 funzioni della famiglia
925 \func{printf}; le tre più usate sono le seguenti:
928 \funcdecl{int printf(const char *format, ...)} Stampa su \file{stdout}
929 gli argomenti, secondo il formato specificato da \param{format}.
931 \funcdecl{int fprintf(FILE *stream, const char *format, ...)} Stampa
932 su \param{stream} gli argomenti, secondo il formato specificato da
935 \funcdecl{int sprintf(char *str, const char *format, ...)} Stampa
936 sulla stringa \param{str} gli argomenti, secondo il formato
937 specificato da \param{format}.
939 \bodydesc{Le funzioni ritornano il numero di caratteri stampati.}
941 \noindent le prime due servono per stampare su file (lo standard output
942 o quello specificato) la terza permette di stampare su una stringa, in genere
943 l'uso di \func{sprintf} è sconsigliato in quanto è possibile, se non si ha la
944 sicurezza assoluta sulle dimensioni del risultato della stampa, eccedere le
945 dimensioni di \param{str} con conseguente sovrascrittura di altre variabili e
946 possibili buffer overflow; per questo motivo si consiglia l'uso
948 \begin{prototype}{stdio.h}
949 {snprintf(char *str, size\_t size, const char *format, ...)}
950 Identica a \func{sprintf}, ma non scrive su \param{str} più di
951 \param{size} caratteri.
954 La parte più complessa di queste funzioni è il formato della stringa
955 \param{format} che indica le conversioni da fare, da cui poi deriva il numero
956 dei parametri che dovranno essere passati a seguire. La stringa è costituita
957 da caratteri normali (tutti eccetto \texttt{\%}), che vengono passati
958 invariati all'output, e da direttive di conversione, in cui devono essere
959 sempre presenti il carattere \texttt{\%}, che introduce la direttiva, ed uno
960 degli specificatori di conversione (riportati in \ntab) che la conclude.
964 \begin{tabular}[c]{|l|l|p{10cm}|}
966 \textbf{Valore} & \textbf{Tipo} & \textbf{Significato} \\
969 \cmd{\%d} &\type{int} & Stampa un numero intero in formato decimale
971 \cmd{\%i} &\type{int} & Identico a \cmd{\%i} in output, \\
972 \cmd{\%o} &\type{unsigned int}& Stampa un numero intero come ottale\\
973 \cmd{\%u} &\type{unsigned int}& Stampa un numero intero in formato
974 decimale senza segno \\
976 \cmd{\%X} &\type{unsigned int}& Stampano un intero in formato esadecimale,
977 rispettivamente con lettere minuscole e
979 \cmd{\%f} &\type{unsigned int}& Stampa un numero in virgola mobile con la
980 notazione a virgola fissa \\
982 \cmd{\%E} &\type{double} & Stampano un numero in virgola mobile con la
983 notazione esponenziale, rispettivamente con
984 lettere minuscole e maiuscole. \\
986 \cmd{\%G} &\type{double} & Stampano un numero in virgola mobile con la
987 notazione più appropriate delle due precedenti,
988 rispettivamente con lettere minuscole e
991 \cmd{\%A} &\type{double} & Stampano un numero in virgola mobile in
992 notazione esadecimale frazionaria\\
993 \cmd{\%c} &\type{int} & Stampa un carattere singolo\\
994 \cmd{\%s} &\type{char *} & Stampa una stringa \\
995 \cmd{\%p} &\type{void *} & Stampa il valore di un puntatore\\
996 \cmd{\%n} &\type{\&int} & Prende il numero di caratteri stampati finora\\
997 \cmd{\%\%}& & Stampa un \% \\
1000 \caption{Valori possibili per gli specificatori di conversione in una
1001 stringa di formato di \func{printf}.}
1002 \label{tab:file_format_spec}
1005 Il formato di una direttiva di conversione prevede una serie di possibili
1006 elementi opzionali oltre al \cmd{\%} e allo specificatore di conversione. In
1007 generale essa è sempre del tipo:
1010 % [n. parametro $] [flag] [[larghezza] [. precisione]] [tipo] conversione
1013 in cui tutti i valori tranne il \cmd{\%} e lo specificatore di conversione
1014 sono opzionali (e per questo sono indicati fra parentesi quadre); si possono
1015 usare più elementi opzionali, nel qual caso devono essere specificati in
1018 \item uno specificatore del parametro da usare (terminato da un \cmd{\$}),
1019 \item uno o più flag (i cui valori possibili sono riassunti in
1020 \tabref{tab:file_format_flag}) che controllano il formato di stampa della
1022 \item uno specificatore di larghezza (un numero decimale), eventualmente
1023 seguito (per i numeri in virgola mobile) da un specificatore di precisione
1024 (un altro numero decimale),
1025 \item uno specificatore del tipo di dato, che ne indica la dimensione (i cui
1026 valori possibili sono riassunti in \tabref{tab:file_format_type}).
1032 \begin{tabular}[c]{|l|p{10cm}|}
1034 \textbf{Valore} & \textbf{Significato}\\
1037 \cmd{\#} & Chiede la conversione in forma alternativa. \\
1038 \cmd{0} & La conversione è riempita con zeri alla sinistra del valore.\\
1039 \cmd{-} & La conversione viene allineata a sinistra sul bordo del campo.\\
1040 \cmd{' '}& Mette uno spazio prima di un numero con segno di valore
1042 \cmd{+} & Mette sempre il segno ($+$ o $-$) prima di un numero.\\
1045 \caption{I valori dei flag per il formato di \func{printf}}
1046 \label{tab:file_format_flag}
1049 Dettagli ulteriori sulle varie opzioni possono essere trovati nella man page
1050 di \func{printf} e nella documentazione delle \acr{glibc}.
1054 \begin{tabular}[c]{|l|p{10cm}|}
1056 \textbf{Valore} & \textbf{Significato} \\
1059 \cmd{hh} & una conversione intera corrisponde a un \type{char} con o senza
1060 segno, o il puntatore per il numero dei parametri \cmd{n} è di
1062 \cmd{h} & una conversione intera corrisponde a uno \type{short} con o
1063 senza segno, o il puntatore per il numero dei parametri \cmd{n}
1064 è di tipo \type{short}.\\
1065 \cmd{l} & una conversione intera corrisponde a un \type{long} con o
1066 senza segno, o il puntatore per il numero dei parametri \cmd{n}
1067 è di tipo \type{long}, o il carattere o la stringa seguenti
1068 sono in formato esteso.\\
1069 \cmd{ll} & una conversione intera corrisponde a un \type{long long} con o
1070 senza segno, o il puntatore per il numero dei parametri \cmd{n}
1071 è di tipo \type{long long}.\\
1072 \cmd{L} & una conversione in virgola mobile corrisponde a un
1074 \cmd{q} & sinonimo di \cmd{ll}.\\
1075 \cmd{j} & una conversione intera corrisponde a un \type{intmax\_t} o
1076 \type{uintmax\_t}.\\
1077 \cmd{z} & una conversione intera corrisponde a un \type{size\_t} o
1079 \cmd{t} & una conversione intera corrisponde a un \type{ptrdiff\_t}.\\
1082 \caption{Il modificatore di tipo di dato per il formato di \func{printf}}
1083 \label{tab:file_format_type}
1086 Una versione alternativa delle funzioni di output formattato, che permettono
1087 di usare il puntatore ad una lista di argomenti (vedi
1088 \secref{sec:proc_variadic}), sono le seguenti:
1092 \funcdecl{int vprintf(const char *format, va\_list ap)} Stampa su
1093 \var{stdout} gli argomenti della lista \param{ap}, secondo il formato
1094 specificato da \param{format}.
1096 \funcdecl{int vfprintf(FILE *stream, const char *format, va\_list ap)}
1097 Stampa su \param{stream} gli argomenti della lista \param{ap}, secondo il
1098 formato specificato da \param{format}.
1100 \funcdecl{int vsprintf(char *str, const char *format, va\_list ap)} Stampa
1101 sulla stringa \param{str} gli argomenti della lista \param{ap}, secondo il
1102 formato specificato da \param{format}.
1104 \bodydesc{Le funzioni ritornano il numero di caratteri stampati.}
1106 \noindent con queste funzioni diventa possibile selezionare gli argomenti che
1107 si vogliono passare ad una routine di stampa, passando direttamente la lista
1108 tramite il parametro \param{ap}. Per poter far questo ovviamente la lista dei
1109 parametri dovrà essere opportunamente trattata (l'argomento è esaminato in
1110 \secref{sec:proc_variadic}), e dopo l'esecuzione della funzione l'argomento
1111 \param{ap} non sarà più utilizzabile (in generale dovrebbe essere eseguito un
1112 \macro{va\_end(ap)} ma in Linux questo non è necessario).
1114 Come per \func{sprintf} anche per \func{vsprintf} esiste una analoga
1115 \func{vsnprintf} che pone un limite sul numero di caratteri che vengono
1116 scritti sulla stringa di destinazione:
1117 \begin{prototype}{stdio.h}
1118 {vsnprintf(char *str, size\_t size, const char *format, va\_list ap)}
1119 Identica a \func{vsprintf}, ma non scrive su \param{str} più di
1120 \param{size} caratteri.
1122 \noindent in modo da evitare possibili buffer overflow.
1125 Per eliminare alla radice questi problemi, le \acr{glibc} supportano una
1126 estensione specifica GNU che alloca dinamicamente tutto lo spazio necessario;
1127 l'estensione si attiva al solito definendo \macro{\_GNU\_SOURCE}, le due
1132 \funcdecl{int asprintf(char **strptr, const char *format, ...)} Stampa gli
1133 argomenti specificati secondo il formato specificato da \param{format} su
1134 una stringa allocata automaticamente all'indirizzo \param{*strptr}.
1136 \funcdecl{int vasprintf(char **strptr, const char *format, va\_list ap)}
1137 Stampa gli argomenti della lista \param{ap} secondo il formato specificato
1138 da \param{format} su una stringa allocata automaticamente all'indirizzo
1141 \bodydesc{Le funzioni ritornano il numero di caratteri stampati.}
1143 Entrambe le funzioni prendono come parametro \param{strptr} che deve essere
1144 l'indirizzo di un puntatore ad una stringa di caratteri, in cui verrà
1145 restituito (si ricordi quanto detto in \secref{sec:proc_var_passing} a
1146 proposito dei \textit{value result argument}) l'indirizzo della stringa
1147 allogata automaticamente dalle funzioni. Occorre inoltre ricordarsi di
1148 invocare \func{free} per liberare detto puntatore quando la stringa non serve
1149 più, onde evitare memory leak.
1151 Infine una ulteriore estensione GNU definisce le due funzioni \func{dprintf} e
1152 \func{vdprintf}, che prendono un file descriptor al posto dello stream. Altre
1153 estensioni permettono di scrivere con caratteri estesi. Anche queste funzioni,
1154 il cui nome è generato dalle precedenti funzioni aggiungendo una \texttt{w}
1155 davanti a \texttt{print}, sono trattate in dettaglio nella documentazione delle
1158 In corrispondenza alla famiglia di funzioni \func{printf} che si usano per
1159 l'output formattato, l'input formattato viene eseguito con le funzioni della
1160 famiglia \func{scanf}; fra queste le tre più importanti sono:
1162 \headdecl{stdio.h} \funcdecl{int scanf(const char *format, ...)} Esegue una
1163 scansione di \file{stdin} cercando una corrispondenza di quanto letto con il
1164 formato dei dati specificato da \param{format}, ed effettua le relative
1165 conversione memorizzando il risultato nei parametri seguenti.
1167 \funcdecl{int fscanf(FILE *stream, const char *format, ...)} Analoga alla
1168 precedente, ma effettua la scansione su \param{stream}.
1170 \funcdecl{int sscanf(char *str, const char *format, ...)} Analoga alle
1171 precedenti, ma effettua la scansione dalla stringa \param{str}.
1173 \bodydesc{Le funzioni ritornano il numero di elementi assegnati. Questi
1174 possono essere in numero inferiore a quelli specificati, ed anche zero.
1175 Quest'ultimo valore significa che non si è trovata corrispondenza. In caso
1176 di errore o fine del file viene invece restituito \macro{EOF}.}
1178 \noindent e come per le analoghe funzioni di scrittura esistono le relative
1179 \func{vscanf}, \func{vfscanf} \func{vsscanf} che usano un puntatore ad una
1182 Tutte le funzioni della famiglia delle \func{scanf} vogliono come argomenti i
1183 puntatori alle variabili che dovranno contenere le conversioni; questo è un
1184 primo elemento di disagio in quanto è molto facile dimenticarsi di questa
1187 Le funzioni leggono i caratteri dallo stream (o dalla stringa) di input ed
1188 eseguono un confronto con quanto indicato in \param{format}, la sintassi di
1189 questo parametro è simile a quella usata per l'analogo di \func{printf}, ma ci
1190 sono varie differenze. Le funzioni di input infatti sono più orientate verso
1191 la lettura di testo libero che verso un input formattato in campi fissi. Uno
1192 spazio in \param{format} corrisponde con un numero qualunque di caratteri di
1193 separazione (che possono essere spazi, tabulatori, virgole etc.), mentre
1194 caratteri diversi richiedono una corrispondenza esatta. Le direttive di
1195 conversione sono analoghe a quelle di \func{printf} e si trovano descritte in
1196 dettaglio nelle man page e nel manuale delle \acr{glibc}.
1198 Le funzioni eseguono la lettura dall'input, scartano i separatori (e gli
1199 eventuali caratteri diversi indicati dalla stringa di formato) effettuando le
1200 conversioni richieste; in caso la corrispondenza fallisca (o la funzione non
1201 sia in grado di effettuare una delle conversioni richieste) la scansione viene
1202 interrotta immediatamente e la funzione ritorna lasciando posizionato lo
1203 stream al primo carattere che non corrisponde.
1205 Data la notevole complessità di uso di queste funzioni, che richiedono molta
1206 cura nella definizione delle corrette stringhe di formato e sono facilmente
1207 soggette ad errori, e considerato anche il fatto che è estremamente macchinoso
1208 recuperare in caso di fallimento nelle corrispondenze, l'input formattato non
1209 è molto usato. In genere infatti quando si ha a che fare con un input
1210 relativamente semplice si preferisce usare l'input di linea ed effettuare
1211 scansione e conversione di quanto serve direttamente con una delle funzioni di
1212 conversione delle stringhe; se invece il formato è più complesso diventa più
1213 facile utilizzare uno strumento come il \cmd{flex} per generare un
1214 analizzatore lessicale o il \cmd{bison} per generare un parser.
1217 \subsection{Posizionamento su uno stream}
1218 \label{sec:file_fseek}
1220 Come per i file descriptor è possibile anche con gli stream spostarsi
1221 all'interno di un file per effettuare operazioni di lettura o scrittura in un
1222 punto prestabilito; questo fintanto che l'operazione di riposizionamento è
1223 supportata dal file sottostante lo stream, quando cioè si ha a che fare con
1224 quello che viene detto un file ad \textsl{accesso casuale}.
1226 In GNU/Linux ed in generale in ogni sistema unix-like la posizione nel file è
1227 espressa da un intero positivo, rappresentato dal tipo \type{off\_t}, il
1228 problema è alcune delle funzioni usate per il riposizionamento sugli stream
1229 originano dalle prime versioni di Unix, in cui questo tipo non era ancora
1230 stato definito, e che in altri sistemi non è detto che la posizione su un file
1231 venga sempre rappresentata con il numero di caratteri dall'inizio (ad esempio
1232 in VMS può essere rappresentata come numero di record, e offset rispetto al
1235 Tutto questo comporta la presenza di diverse funzioni che eseguono
1236 sostanzialmente le stesse operazioni, ma usano parametri di tipo
1237 diverso. Le funzioni tradizionali usate per il riposizionamento della
1238 posizione in uno stream sono:
1242 \funcdecl{int fseek(FILE *stream, long offset, int whence)} Sposta la
1243 posizione nello stream secondo quanto specificato tramite \param{offset}
1246 \funcdecl{void rewind(FILE *stream)} Riporta la posizione nello stream
1247 all'inizio del file.
1250 L'uso di \func{fseek} è del tutto analogo a quello di \func{lseek} per i file
1251 descriptor, ed i parametri, a parte il tipo, hanno lo stesso significato; in
1252 particolare \param{whence} assume gli stessi valori già visti in
1253 \secref{sec:file_lseek}. La funzione restituisce 0 in caso di successo e -1
1254 in caso di errore. La funzione \func{rewind} riporta semplicemente la
1255 posizione corrente all'inizio dello stream, ma non esattamente equivalente ad
1256 una \code{fseek(stream, 0L, SEEK\_SET)} in quanto vengono cancellati anche i
1257 flag di errore e fine del file.
1259 Per ottenere la posizione corrente si usa invece la funzione \func{ftell}, il
1261 \begin{prototype}{stdio.h}{long ftell(FILE *stream)}
1262 Legge la posizione attuale nello stream \param{stream}.
1264 \bodydesc{La funzione restituisce la posizione corrente, o -1 in caso
1265 di fallimento, che può esser dovuto sia al fatto che il file non
1266 supporta il riposizionamento che al fatto che la posizione non può
1267 essere espressa con un \type{long int}}
1269 \noindent la funzione restituisce la posizione come numero di byte
1270 dall'inizio dello stream.
1272 Queste funzioni esprimono tutte la posizione nel file come un \func{long int},
1273 dato che (ad esempio quando si usa un filesystem indicizzato a 64 bit) questo
1274 può non essere possibile lo standard POSIX ha introdotto le nuove funzioni
1275 \func{fgetpos} e \func{fsetpos}, che invece usano il nuovo tipo
1276 \type{fpos\_t}, ed i cui prototipi sono:
1280 \funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Setta la posizione
1281 corrente nello stream \param{stream} al valore specificato da \param{pos}.
1283 \funcdecl{int fgetpos(FILE *stream, fpos\_t *pos)} Scrive la posizione
1284 corrente nello stream \param{stream} in \param{pos}.
1286 \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
1290 In Linux, a partire dalle glibc 2.1, sono presenti anche le funzioni
1291 \func{fseeko} e \func{ftello}, assolutamente identiche alle precedenti ma con
1292 argomenti di tipo \type{off\_t} anziché di tipo \type{long int}.
1296 \section{Funzioni avanzate}
1297 \label{sec:file_stream_adv_func}
1299 In questa sezione esamineremo alcune funzioni avanzate che permettono di
1300 eseguire operazioni particolari sugli stream, come leggerne gli attributi,
1301 controllarne le modalità di bufferizzazione, gestire direttamente i lock
1302 impliciti per la programmazione multi thread.
1305 \subsection{Le funzioni di controllo}
1306 \label{sec:file_stream_cntrl}
1308 Al contrario di quanto avviene con i file descriptor le librerie standard del
1309 C non prevedono nessuna funzione come la \func{fcntl} per il controllo degli
1310 attributi dei file. Però siccome ogni stream si appoggia ad un file descriptor
1311 si può usare la funzione \func{fileno} per ottenere quest'ultimo, il prototipo
1313 \begin{prototype}{stdio.h}{int fileno(FILE *stream)}
1314 Legge il file descriptor sottostante lo stream \param{stream}.
1316 \bodydesc{Restituisce il numero del file descriptor in caso di successo, e
1317 -1 qualora \param{stream} non sia valido, nel qual caso setta \var{errno}
1320 \noindent ed in questo modo diventa possibile usare direttamente \func{fcntl}.
1322 Questo permette di accedere agli attributi del file descriptor sottostante lo
1323 stream, ma non ci da nessuna informazione riguardo alle proprietà dello stream
1324 medesimo. Le \acr{glibc} però supportano alcune estensioni derivate da
1325 Solaris, che permettono di ottenere informazioni utili.
1327 Ad esempio in certi casi può essere necessario sapere se un certo stream è
1328 accessibile in lettura o scrittura. In genere questa informazione non è
1329 disponibile, e si deve ricordare come il file è stato aperto. La cosa può
1330 essere complessa se le operazioni vengono effettuate in una subroutine, che a
1331 questo punto necessiterà di informazioni aggiuntive rispetto al semplice
1332 puntatore allo stream; questo può essere evitato con le due funzioni
1333 \func{\_\_freadable} e \func{\_\_fwritable} i cui prototipi sono:
1335 \headdecl{stdio\_ext.h}
1336 \funcdecl{int \_\_freadable(FILE *stream)}
1337 Restituisce un valore diverso da zero se \param{stream} consente la lettura.
1339 \funcdecl{int \_\_fwritable(FILE *stream)}
1340 Restituisce un valore diverso da zero se \param{stream} consente la
1343 \noindent che permettono di ottenere questa informazione.
1345 Altre due funzioni, \func{\_\_freading} e \func{\_\_fwriting} servono ad un
1346 uso ancora più specialistico, il loro prototipo è:
1348 \headdecl{stdio\_ext.h}
1349 \funcdecl{int \_\_freading(FILE *stream)}
1350 Restituisce un valore diverso da zero se \param{stream} è aperto in sola
1351 lettura o se l'ultima operazione è stata di lettura.
1353 \funcdecl{int \_\_fwriting(FILE *stream)}
1354 Restituisce un valore diverso da zero se \param{stream} è aperto in sola
1355 scrittura o se l'ultima operazione è stata di scrittura.
1358 Le due funzioni hanno lo scopo di determinare di che tipo è stata l'ultima
1359 operazione eseguita su uno stream aperto in lettura/scrittura; ovviamente se
1360 uno stream è aperto in sola lettura (o sola scrittura) la modalità dell'ultima
1361 operazione è sempre determinata; l'unica ambiguità è quando non sono state
1362 ancora eseguite operazioni, in questo caso le funzioni rispondono come se
1363 una operazione ci fosse comunque stata.
1365 La conoscenza dell'ultima operazione effettuata su uno stream aperto in
1366 lettura/scrittura è utile in quanto permette di trarre conclusioni sullo stato
1367 del buffer e del suo contenuto.
1370 \subsection{Il controllo della bufferizzazione}
1371 \label{sec:file_buffering_ctrl}
1373 Come accennato in \secref{sec:file_buffering} le librerie definiscono una
1374 serie di funzioni che permettono di controllare il comportamento degli stream;
1375 se non si è specificato nulla la modalità di buffering viene decisa
1376 autonomamente sulla base del tipo di file sottostante, ed i buffer vengono
1377 allocati automaticamente.
1379 Però una volta che si sia aperto lo stream (ma prima di aver compiuto
1380 operazioni su di esso) è possibile intervenire sulle modalità di buffering; la
1381 funzione che permette di controllare la bufferizzazione è \func{setvbuf}, il
1383 \begin{prototype}{stdio.h}{int setvbuf(FILE *stream, char *buf, int mode,
1386 Setta la bufferizzazione dello stream \param{stream} nella modalità indicata
1387 da \param{mode}, usando \param{buf} come buffer di lunghezza \param{size}.
1389 \bodydesc{Restituisce zero in caso di successo, ed un valore qualunque in
1393 La funzione permette di controllare tutti gli aspetti della bufferizzazione;
1394 l'utente può specificare un buffer da usare al posto di quello allocato dal
1395 sistema passandone alla funzione l'indirizzo in \param{buf} e la dimensione in
1398 Ovviamente se si usa un buffer specificato dall'utente questo deve essere
1399 stato allocato e restare disponibile per tutto il tempo in cui si opera sullo
1400 stream. In genere conviene allocarlo con \func{malloc} e disallocarlo dopo la
1401 chiusura del file; ma fintanto che il file è usato all'interno di una
1402 funzione, può anche essere usata una variabile automatica. In \file{stdio.h}
1403 definita la macro \macro{BUFSIZ}, che indica le dimensioni generiche del
1404 buffer di uno stream; queste vengono usate dalla funzione \func{setbuf},
1405 questa però non è detto corrisponda in tutti i casi al valore ottimale (che
1406 può variare a seconda del dispositivo).
1408 Dato che la procedura di allocazione manuale è macchinosa, comporta dei rischi
1409 (come delle scritture accidentali sul buffer) e non assicura la scelta delle
1410 dimensioni ottimali, è sempre meglio lasciare allocare il buffer alle funzioni
1411 di librerie, che sono in grado di farlo in maniera ottimale e trasparente
1412 all'utente (in quanto la disallocazione avviene automaticamente). Inoltre
1413 siccome alcune implementazioni usano parte del buffer per mantenere delle
1414 informazioni di controllo, non è detto che le dimensioni dello stesso
1415 coincidano con le dimensioni con cui viene effettuato l'I/O.
1417 Per evitare che \func{setvbuf} setti il buffer basta passare un valore
1418 \macro{NULL} per \param{buf} e la funzione ignorerà il parametro \param{size}
1419 usando il buffer allocato automaticamente dal sistema. Si potrà comunque
1420 modificare la modalità di bufferizzazione, passando in \param{mode} uno degli
1421 opportuni valori elencati in \ntab. Qualora si specifichi la modalità non
1422 bufferizzata i valori di \param{buf} e \param{size} vengono sempre ignorati.
1426 \begin{tabular}[c]{|l|l|}
1428 \textbf{Valore} & \textbf{Modalità} \\
1431 \macro{\_IONBF} & \textit{unbuffered}\\
1432 \macro{\_IOLBF} & \textit{line buffered}\\
1433 \macro{\_IOFBF} & \textit{fully buffered}\\
1436 \label{tab:file_stream_buf_mode}
1437 \caption{Valori del parametro \param{mode} di \func{setvbuf}
1438 per il settaggio delle modalità di bufferizzazione.}
1441 Oltre a \func{setvbuf} le \acr{glibc} definiscono altre tre funzioni per la
1442 gestione della bufferizzazione di uno stream: \func{setbuf}, \func{setbuffer}
1443 e \func{setlinebuf}, i loro prototipi sono:
1447 \funcdecl{void setbuf(FILE *stream, char *buf)} Disabilita la
1448 bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \param{buf}
1449 come buffer di dimensione \macro{BUFSIZ} in modalità \textit{fully buffered}.
1451 \funcdecl{void setbuffer(FILE *stream, char *buf, size\_t size)} Disabilita
1452 la bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \param{buf}
1453 come buffer di dimensione \param{size} in modalità \textit{fully buffered}.
1455 \funcdecl{void setlinebuf(FILE *stream)} Pone lo stream in modalità
1456 \textit{line buffered}.
1458 \noindent tutte queste funzioni sono realizzate con opportune chiamate a
1459 \func{setvbuf} e sono definite solo per compatibilità con le vecchie librerie
1460 BSD. Infine le \acr{glibc} provvedono le funzioni non standard\footnote{anche
1461 queste sono originarie di Solaris} \func{\_\_flbf} e \func{\_\_fbufsize} che
1462 permettono di leggere le proprietà di bufferizzazione di uno stream; i cui
1465 \headdecl{stdio\_ext.h}
1467 \funcdecl{int \_\_flbf(FILE *stream)} Restituisce un valore diverso da zero
1468 se \param{stream} è in modalità \textit{line buffered}.
1470 \funcdecl{size\_t \_\_fbufsize(FILE *stream)} Restituisce le dimensioni del
1471 buffer di \param{stream}.
1474 Come già accennato, indipendentemente dalla modalità di bufferizzazione
1475 scelta, si può forzare lo scarico dei dati sul file con la funzione
1476 \func{fflush}, il suo prototipo è:
1477 \begin{prototype}{stdio.h}{int fflush(FILE *stream)}
1479 Forza la scrittura di tutti i dati bufferizzati dello stream \param{stream}.
1481 \bodydesc{Restituisce zero in caso di successo, ed \macro{EOF} in caso di
1482 errore, settando \var{errno} a \macro{EBADF} se \param{stream} non è
1483 aperto o non è aperto in scrittura, o ad uno degli errori di
1486 \noindent anche di questa funzione esiste una analoga
1487 \func{fflush\_unlocked}\footnote{accessibile definendo \macro{\_BSD\_SOURCE} o
1488 \macro{\_SVID\_SOURCE} o \macro{\_GNU\_SOURCE}} che non effettua il blocco
1491 Se \param{stream} è \macro{NULL} lo scarico dei dati è forzato per tutti gli
1492 stream aperti. Esistono però circostanze, ad esempio quando si vuole essere
1493 sicuri che sia stato eseguito tutto l'output su terminale, in cui serve poter
1494 effettuare lo scarico dei dati solo per gli stream in modalità line buffered;
1495 per questo motivo le \acr{glibc} supportano una estensione di Solaris, la
1496 funzione \func{\_flushlbf}, il cui prototipo è:
1497 \begin{prototype}{stdio-ext.h}{void \_flushlbf(void)}
1498 Forza la scrittura di tutti i dati bufferizzati degli stream in modalità
1502 Si ricordi comunque che lo scarico dei dati dai buffer effettuato da queste
1503 funzioni non comporta la scrittura di questi su disco; se si vuole che il
1504 kernel dia effettivamente avvio alle operazioni di scrittura su disco occorre
1505 usare \func{sync} o \func{fsync} (si veda~\secref{sec:file_sync}).
1507 Infine esistono anche circostanze in cui si vuole scartare tutto l'output
1508 pendente, per questo si può usare \func{fpurge}, il cui prototipo è:
1509 \begin{prototype}{stdio.h}{int fpurge(FILE *stream)}
1511 Cancella i buffer di input e di output dello stream \param{stream}.
1513 \bodydesc{Restituisce zero in caso di successo, ed \macro{EOF} in caso di
1517 La funzione scarta tutti i dati non ancora scritti (se il file è aperto in
1518 scrittura), e tutto l'input non ancora letto (se è aperto in lettura),
1519 compresi gli eventuali caratteri rimandati indietro con \func{ungetc}.
1522 \subsection{Gli stream e i thread}
1523 \label{sec:file_stream_thread}
1525 Gli stream possono essere usati in applicazioni multi-thread allo stesso
1526 modo in cui sono usati nelle applicazioni normali, ma si deve essere
1527 consapevoli delle possibili complicazioni anche quando non si usano i
1528 thread, dato che l'implementazione delle librerie è influenzata
1529 pesantemente dalle richieste necessarie per garantirne l'uso coi thread.
1531 Lo standard POSIX richiede che le operazioni sui file siano atomiche rispetto
1532 ai thread, per questo le operazioni sui buffer effettuate dalle funzioni di
1533 libreria durante la lettura e la scrittura di uno stream devono essere
1534 opportunamente protette (in quanto il sistema assicura l'atomicità solo per le
1535 system call). Questo viene fatto associando ad ogni stream un opportuno blocco
1536 che deve essere implicitamente acquisito prima dell'esecuzione di qualunque
1539 Ci sono comunque situazioni in cui questo non basta, come quando un thread
1540 necessita di compiere più di una operazione sullo stream atomicamente, per
1541 questo motivo le librerie provvedono anche delle funzioni che permettono la
1542 gestione esplicita dei blocchi sugli stream; queste funzioni sono disponibili
1543 definendo \macro{\_POSIX\_THREAD\_SAFE\_FUNCTIONS} ed i loro prototipi sono:
1547 \funcdecl{void flockfile(FILE *stream)} Esegue l'acquisizione del
1548 lock dello stream \param{stream}, bloccandosi in caso il lock non
1551 \funcdecl{int ftrylockfile(FILE *stream)} Tenta l'acquisizione del
1552 lock dello stream \param{stream}, senza bloccarsi in caso il lock non sia
1553 disponibile. Ritorna zero in caso di acquisizione del lock, diverso da
1556 \funcdecl{void funlockfile(FILE *stream)} Rilascia il lock dello
1557 stream \param{stream}.
1559 \noindent con queste funzioni diventa possibile acquisire un blocco ed
1560 eseguire tutte le operazioni volute, per poi rilasciarlo.
1562 Ma, vista la complessità delle strutture di dati coinvolte, le operazioni di
1563 blocco non sono del tutto indolori, e quando il locking dello stream non è
1564 necessario (come in tutti i programmi che non usano i thread), tutta la
1565 procedura può comportare dei costi pesanti in termini di prestazioni. Per
1566 questo motivo abbiamo visto come alle usuali funzioni di I/O non formattato
1567 siano associate delle versioni \code{\_unlocked} (alcune previste dallo stesso
1568 standard POSIX, altre aggiunte come estensioni dalle \acr{glibc}) che possono
1569 essere usate quando il locking non serve\footnote{in certi casi dette funzioni
1570 possono essere usate, visto che sono molto più efficienti, anche in caso di
1571 necessità di locking, una volta che questo sia stato acquisito manualmente.}
1572 con prestazioni molto più elevate, dato che spesso queste versioni (come
1573 accade per \func{getc} e \func{putc}) sono realizzate come macro.
1575 La sostituzione di tutte le funzioni di I/O con le relative versioni
1576 \code{\_unlocked} in un programma che non usa i thread è però un lavoro
1577 abbastanza noioso; per questo motivo le \acr{glibc} provvedono al
1578 programmatore pigro un'altra via\footnote{anche questa mutuata da estensioni
1579 introdotte in Solaris.} da poter utilizzare per disabilitare in blocco il
1580 locking degli stream: l'uso della funzione \func{\_\_fsetlocking}, il cui
1582 \begin{prototype}{stdio\_ext.h}{int \_\_fsetlocking (FILE *stream, int type)}
1583 Specifica o richiede a seconda del valore di \param{type} la modalità in cui
1584 le operazioni di I/O su \param{stream} vengono effettuate rispetto
1585 all'acquisizione implicita del blocco sullo stream.
1587 \bodydesc{Restituisce lo stato di locking interno dello stream con uno dei
1588 valori \macro{FSETLOCKING\_INTERNAL} o \macro{FSETLOCKING\_BYCALLER}.}
1591 La funzione setta o legge lo stato della modalità di operazione di uno stream
1592 nei confronti del locking a seconda del valore specificato con \param{type},
1593 che può essere uno dei seguenti:
1594 \begin{basedescript}{\desclabelwidth{4.0cm}}
1595 \item[\macro{FSETLOCKING\_INTERNAL}] Lo stream userà da ora in poi il blocco
1596 implicito di default.
1597 \item[\macro{FSETLOCKING\_BYCALLER}] Al ritorno della funzione sarà l'utente a
1598 dover gestire da solo il locking dello stream.
1599 \item[\macro{FSETLOCKING\_QUERY}] Restituisce lo stato corrente della modalità
1600 di blocco dello stream.
1604 %%% Local Variables:
1606 %%% TeX-master: "gapil"