-quattro: \funcd{malloc}, \funcd{calloc}, \funcd{realloc} e \funcd{free}, i
-loro prototipi sono i seguenti:
-\begin{functions}
-\headdecl{stdlib.h}
-\funcdecl{void *calloc(size\_t nmemb, size\_t size)}
- Alloca nello \textit{heap} un'area di memoria per un vettore di
- \param{nmemb} membri di \param{size} byte di dimensione. La memoria viene
- inizializzata a 0.
-
- La funzione restituisce il puntatore alla zona di memoria allocata in caso
- di successo e \val{NULL} in caso di fallimento, nel qual caso
- \var{errno} assumerà il valore \errval{ENOMEM}.
-\funcdecl{void *malloc(size\_t size)}
- Alloca \param{size} byte nello \textit{heap}. La memoria non viene
- inizializzata.
-
- La funzione restituisce il puntatore alla zona di memoria allocata in caso
- di successo e \val{NULL} in caso di fallimento, nel qual caso
- \var{errno} assumerà il valore \errval{ENOMEM}.
-\funcdecl{void *realloc(void *ptr, size\_t size)}
- Cambia la dimensione del blocco allocato all'indirizzo \param{ptr}
- portandola a \param{size}.
-
- La funzione restituisce il puntatore alla zona di memoria allocata in caso
- di successo e \val{NULL} in caso di fallimento, nel qual caso
- \var{errno} assumerà il valore \errval{ENOMEM}.
-\funcdecl{void free(void *ptr)}
- Disalloca lo spazio di memoria puntato da \param{ptr}.
-
- La funzione non ritorna nulla e non riporta errori.
-\end{functions}
-Il puntatore ritornato dalle funzioni di allocazione è garantito essere sempre
-allineato correttamente per tutti i tipi di dati; ad esempio sulle macchine a
-32 bit in genere è allineato a multipli di 4 byte e sulle macchine a 64 bit a
-multipli di 8 byte.
-
-In genere si usano le funzioni \func{malloc} e \func{calloc} per allocare
-dinamicamente la quantità di memoria necessaria al programma indicata da
-\param{size},\footnote{queste funzioni presentano un comportamento diverso fra
- le \acr{glibc} e le \acr{uClib} quando il valore di \param{size} è nullo.
- Nel primo caso viene comunque restituito un puntatore valido, anche se non è
- chiaro a cosa esso possa fare riferimento, nel secondo caso viene restituito
- \val{NULL}. Il comportamento è analogo con \code{realloc(NULL, 0)}.} e
-siccome i puntatori ritornati sono di tipo generico non è necessario
-effettuare un cast per assegnarli a puntatori al tipo di variabile per la
-quale si effettua l'allocazione.
-
-La memoria allocata dinamicamente deve essere esplicitamente rilasciata usando
-\func{free}\footnote{le glibc provvedono anche una funzione \func{cfree}
- definita per compatibilità con SunOS, che è deprecata.} una volta che non
-sia più necessaria. Questa funzione vuole come argomento un puntatore
-restituito da una precedente chiamata a una qualunque delle funzioni di
-allocazione che non sia già stato liberato da un'altra chiamata a \func{free},
-in caso contrario il comportamento della funzione è indefinito.
-
-La funzione \func{realloc} si usa invece per cambiare (in genere aumentare) la
-dimensione di un'area di memoria precedentemente allocata, la funzione vuole
-in ingresso il puntatore restituito dalla precedente chiamata ad una
-\func{malloc} (se è passato un valore \val{NULL} allora la funzione si
-comporta come \func{malloc})\footnote{questo è vero per Linux e
- l'implementazione secondo lo standard ANSI C, ma non è vero per alcune
- vecchie implementazioni, inoltre alcune versioni delle librerie del C
- consentivano di usare \func{realloc} anche per un puntatore liberato con
- \func{free} purché non ci fossero state nel frattempo altre chiamate a
- funzioni di allocazione, questa funzionalità è totalmente deprecata e non è
- consentita sotto Linux.} ad esempio quando si deve far crescere la
-dimensione di un vettore. In questo caso se è disponibile dello spazio
-adiacente al precedente la funzione lo utilizza, altrimenti rialloca altrove
-un blocco della dimensione voluta, copiandoci automaticamente il contenuto; lo
-spazio aggiunto non viene inizializzato.
+quattro: \func{malloc}, \func{calloc}, \func{realloc} e \func{free}. Le prime
+due, \funcd{malloc} e \funcd{calloc} allocano in nuovo spazio di memoria; i
+rispettivi prototipi sono:
+
+\begin{funcproto}{
+\fhead{stdlib.h}
+\fdecl{void *calloc(size\_t nmemb, size\_t size)}
+\fdesc{Alloca un'area di memoria inizializzata a 0.}
+\fdecl{void *malloc(size\_t size)}
+\fdesc{Alloca un'area di memoria non inizializzata.}
+}
+{Entrambe le funzioni restituiscono il puntatore alla zona di memoria allocata
+in caso di successo e \val{NULL} in caso di fallimento, nel qual caso
+ \var{errno} assumerà il valore \errval{ENOMEM}.}
+\end{funcproto}
+
+In genere si usano \func{malloc} e \func{calloc} per allocare dinamicamente
+un'area di memoria.\footnote{queste funzioni presentano un comportamento
+ diverso fra le \acr{glibc} e le \acr{uClib} quando il valore di \param{size}
+ è nullo. Nel primo caso viene comunque restituito un puntatore valido,
+ anche se non è chiaro a cosa esso possa fare riferimento, nel secondo caso
+ viene restituito \val{NULL}. Il comportamento è analogo con
+ \code{realloc(NULL, 0)}.} Dato che i puntatori ritornati sono di tipo
+generico non è necessario effettuare un cast per assegnarli a puntatori al
+tipo di variabile per la quale si effettua l'allocazione, inoltre le funzioni
+garantiscono che i puntatori siano allineati correttamente per tutti i tipi di
+dati; ad esempio sulle macchine a 32 bit in genere è allineato a multipli di 4
+byte e sulle macchine a 64 bit a multipli di 8 byte.
+
+Nel caso di \func{calloc} l'area di memoria viene allocata nello \textit{heap}
+come un vettore di \param{nmemb} membri di \param{size} byte di dimensione, e
+preventivamente inizializzata a zero, nel caso di \func{malloc} invece vengono
+semplicemente allocati \param{size} byte e l'area di memoria non viene
+inizializzata.
+
+Una volta che non sia più necessaria la memoria allocata dinamicamente deve
+essere esplicitamente rilasciata usando la funzione \func{free},\footnote{le
+ glibc provvedono anche una funzione \func{cfree} definita per compatibilità
+ con SunOS, che è deprecata.} il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{stdlib.h}
+\fdecl{void free(void *ptr)}
+\fdesc{Disalloca un'area di memoria precedentemente allocata.}
+}
+{La funzione non ritorna nulla e non riporta errori.}
+\end{funcproto}
+
+Questa funzione vuole come argomento \var{ptr} il puntatore restituito da una
+precedente chiamata ad una qualunque delle funzioni di allocazione che non sia
+già stato liberato da un'altra chiamata a \func{free}. Se il valore
+di \param{ptr} è \val{NULL} la funzione non fa niente, mentre se l'area di
+memoria era già stata liberata da un precedente chiamata il comportamento
+della funzione è dichiarato indefinito, ma in genere comporta la corruzione
+dei dati di gestione dell'allocazione, che può dar luogo a problemi gravi, ad
+esempio un \textit{segmentation fault} in una successiva chiamata di una di
+queste funzioni.
+
+Dato che questo errore, chiamato in gergo \textit{double free}, è abbastanza
+frequente specie quando si manipolano vettori di puntatori, e dato che le
+conseguenze possono essere pesanti ed inaspettate, si suggerisce come
+soluzione precauzionale di assegnare sempre a \val{NULL} ogni puntatore su cui
+sia stata eseguita \func{free} immediatamente dopo l'esecuzione della
+funzione. In questo modo, dato che quando l'argomento è un puntatore nullo
+\func{free} non esegue nessuna operazione, si evitano i problemi del
+\textit{double free}.
+
+Infine la funzione \funcd{realloc} consente di modificare (in genere
+aumentare) la dimensione di un'area di memoria precedentemente allocata, il
+suo prototipo è:
+
+\begin{funcproto}{
+\fhead{stdlib.h}
+\fdecl{void *realloc(void *ptr, size\_t size)}
+\fdesc{Cambia la dimensione di un'area di memoria precedentemente allocata.}
+} {La funzione restituisce il puntatore alla zona di memoria allocata in caso
+ di successo e \val{NULL} in caso di fallimento, nel qual caso \var{errno}
+ assumerà il valore \errval{ENOMEM}.}
+\end{funcproto}
+
+La funzione vuole come primo argomento il puntatore restituito da una
+precedente chiamata a \func{malloc} o \func{calloc} e come secondo argomento
+la nuova dimensione (in byte) che si intende ottenere. Se si passa
+per \param{ptr} il valore \val{NULL} allora la funzione si comporta come
+\func{malloc}.\footnote{questo è vero per Linux e l'implementazione secondo lo
+ standard ANSI C, ma non è vero per alcune vecchie implementazioni, inoltre
+ alcune versioni delle librerie del C consentivano di usare \func{realloc}
+ anche per un puntatore liberato con \func{free} purché non ci fossero state
+ nel frattempo altre chiamate a funzioni di allocazione, questa funzionalità
+ è totalmente deprecata e non è consentita sotto Linux.}
+
+La funzione si usa ad esempio quando si deve far crescere la dimensione di un
+vettore. In questo caso se è disponibile dello spazio adiacente al precedente
+la funzione lo utilizza, altrimenti rialloca altrove un blocco della
+dimensione voluta, copiandoci automaticamente il contenuto; lo spazio aggiunto
+non viene inizializzato. Se la funzione fallisce l'area di memoria originale
+non viene assolutamente toccata.