\subsection{I \textit{file stream}}
\label{sec:file_stream}
-Come più volte ribadito l'interfaccia dei file descriptor è una interfaccia di
+Come più volte ribadito l'interfaccia dei file descriptor è un'interfaccia di
basso livello, che non provvede nessuna forma di formattazione dei dati e
nessuna forma di bufferizzazione per ottimizzare le operazioni di I/O.
-In \textit{Advanced Programming in the Unix Environment} Stevens descrive una
-serie di test sull'influenza delle dimensioni del blocco di dati (il parametro
-\param{buf} di \func{read} e \func{write}) nell'efficienza nelle operazioni di
-I/O con i file descriptor, evidenziando come le prestazioni ottimali si
-ottengano a partire da dimensioni del buffer dei dati pari a quelle dei
-blocchi del filesystem (il valore dato dal campo \var{st\_blksize} di
-\var{fstat}).
+In \cite{APUE} Stevens descrive una serie di test sull'influenza delle
+dimensioni del blocco di dati (il parametro \param{buf} di \func{read} e
+\func{write}) nell'efficienza nelle operazioni di I/O con i file descriptor,
+evidenziando come le prestazioni ottimali si ottengano a partire da dimensioni
+del buffer dei dati pari a quelle dei blocchi del filesystem (il valore dato
+dal campo \var{st\_blksize} di \var{fstat}).
Se il programmatore non si cura di effettuare le operazioni in blocchi di
dimensioni adeguate, le prestazioni sono inferiori. La caratteristica
\secref{sec:file_access_control} per il controllo di accesso.
-\subsection{Gli oggetti \type{FILE}}
+\subsection{Gli oggetti \ctyp{FILE}}
\label{sec:file_FILE}
Per ragioni storiche la struttura di dati che rappresenta uno stream è stata
-chiamata \type{FILE}, questi oggetti sono creati dalle funzioni di libreria e
+chiamata \ctyp{FILE}, questi oggetti sono creati dalle funzioni di libreria e
contengono tutte le informazioni necessarie a gestire le operazioni sugli
stream, come la posizione corrente, lo stato del buffer e degli indicatori di
stato e di fine del file.
Per questo motivo gli utenti non devono mai utilizzare direttamente o
-allocare queste strutture, ma usare sempre puntatori del tipo \type{FILE
+allocare queste strutture, ma usare sempre puntatori del tipo \ctyp{FILE
*} ottenuti dalla libreria stessa (tanto che in certi casi il termine
di puntatore a file è diventato sinonimo di stream). Tutte le funzioni
della libreria che operano sui file accettano come parametri solo
questi tre stream sono identificabili attraverso dei nomi simbolici
definiti nell'header \file{stdio.h} che sono:
-\begin{itemize}
-\item \var{FILE *stdin} Lo \textit{standard input} cioè lo stream da
+\begin{basedescript}{\desclabelwidth{3.0cm}}
+\item[\var{FILE *stdin}] Lo \textit{standard input} cioè lo stream da
cui il processo riceve ordinariamente i dati in ingresso. Normalmente
è associato dalla shell all'input del terminale e prende i caratteri
dalla tastiera.
-\item \var{FILE *stdout} Lo \textit{standard input} cioè lo stream su
+\item[\var{FILE *stdout}] Lo \textit{standard output} cioè lo stream su
cui il processo invia ordinariamente i dati in uscita. Normalmente è
associato dalla shell all'output del terminale e scrive sullo schermo.
-\item \var{FILE *stderr} Lo \textit{standard input} cioè lo stream su
+\item[\var{FILE *stderr}] Lo \textit{standard error} cioè lo stream su
cui il processo è supposto inviare i messaggi di errore. Normalmente
anch'esso è associato dalla shell all'output del terminale e scrive
sullo schermo.
-\end{itemize}
+\end{basedescript}
Nelle \acr{glibc} \var{stdin}, \var{stdout} e \var{stderr} sono
-effettivamente tre variabili di tipo \type{FILE *} che possono essere
+effettivamente tre variabili di tipo \ctyp{FILE *} che possono essere
usate come tutte le altre, ad esempio si può effettuare una redirezione
dell'output di un programma con il semplice codice:
\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
interfaccia degli stream; lo scopo è quello di ridurre al minimo il
numero di system call (\func{read} o \func{write}) eseguite nelle
operazioni di input/output. Questa funzionalità è assicurata
-automaticamente dalla libreria, ma costituisce anche una degli aspetti
+automaticamente dalla libreria, ma costituisce anche uno degli aspetti
più comunemente fraintesi, in particolare per quello che riguarda
l'aspetto della scrittura dei dati sul file.
non fanno riferimento ad un dispositivo interattivo, e che lo standard
error non sia mai aperto in modalità \textit{fully buffered}.
-Linux, come BSD e SVr4, specifica il comportamento di default in maniera
+Linux, come BSD e SVr4, specifica il comportamento predefinito in maniera
ancora più precisa, e cioè impone che lo standard error sia sempre
\textit{unbuffered} (in modo che i messaggi di errore siano mostrati il più
rapidamente possibile) e che standard input e standard output siano aperti in
\subsection{Apertura e chiusura di uno stream}
\label{sec:file_fopen}
-Le funzioni che si possono usare per aprire uno stream sono solo
-tre\footnote{\func{fopen} e \func{freopen} fanno parte dello standard
- ANSI C, \func{fdopen} è parte dello standard POSIX.1.}, i loro
-prototipi sono:
+Le funzioni che si possono usare per aprire uno stream sono solo tre:
+\func{fopen}, \func{fdopen} e \func{freopen},\footnote{\func{fopen} e
+ \func{freopen} fanno parte dello standard ANSI C, \func{fdopen} è parte
+ dello standard POSIX.1.} i loro prototipi sono:
\begin{functions}
\headdecl{stdio.h}
\funcdecl{FILE *fopen(const char *path, const char *mode)}
\bodydesc{Le funzioni ritornano un puntatore valido in caso di
successo e \macro{NULL} in caso di errore, in tal caso \var{errno}
- viene settata al valore ricevuto dalla funzione sottostante di cui è
+ viene impostata al valore ricevuto dalla funzione sottostante di cui è
fallita l'esecuzione.
Gli errori pertanto possono essere quelli di \code{malloc} per tutte
\begin{table}[htb]
\centering
+ \footnotesize
\begin{tabular}[c]{|l|p{8cm}|}
\hline
\textbf{Valore} & \textbf{Significato}\\
\texttt{a+} & Il file viene aperto (o creato se non esiste) in
\textit{append mode}, l'accesso viene posto in lettura e scrittura. \\
\hline
+ \texttt{b} & specifica che il file è binario, non ha alcun effetto. \\
+ \texttt{x} & la apertura fallisce se il file esiste già. \\
+ \hline
\end{tabular}
\caption{Modalità di apertura di uno stream dello standard ANSI C che
- sono sempre presenti in qualunque sistema POSIX}
+ sono sempre presenti in qualunque sistema POSIX.}
\label{tab:file_fopen_mode}
\end{table}
Nel caso si usi \func{fdopen} i valori specificati da \param{mode} devono
essere compatibili con quelli con cui il file descriptor è stato aperto.
Inoltre i modi \cmd{w} e \cmd{w+} non troncano il file. La posizione nello
-stream viene settata a quella corrente nel file descriptor, e le variabili di
+stream viene impostata a quella corrente nel file descriptor, e le variabili di
errore e di fine del file (vedi \secref{sec:file_io}) sono cancellate. Il file
non viene duplicato e verrà chiuso alla chiusura dello stream.
I nuovi file saranno creati secondo quanto visto in
-\secref{sec:file_ownership} ed avranno i permessi di accesso settati al
+\secref{sec:file_ownership} ed avranno i permessi di accesso impostati al
valore \macro{S\_IRUSR|S\_IWUSR|S\_IRGRP|S\_IWGRP|S\_IROTH|S\_IWOTH}
(pari a \macro{0666}) modificato secondo il valore di \acr{umask} per il
processo (si veda \secref{sec:file_umask}).
In caso di file aperti in lettura e scrittura occorre ricordarsi che c'è
-di messo una bufferizzazione; per questo motivo lo standard ANSI C
-richiede che ci sia una operazione di posizionamento fra una operazione
+di mezzo una bufferizzazione; per questo motivo lo standard ANSI C
+richiede che ci sia un'operazione di posizionamento fra un'operazione
di output ed una di input o viceversa (eccetto il caso in cui l'input ha
incontrato la fine del file), altrimenti una lettura può ritornare anche
il risultato di scritture precedenti l'ultima effettuata.
\func{rewind} prima di eseguire una rilettura; viceversa nel caso in cui si
voglia fare una scrittura subito dopo aver eseguito una lettura occorre prima
usare una delle funzioni \func{fseek}, \func{fsetpos} o \func{rewind}. Anche
-una operazione nominalmente nulla come \code{fseek(file, 0, SEEK\_CUR)} è
+un'operazione nominalmente nulla come \code{fseek(file, 0, SEEK\_CUR)} è
sufficiente a garantire la sincronizzazione.
Una volta aperto lo stream, si può cambiare la modalità di bufferizzazione
Chiude lo stream \param{stream}.
\bodydesc{Restituisce 0 in caso di successo e \macro{EOF} in caso di errore,
- nel qual caso setta \var{errno} a \macro{EBADF} se il file descriptor
+ nel qual caso imposta \var{errno} a \macro{EBADF} se il file descriptor
indicato da \param{stream} non è valido, o uno dei valori specificati
dalla sottostante funzione che è fallita (\func{close}, \func{write} o
\func{fflush}).}
raggiungimento della fine del file è 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 \type{int}) \macro{EOF}\footnote{la costante deve essere
+intero (di tipo \ctyp{int}) \macro{EOF}\footnote{la costante deve essere
negativa, le \acr{glibc} usano -1, altre implementazioni possono avere
valori diversi.} definito anch'esso nell'header \file{stdlib.h}.
Dato che le funzioni dell'interfaccia degli stream sono funzioni di libreria
-che si appoggiano a delle system call, esse non settano direttamente la
-variabile \var{errno}, che mantiene il valore settato dalla system call che ha
+che si appoggiano a delle system call, esse non impostano direttamente la
+variabile \var{errno}, che mantiene il valore impostato dalla system call che ha
riportato l'errore.
Siccome la condizione di 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 settato in una
+infatti non basta, dato che quest'ultimo potrebbe essere stato impostato in una
altra occasione, (si veda \secref{sec:sys_errno} per i dettagli del
funzionamento di \var{errno}).
Per questo motivo tutte le implementazioni delle librerie standard
mantengono per ogni stream almeno due flag all'interno dell'oggetto
-\type{FILE}, il flag di \textit{end-of-file}, che segnala che si è
+\ctyp{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:
Controlla il flag di errore di \param{stream}.
\bodydesc{Entrambe le funzioni ritornano un valore diverso da zero se
- i relativi flag sono settati.}
+ i relativi flag sono impostati.}
\end{functions}
\noindent 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
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:
+%\footnotesize
\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
int WriteVect(FILE *stream, double *vec, size_t nelem)
{
return nread;
}
\end{lstlisting}
+%\normalsize
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;
si avrà allora una chiamata tipo:
+%\footnotesize
\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
struct histogram {
int nbins;
return nread;
}
\end{lstlisting}
+%\normalsize
in cui si specifica la dimensione dell'intera struttura ed un solo
elemento.
La funzione \func{fread} legge sempre un numero intero di elementi, se
incontra la fine del file l'oggetto letto parzialmente viene scartato
(lo stesso avviene in caso di errore). In questo caso la posizione dello
-stream viene settata alla fine del file (e non a quella corrispondente
+stream viene impostata alla fine del file (e non a quella corrispondente
alla quantità di dati letti).
In caso di errore (o fine del file per \func{fread}) entrambe le
\funcdecl{int getc(FILE *stream)} Legge un byte da \param{stream} e lo
restituisce come intero. In genere è implementata come una macro.
-
+
\funcdecl{int fgetc(FILE *stream)} Legge un byte da \param{stream} e lo
- restituisce come intero. È una sempre una funzione.
+ restituisce come intero. È sempre una funzione.
\funcdecl{int getchar(void)} Equivalente a \code{getc(stdin)}.
le si passa come argomento, infatti \param{stream} può essere valutato
più volte nell'esecuzione, e non viene passato in copia con il
meccanismo visto in \secref{sec:proc_var_passing}; per questo motivo se
-si passa una espressione si possono avere effetti indesiderati.
+si passa un'espressione si possono avere effetti indesiderati.
Invece \func{fgetc} è assicurata essere sempre una funzione, per questo
motivo la sua esecuzione normalmente è più lenta per via dell'overhead
essere passato come parametro ad un altra funzione (e non si hanno i
problemi accennati in precedenza con \param{stream}).
-Le tre funzioni restituiscono tutte un \type{unsigned char} convertito
-ad \type{int} (si usa \type{unsigned char} in modo da evitare
+Le tre funzioni restituiscono tutte un \ctyp{unsigned char} convertito
+ad \ctyp{int} (si usa \ctyp{unsigned char} in modo da evitare
l'espansione del segno). In questo modo il valore di ritorno è sempre
positivo, tranne in caso di errore o fine del file.
Nelle estensioni GNU che provvedono la localizzazione sono definite tre
funzioni equivalenti alle precedenti che invece di un carattere di un
byte restituiscono un carattere in formato esteso (cioè di tipo
-\type{wint\_t}, il loro prototipo è:
+\ctyp{wint\_t}, il loro prototipo è:
\begin{functions}
\headdecl{stdio.h}
\headdecl{wchar.h}
\end{functions}
Tutte queste funzioni scrivono sempre un byte alla volta, anche se
-prendono come parametro un \type{int} (che pertanto deve essere ottenuto
-con un cast da un \type{unsigned char}). Anche il valore di ritorno è
+prendono come parametro un \ctyp{int} (che pertanto deve essere ottenuto
+con un cast da un \ctyp{unsigned char}). Anche il valore di ritorno è
sempre un intero; in caso di errore o fine del file il valore di ritorno
è \macro{EOF}.
stream.
Per compatibilità con SVID sono provviste anche due funzioni per leggere
-e scrivere una \textit{word} (che è sempre definita come \type{int}); i
+e scrivere una \textit{word} (che è sempre definita come \ctyp{int}); i
loro prototipi sono:
\begin{functions}
\headdecl{stdio.h}
disponibile per una lettura successiva; la funzione che inverte la
lettura si chiama \func{ungetc} ed il suo prototipo è:
\begin{prototype}{stdio.h}{int ungetc(int c, FILE *stream)}
- Rimanda indietro il carattere \param{c}, con un cast a \type{unsigned
+ Rimanda indietro il carattere \param{c}, con un cast a \ctyp{unsigned
char}, sullo stream \param{stream}.
\bodydesc{La funzione ritorna \param{c} in caso di successo e
mentre \func{fgets} aggiunge uno zero dopo il \textit{newline}, che resta
dentro la stringa. Se la lettura incontra la fine del file (o c'è un errore)
viene restituito un \macro{NULL}, ed il buffer \param{buf} non viene toccato.
-
L'uso di \func{gets} è deprecato e deve essere assolutamente evitato; la
funzione infatti non controlla il numero di byte letti, per cui nel caso
la stringa letta superi le dimensioni del buffer, si avrà un
i valori delle variabili, secondo la tecnica spiegata in
\secref{sec:proc_var_passing}).
-Se si passa alla funzione l'indirizzo ad un puntatore settato a
+Se si passa alla funzione l'indirizzo ad un puntatore impostato a
\macro{NULL} e \var{*n} è zero, la funzione provvede da sola
all'allocazione della memoria necessaria a contenere la linea. In tutti
i casi si ottiene dalla funzione un puntatore all'inizio del testo della
La parte più complessa di queste funzioni è il formato della stringa
\param{format} che indica le conversioni da fare, da cui poi deriva il numero
-dei parametri che dovranno essere passati a seguire. La stringa è costituita
-da caratteri normali (tutti eccetto \texttt{\%}), che vengono passati
-invariati all'output, e da direttive di conversione, in cui devono essere
-sempre presenti il carattere \texttt{\%}, che introduce la direttiva, ed uno
-degli specificatori di conversione (riportati in \ntab) che la conclude.
+dei parametri che dovranno essere passati a seguire.
\begin{table}[htb]
\centering
+ \footnotesize
\begin{tabular}[c]{|l|l|p{10cm}|}
\hline
\textbf{Valore} & \textbf{Tipo} & \textbf{Significato} \\
\hline
\hline
- \cmd{\%d} &\type{int} & Stampa un numero intero in formato decimale
+ \cmd{\%d} &\ctyp{int} & Stampa un numero intero in formato decimale
con segno \\
- \cmd{\%i} &\type{int} & Identico a \cmd{\%i} in output, \\
- \cmd{\%o} &\type{unsigned int}& Stampa un numero intero come ottale\\
- \cmd{\%u} &\type{unsigned int}& Stampa un numero intero in formato
+ \cmd{\%i} &\ctyp{int} & Identico a \cmd{\%i} in output, \\
+ \cmd{\%o} &\ctyp{unsigned int}& Stampa un numero intero come ottale\\
+ \cmd{\%u} &\ctyp{unsigned int}& Stampa un numero intero in formato
decimale senza segno \\
\cmd{\%x},
- \cmd{\%X} &\type{unsigned int}& Stampano un intero in formato esadecimale,
+ \cmd{\%X} &\ctyp{unsigned int}& Stampano un intero in formato esadecimale,
rispettivamente con lettere minuscole e
maiuscole. \\
- \cmd{\%f} &\type{unsigned int}& Stampa un numero in virgola mobile con la
+ \cmd{\%f} &\ctyp{unsigned int}& Stampa un numero in virgola mobile con la
notazione a virgola fissa \\
\cmd{\%e},
- \cmd{\%E} &\type{double} & Stampano un numero in virgola mobile con la
+ \cmd{\%E} &\ctyp{double} & Stampano un numero in virgola mobile con la
notazione esponenziale, rispettivamente con
lettere minuscole e maiuscole. \\
\cmd{\%g},
- \cmd{\%G} &\type{double} & Stampano un numero in virgola mobile con la
+ \cmd{\%G} &\ctyp{double} & Stampano un numero in virgola mobile con la
notazione più appropriate delle due precedenti,
rispettivamente con lettere minuscole e
maiuscole. \\
\cmd{\%a},
- \cmd{\%A} &\type{double} & Stampano un numero in virgola mobile in
+ \cmd{\%A} &\ctyp{double} & Stampano un numero in virgola mobile in
notazione esadecimale frazionaria\\
- \cmd{\%c} &\type{int} & Stampa un carattere singolo\\
- \cmd{\%s} &\type{char *} & Stampa una stringa \\
- \cmd{\%p} &\type{void *} & Stampa il valore di un puntatore\\
- \cmd{\%n} &\type{\&int} & Prende il numero di caratteri stampati finora\\
+ \cmd{\%c} &\ctyp{int} & Stampa un carattere singolo\\
+ \cmd{\%s} &\ctyp{char *} & Stampa una stringa \\
+ \cmd{\%p} &\ctyp{void *} & Stampa il valore di un puntatore\\
+ \cmd{\%n} &\ctyp{\&int} & Prende il numero di caratteri stampati finora\\
\cmd{\%\%}& & Stampa un \% \\
\hline
\end{tabular}
\label{tab:file_format_spec}
\end{table}
+La stringa è costituita da caratteri normali (tutti eccetto \texttt{\%}), che
+vengono passati invariati all'output, e da direttive di conversione, in cui
+devono essere sempre presenti il carattere \texttt{\%}, che introduce la
+direttiva, ed uno degli specificatori di conversione (riportati in
+\tabref{tab:file_format_spec}) che la conclude.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|p{10cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \cmd{\#} & Chiede la conversione in forma alternativa. \\
+ \cmd{0} & La conversione è riempita con zeri alla sinistra del valore.\\
+ \cmd{-} & La conversione viene allineata a sinistra sul bordo del campo.\\
+ \cmd{' '}& Mette uno spazio prima di un numero con segno di valore
+ positivo\\
+ \cmd{+} & Mette sempre il segno ($+$ o $-$) prima di un numero.\\
+ \hline
+ \end{tabular}
+ \caption{I valori dei flag per il formato di \func{printf}}
+ \label{tab:file_format_flag}
+\end{table}
+
Il formato di una direttiva di conversione prevede una serie di possibili
elementi opzionali oltre al \cmd{\%} e allo specificatore di conversione. In
generale essa è sempre del tipo:
\end{itemize*}
-\begin{table}[htb]
- \centering
- \begin{tabular}[c]{|l|p{10cm}|}
- \hline
- \textbf{Valore} & \textbf{Significato}\\
- \hline
- \hline
- \cmd{\#} & Chiede la conversione in forma alternativa. \\
- \cmd{0} & La conversione è riempita con zeri alla sinistra del valore.\\
- \cmd{-} & La conversione viene allineata a sinistra sul bordo del campo.\\
- \cmd{' '}& Mette uno spazio prima di un numero con segno di valore
- positivo\\
- \cmd{+} & Mette sempre il segno ($+$ o $-$) prima di un numero.\\
- \hline
- \end{tabular}
- \caption{I valori dei flag per il formato di \func{printf}}
- \label{tab:file_format_flag}
-\end{table}
-
-Dettagli ulteriori sulle varie opzioni possono essere trovati nella man page
-di \func{printf} e nella documentazione delle \acr{glibc}.
+Dettagli ulteriori sulle varie opzioni possono essere trovati nella pagina di
+manuale di \func{printf} e nella documentazione delle \acr{glibc}.
\begin{table}[htb]
\centering
+ \footnotesize
\begin{tabular}[c]{|l|p{10cm}|}
\hline
\textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \cmd{hh} & una conversione intera corrisponde a un \type{char} con o senza
+ \cmd{hh} & una conversione intera corrisponde a un \ctyp{char} con o senza
segno, o il puntatore per il numero dei parametri \cmd{n} è di
- tipo \type{char}.\\
- \cmd{h} & una conversione intera corrisponde a uno \type{short} con o
+ tipo \ctyp{char}.\\
+ \cmd{h} & una conversione intera corrisponde a uno \ctyp{short} con o
senza segno, o il puntatore per il numero dei parametri \cmd{n}
- è di tipo \type{short}.\\
- \cmd{l} & una conversione intera corrisponde a un \type{long} con o
+ è di tipo \ctyp{short}.\\
+ \cmd{l} & una conversione intera corrisponde a un \ctyp{long} con o
senza segno, o il puntatore per il numero dei parametri \cmd{n}
- è di tipo \type{long}, o il carattere o la stringa seguenti
+ è di tipo \ctyp{long}, o il carattere o la stringa seguenti
sono in formato esteso.\\
- \cmd{ll} & una conversione intera corrisponde a un \type{long long} con o
+ \cmd{ll} & una conversione intera corrisponde a un \ctyp{long long} con o
senza segno, o il puntatore per il numero dei parametri \cmd{n}
- è di tipo \type{long long}.\\
+ è di tipo \ctyp{long long}.\\
\cmd{L} & una conversione in virgola mobile corrisponde a un
- \type{double}.\\
+ \ctyp{double}.\\
\cmd{q} & sinonimo di \cmd{ll}.\\
\cmd{j} & una conversione intera corrisponde a un \type{intmax\_t} o
\type{uintmax\_t}.\\
l'indirizzo di un puntatore ad una stringa di caratteri, in cui verrà
restituito (si ricordi quanto detto in \secref{sec:proc_var_passing} a
proposito dei \textit{value result argument}) l'indirizzo della stringa
-allogata automaticamente dalle funzioni. Occorre inoltre ricordarsi di
+allocata automaticamente dalle funzioni. Occorre inoltre ricordarsi di
invocare \func{free} per liberare detto puntatore quando la stringa non serve
più, onde evitare memory leak.
separazione (che possono essere spazi, tabulatori, virgole etc.), mentre
caratteri diversi richiedono una corrispondenza esatta. Le direttive di
conversione sono analoghe a quelle di \func{printf} e si trovano descritte in
-dettaglio nelle man page e nel manuale delle \acr{glibc}.
+dettaglio nelle pagine di manuale e nel manuale delle \acr{glibc}.
Le funzioni eseguono la lettura dall'input, scartano i separatori (e gli
eventuali caratteri diversi indicati dalla stringa di formato) effettuando le
\bodydesc{La funzione restituisce la posizione corrente, o -1 in caso
di fallimento, che può esser dovuto sia al fatto che il file non
supporta il riposizionamento che al fatto che la posizione non può
- essere espressa con un \type{long int}}
+ essere espressa con un \ctyp{long int}}
\end{prototype}
\noindent la funzione restituisce la posizione come numero di byte
dall'inizio dello stream.
\begin{functions}
\headdecl{stdio.h}
- \funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Setta la posizione
+ \funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Imposta la posizione
corrente nello stream \param{stream} al valore specificato da \param{pos}.
\funcdecl{int fgetpos(FILE *stream, fpos\_t *pos)} Scrive la posizione
errore.}
\end{functions}
-In Linux, a partire dalle glibc 2.1, sono presenti anche le funzioni
-\func{fseeko} e \func{ftello}, assolutamente identiche alle precedenti ma con
-argomenti di tipo \type{off\_t} anziché di tipo \type{long int}.
+In Linux, a partire dalle glibc 2.1, sono presenti anche le due funzioni
+\func{fseeko} e \func{ftello}, che assolutamente identiche alle precedenti
+\func{fseek} e \func{ftell} ma hanno argomenti di tipo \type{off\_t} anziché
+di tipo \ctyp{long int}.
Legge il file descriptor sottostante lo stream \param{stream}.
\bodydesc{Restituisce il numero del file descriptor in caso di successo, e
- -1 qualora \param{stream} non sia valido, nel qual caso setta \var{errno}
+ -1 qualora \param{stream} non sia valido, nel qual caso imposta \var{errno}
a \macro{EBADF}.}
\end{prototype}
\noindent ed in questo modo diventa possibile usare direttamente \func{fcntl}.
\end{functions}
\noindent che permettono di ottenere questa informazione.
-Altre due funzioni, \func{\_\_freading} e \func{\_\_fwriting} servono ad un
-uso ancora più specialistico, il loro prototipo è:
+La conoscenza dell'ultima operazione effettuata su uno stream aperto è utile
+in quanto permette di trarre conclusioni sullo stato del buffer e del suo
+contenuto. Altre due funzioni, \func{\_\_freading} e \func{\_\_fwriting}
+servono a tale scopo, il loro prototipo è:
\begin{functions}
\headdecl{stdio\_ext.h}
\funcdecl{int \_\_freading(FILE *stream)}
scrittura o se l'ultima operazione è stata di scrittura.
\end{functions}
-Le due funzioni hanno lo scopo di determinare di che tipo è stata l'ultima
+Le due funzioni permettono di determinare di che tipo è stata l'ultima
operazione eseguita su uno stream aperto in lettura/scrittura; ovviamente se
uno stream è aperto in sola lettura (o sola scrittura) la modalità dell'ultima
operazione è sempre determinata; l'unica ambiguità è quando non sono state
-ancora eseguite operazioni, in questo caso le funzioni rispondono come se
-una operazione ci fosse comunque stata.
-
-La conoscenza dell'ultima operazione effettuata su uno stream aperto in
-lettura/scrittura è utile in quanto permette di trarre conclusioni sullo stato
-del buffer e del suo contenuto.
+ancora eseguite operazioni, in questo caso le funzioni rispondono come se una
+operazione ci fosse comunque stata.
\subsection{Il controllo della bufferizzazione}
\begin{prototype}{stdio.h}{int setvbuf(FILE *stream, char *buf, int mode,
size\_t size)}
- Setta la bufferizzazione dello stream \param{stream} nella modalità indicata
- da \param{mode}, usando \param{buf} come buffer di lunghezza \param{size}.
+ Imposta la bufferizzazione dello stream \param{stream} nella modalità
+ indicata da \param{mode}, usando \param{buf} come buffer di lunghezza
+ \param{size}.
\bodydesc{Restituisce zero in caso di successo, ed un valore qualunque in
- caso di errore.}
+ caso di errore, nel qual caso \var{errno} viene impostata opportunamente.}
\end{prototype}
La funzione permette di controllare tutti gli aspetti della bufferizzazione;
Dato che la procedura di allocazione manuale è macchinosa, comporta dei rischi
(come delle scritture accidentali sul buffer) e non assicura la scelta delle
dimensioni ottimali, è sempre meglio lasciare allocare il buffer alle funzioni
-di librerie, che sono in grado di farlo in maniera ottimale e trasparente
+di libreria, che sono in grado di farlo in maniera ottimale e trasparente
all'utente (in quanto la disallocazione avviene automaticamente). Inoltre
siccome alcune implementazioni usano parte del buffer per mantenere delle
informazioni di controllo, non è detto che le dimensioni dello stesso
-coincidano con le dimensioni con cui viene effettuato l'I/O.
-
-Per evitare che \func{setvbuf} setti il buffer basta passare un valore
-\macro{NULL} per \param{buf} e la funzione ignorerà il parametro \param{size}
-usando il buffer allocato automaticamente dal sistema. Si potrà comunque
-modificare la modalità di bufferizzazione, passando in \param{mode} uno degli
-opportuni valori elencati in \ntab. Qualora si specifichi la modalità non
-bufferizzata i valori di \param{buf} e \param{size} vengono sempre ignorati.
+coincidano con quelle su cui viene effettuato l'I/O.
\begin{table}[htb]
\centering
+ \footnotesize
\begin{tabular}[c]{|l|l|}
\hline
\textbf{Valore} & \textbf{Modalità} \\
\macro{\_IOFBF} & \textit{fully buffered}\\
\hline
\end{tabular}
- \label{tab:file_stream_buf_mode}
\caption{Valori del parametro \param{mode} di \func{setvbuf}
- per il settaggio delle modalità di bufferizzazione.}
+ per l'impostazione delle modalità di bufferizzazione.}
+ \label{tab:file_stream_buf_mode}
\end{table}
+Per evitare che \func{setvbuf} imposti il buffer basta passare un valore
+\macro{NULL} per \param{buf} e la funzione ignorerà il parametro \param{size}
+usando il buffer allocato automaticamente dal sistema. Si potrà comunque
+modificare la modalità di bufferizzazione, passando in \param{mode} uno degli
+opportuni valori elencati in \tabref{tab:file_stream_buf_mode}. Qualora si
+specifichi la modalità non bufferizzata i valori di \param{buf} e \param{size}
+vengono sempre ignorati.
+
Oltre a \func{setvbuf} le \acr{glibc} definiscono altre tre funzioni per la
gestione della bufferizzazione di uno stream: \func{setbuf}, \func{setbuffer}
e \func{setlinebuf}, i loro prototipi sono:
\noindent tutte queste funzioni sono realizzate con opportune chiamate a
\func{setvbuf} e sono definite solo per compatibilità con le vecchie librerie
BSD. Infine le \acr{glibc} provvedono le funzioni non standard\footnote{anche
- queste sono originarie di Solaris} \func{\_\_flbf} e \func{\_\_fbufsize} che
-permettono di leggere le proprietà di bufferizzazione di uno stream; i cui
-prototipi sono:
+ queste funzioni sono originarie di Solaris.} \func{\_\_flbf} e
+\func{\_\_fbufsize} che permettono di leggere le proprietà di bufferizzazione
+di uno stream; i cui prototipi sono:
\begin{functions}
\headdecl{stdio\_ext.h}
Forza la scrittura di tutti i dati bufferizzati dello stream \param{stream}.
\bodydesc{Restituisce zero in caso di successo, ed \macro{EOF} in caso di
- errore, settando \var{errno} a \macro{EBADF} se \param{stream} non è
+ errore, impostando \var{errno} a \macro{EBADF} se \param{stream} non è
aperto o non è aperto in scrittura, o ad uno degli errori di
\func{write}.}
\end{prototype}
\noindent anche di questa funzione esiste una analoga
\func{fflush\_unlocked}\footnote{accessibile definendo \macro{\_BSD\_SOURCE} o
- \macro{\_SVID\_SOURCE} o \macro{\_GNU\_SOURCE}} che non effettua il blocco
+ \macro{\_SVID\_SOURCE} o \macro{\_GNU\_SOURCE}.} che non effettua il blocco
dello stream.
Se \param{stream} è \macro{NULL} lo scarico dei dati è forzato per tutti gli
valori \macro{FSETLOCKING\_INTERNAL} o \macro{FSETLOCKING\_BYCALLER}.}
\end{prototype}
-La funzione setta o legge lo stato della modalità di operazione di uno stream
+La funzione imposta o legge lo stato della modalità di operazione di uno stream
nei confronti del locking a seconda del valore specificato con \param{type},
che può essere uno dei seguenti:
\begin{basedescript}{\desclabelwidth{4.0cm}}
\item[\macro{FSETLOCKING\_INTERNAL}] Lo stream userà da ora in poi il blocco
- implicito di default.
+ implicito predefinito.
\item[\macro{FSETLOCKING\_BYCALLER}] Al ritorno della funzione sarà l'utente a
dover gestire da solo il locking dello stream.
\item[\macro{FSETLOCKING\_QUERY}] Restituisce lo stato corrente della modalità
projects / gapil.git / blobdiff