Le FAQ di comp.lang.c

L'uso di NULL è solo una convenzione stilistica; il preprocessore ritrasforma NULL in 0, che viene poi trattato dal compilatore, in contesti puntatore, come indicato sopra. In particolare, potrebbe essere ancora necessario un cast prima di NULL (come prima di 0) per argomenti di chiamate di funzione. La tavola riassuntiva al termine della domanda 5.2 sopra si applica a NULL tanto quanto a 0 (un NULL senza cast è equivalente a uno 0 senza cast).

NULL dovrebbe essere usato solo per i puntatori; vedi la domanda 5.9.

Riferimenti: K&R1 Sez. 5.4; K&R2 Sez. 5.4; ANSI Sez. 4.1.5, Sez. 3.2.2.3; ISO Sez. 7.1.6, Sez. 6.2.2.3; Rationale Sez. 4.1.5; H&S Sez. 5.3.2, Sez. 11.1.

5.5: Come dovrebbe essere definito NULL su una macchina che usa una sequenza di bit diversa da 0 come rappresentazione interna del puntatore nullo?

Ogni volta che un programmatore richiede un puntatore nullo, scrivendo "0" o "NULL", è responsabilità del compilatore generare qualsiasi stringa di bit la macchina usi per i puntatori nulli. Perciò, una #define di NULL come 0 su una macchina per cui la rappresentazione interna dei puntatori nulli è diversa da zero è valido quanto su qualsiasi altra macchina: il compilatore deve sempre essere in grado di generare i puntatori nulli corretti per gli 0 che si trovano in contesti puntatore. Vedi anche le domande 5.2, 5.10, e 5.17.

Riferimenti: ANSI Sez. 4.1.5; ISO Sez. 7.1.6; Rationale Sez. 4.1.5.

5.6: Se NULL fosse definito come segue:

#define NULL ((char *)0)

questo farebbe funzionare le chiamate di funzioni che passano un NULL senza cast?

FILE *fp = NULL;

potrebbero fallire.

Tuttavia, l'ANSI C consente la definizione alternativa

#define NULL ((void *)0)

per NULL. Oltre a far funzionare programmi potenzialmente scorretti (ma solo su macchine con puntatori omogenei, il che è di dubbia utilità), questa definizione può intercettare usi scorretti di NULL (per esempio, laddove si intendeva usare il carattere ASCII NUL; vedi la domanda 5.9).

Riferimenti: Rationale Sez. 4.1.5.

5.9: Se NULL e 0 sono equivalenti come costanti puntatore nulle, quale è meglio usare?

Non si dovrebbe usare NULL dove è necessario un altro tipo di 0, anche se può funzionare, perché questo manda il messaggio sbagliato. (Inoltre, ANSI consente la definizione di NULL come ((void*)0), che non funziona del tutto in contesti non puntatore). In particolare, non si deve usare NULL quando si vuole indicare il carattere ASCII nullo (NUL). Se è proprio necessario, è meglio crearsi la propria macro:

#define NUL '\0'

Riferimenti: K&R1 Sez. 5.4; K&R2 Sez. 5.4.

5.10: Ma non sarebbe meglio usare NULL (invece di 0), nel caso il valore di NULL cambi, magari su una macchina con puntatori nulli internamente rappresentati diversi da zero?

5.12: Uso la macro di preprocessore

#define Nullptr(type) (type *)0

per facilitarmi la costruzione di puntatori nulli del tipo corretto.

5.13: È strano. C'è la garanzia che NULL sia 0, ma non che il puntatore nullo sia rappresentato con 0?

• 1. Il puntatore nullo concettuale, ovvero il concetto astratto presente nella definizione del linguaggio e definito nella domanda 5.1. Questo è implementato con...
• 2. La rappresentazione interna (o a tempo di esecuzione) di un puntatore nullo, che potrebbe, ma non necessariamente deve, essere con tutti i bit a 0, e che può essere diversa per diversi tipi puntatore. I valori effettivi dovrebbero interessare solo a chi scrive i compilatori. I programmatori C non li vedono mai, perché usano...
• 3. La costante puntatore nullo, che è uno 0 intero costante (vedi domanda 5.2). Questa costante è spesso nascosta dietro...
• 4. La macro NULL, che è definita da una #define come "0" o "((void *)0)" (vedi domanda 5.4). Infine, ma non c'entrano nulla, ci sono...
• 5. Il carattere nullo del codice ASCII (NUL), che ha in effetti tutti i bit a zero, ma non ha altra relazione con il puntatore nullo che nel nome; e...
• 6. La stringa nulla, che è un altro nome per la stringa vuota (""). Usare il termine "stringa nulla " può creare confusione in C, perché una stringa vuota è data da un carattere nullo ('\0'), ma non, da un puntatore nullo; e questo chiude il cerchio...

Questo articolo usa l'espressione "puntatore nullo" (in minuscolo) per il significato 1, il carattere "0" o l'espressione "costante puntatore nullo" per il senso 3, e la parola maiuscola NULL per il significato 4.

5.14: Come mai c'è tutta questa confusione riguardo ai puntatori nulli? Perché queste domande sono così ricorrenti?

Un buon modo per liberarsi di questa confusione è quello di immaginare che il C abbia una parola chiave (per esempio "nil", come il Pascal) come costante puntatore nullo. A quel punto il compilatore potrebbe trasformare "nil" nel tipo corretto di puntatore nullo qualora possa determinare tale tipo dal codice, o lamentarsi se non può. Ora, in effetti, in C la parola chiave per un puntatore nullo non è "nil" ma "0", il che va quasi altrettanto bene, eccetto che uno "0" in un contesto non-puntatore genera uno zero intero invece di un messaggio di errore, e se quello 0 doveva essere un puntatore nullo, il codice potrebbe non funzionare.

5.15: Sono confuso. Non capisco niente di tutta questa faccenda dei puntatori nulli.

• 1. Quando si vuole una costante puntatore nullo nel sorgente, usare "0" o "NULL".
• 2. Se "0" o "NULL" sono argomeni in una chiamata a funzione, fare il cast al tipo puntatore aspettato dalla funzione.

5.16: Vista tutta la confusione che c`è sui puntatori nulli, non sarebbe più semplice richiedere che siano rappresentati internamente come zeri?

Inoltre, cosa si guadagnerebbe con un simile requisito? La comprensione dei puntatori nulli non richiede la conoscenza della rappresentazione interna, sia essa zero o no. Assumere che i puntatori nulli siano internamente zero non semplifica la scrittura del codice (fatta eccezione per un modo poco saggio di usare la calloc(); vedi la domanda 7.31). Puntatori interni a zero non ovvierebbero alla necessità di eseguire un cast nelle chiamate a funzione, perché la *dimensione* del puntatore potrebbe essere comunque diversa da quella di un int. (Se si usasse "nil" per richiedere puntatori nulli, come menzionato nella domanda 5.14, la necessità di assumere una rappresentazione interna a zero non nascerebbe neanche).

5.17: Seriamente, esistono effettivamente delle macchine che rappresentano i puntatori nulli con valori diversi da zero, o che usano diverse rappresentazioni interne per puntatori a diversi tipi?

La serie Eclipse MV della Data General fornisce supporto architetturale per tre formati di puntatore (a parola, a byte e a bit), due dei quali sono usati dai compilatori C: i puntatori a byte per char * e void * e i puntatori a parola per tutto il resto.

Alcuni mainframe Honeywell-Bull usano il pattern di bit 06000 per i puntatori nulli (interni).

La serie Cyber 180 della CDC ha puntatori a 48 bit composti da anello, segmento e offset. Per la maggior parte degli utenti (nell'anello 11) il puntatore nullo è 0xB00000000000. Nelle vecchie macchine CDC in complemento a 1 era comune usare parole con tutti i bit a uno come valore speciale per tutti i tipi di dati, inclusi gli indirizzi non validi.

La vecchia serie HP 3000 usa uno schema di indirizzamento diverso per i byte e le parole; di conseguenza, come molte altre delle macchine citate sopra, usa per i char* e i void* una rappresentazione diversa da quella usata per gli altri puntatori.

La Symbolics Lisp Machine, che ha una architettura a tag, non ha neppure puntatori convenzionali numerici; usa la coppia (essenzialmente un handle inesistente) come puntatore nullo C.

A seconda del modello di memoria usato, i processori della famiglia 8086 (PC compatibili) possono usare puntatori a dati a 16 bit e puntatori a funzione a 32 bit, o viceversa.

Alcune macchine Cray a 64 bit Cray rappresentano gli int* con i 48 bit inferiori di una parola; i char* usano, in più, anche i 16 bit superiori per indicare l'indirizzo di un byte all'interno di una parola.

Riferimenti: K&R1 Sez. A14.4.

5.20: Che cosa significa l'errore a tempo di esecuzione "null pointer assignment"? Come si fa a dargli la caccia?

Un debugger potrebbe consentire di piazzare un breakpoint o un watchpoint o qualcos'altro nella locazione 0. In alternativa, si può scrivere un po' di codice che memorizza una copia di circa 20 byte dalla locazione 0, e periodicamente verifica che la memoria a quella locazione non sia cambiata. Vedi anche la domanda 16.8.

6. Vettori e puntatori

6.1: Ho messo la definizione di char a[6] in un file sorgente, e in un altro ho messo la dichiarazione extern char *a. Perché non ha funzionato?

Riferimenti: ANSI Sez. 3.5.4.2; ISO Sez. 6.5.4.2; CT&P Sez. 3.3, Sez. 4.5.

6.2: Ma ho sentito dire che char a[] è identico a char *a.

Come sempre, un disegno vale mille parole. Le dichiarazioni

char a[] = "hello"; char *p = "world";

inizializzano strutture dati che si presentano così:

    +---+---+---+---+---+---+
a:  | h | e | l | l | o |\0 |
    +---+---+---+---+---+---+
    +-----+     +---+---+---+---+---+---+
p:  |  *======> | w | o | r | l | d |\0 |
    +-----+     +---+---+---+---+---+---+

È importante comprendere che un costrutto come x[3] genera codice diverso a seconda che x sia un vettore o un puntatore. Date le dichiarazioni sopra, quando il compilatore vede l'espressione a[3], produce codice che parte alla locazione "a", si sposta di tre avanti, e preleva il carattere che si trova lì. Quando incontra l'espressione p[3], produce codice che parte alla locazione "p", preleva il valore puntatore che si trova lì, aggiunge tre al puntatore, e preleva il carattere puntato. In altre parole, a[3] significa "tre posti dopo (l'inizio de) l'oggetto che *si chiama* a", mentre p[3] significa "tre posti dopo l'oggetto *puntato da* p". Nell'esempio sopra, sia a[3] che p[3] risultano essere il carattere 'l', ma il compilatore ci arriva in modi diversi. (La differenza essenziale è che i valori di un vettore come a e di un puntatore come p sono calcolati in modi diversi *dovunque* compaiano in espressioni, indipendentemente dal fatto che siano o no indicizzati, come spiegato in maggiore dettaglio nella prossima domanda).

Riferimenti: K&R2 Sez. 5.5; CT&P Sez. 4.5.

6.3: Ma allora cosa si intende per "equivalenza di puntatori e vettori" in C?

L'"equivalenza" si riferisce alla seguente definizione chiave:

Un lvalue di tipo vettore-di-T che compare in una espressione degenera (con tre eccezioni) in un puntatore al suo primo elemento; il tipo del puntatore risultante è puntatore-a-T. (Le eccezioni sono quando il vettore è l'operando dell'operatore sizeof o dell'operatore &, oppure è un inizializzatore stringa costante per un vettore di caratteri.

Come conseguenza di questa definizione, il compilatore non applica l'operatore di indicizzazione di vettori [] in modo molto diverso per vettori e puntatori, dopo tutto. In un'espressione come a[i], il vettore degenera in un puntatore, secondo la regola sopra, ed è successivamente indicizzato così come accadrebbe a una variabile puntatore nell'espressione p[i] (anche se avverranno differenti accessi in memoria, come spiegato nella domanda 6.2). Se si assegna l'indirizzo di un vettore a un puntatore:

p = a;

successivamente p[3] e a[3] accederanno allo stesso elemento.

Vedi anche la domanda 6.8.

Riferimenti: K&R1 Sez. 5.3; K&R2 Sez. 5.3; ANSI Sez. 3.2.2.1, Sez. 3.3.2.1, Sez. 3.3.6; ISO Sez. 6.2.2.1, Sez. 6.3.2.1, Sez. 6.3.6; H&S Sez. 5.4.1.

6.4: Allora perché le dichiarazioni di vettori e puntatori sono interscambiabili come parametri formali di funzioni?

Poiché i vettori degenerano immediatamente in puntatori, un vettore non è mai realmente passato a una funzione. Il fatto di consentire a parametri puntatore di essere dichiarati come vettori è semplicemente un modo di dare l'idea che sia il vettore a essere passato - il programmatore potrebbe volere anche enfatizzare che il parametro sarà trattato come un vettore convenzionale, o che verrà passato un vettore (strettamente parlando, il suo indirizzo). Per comodità, quindi, ogni parametro che "sembri" un vettore, per esempio

f(char a[]) { ... }

è trattato dal compilatore come se fosse un puntatore, dato che questo è ciò che la funzione comunque riceverebbe se venisse passato un vettore:

f(char *a) { ... }

Questa conversione vale solo nella dichiarazione di parametri formali di una funzione, e da nessun'altra parte. Se la conversione vi dà fastidio, evitatela; molti hanno concluso che la confusione che essa causa è predominante rispetto al vantaggio di avere una dichiarazione che "assomiglia" alla chiamata o all'uso del parametro all'interno della funzione.

Vedi anche la domanda 6.21.

Riferimenti: K&R1 Sez. 5.3, Sez. A10.1; K&R2 Sez. 5.3, Sez. A8.6.3, Sez. A10.1; ANSI Sez. 3.5.4.3, Sez. 3.7.1, Sez. 3.9.6; ISO Sez. 6.5.4.3, Sez. 6.7.1, Sez. 6.9.6; H&S Sez. 9.3; CT&P Sez. 3.3 pp. 33-4.

6.7: Come è possibile che un vettore sia un lvalue, se non ci si possono fare assegnamenti?

Riferimenti: ANSI Sez. 3.2.2.1; ISO Sez. 6.2.2.1; Rationale Sez. 3.2.2.1; H&S Sez. 7.1.

6.8: Da un punto di vista pratico, qual è la differenza fra vettori e puntatori?

A causa della cosiddetta equivalenza fra vettori e puntatori (vedi domanda 6.3), i vettori e i puntatori spesso sembrano interscambiaabili, e in particulare un puntatore a un blocco di memoria allocato con malloc è spesso trattato esattamente come se fosse un vero vettore (e vi si può accedere usando []). (Comunque, attenzione con sizeof.) Vedi le domande 6.14 e 6.16.

Vedi anche le domande 1.32 e 20.14.

6.9: Qualcuno mi spiegato che i vettori sono in realtà semplicemente puntatori costanti.

6.11: Ho trovato un pezzo di codice "scherzoso" che contiene l'espressione 5["abcdef"]. Come fa a essere legale in C?

Riferimenti: Rationale Sez. 3.3.2.1; H&S Sez. 5.4.1, Sez. 7.4.1.

6.12: Se i vettori degenerano in puntatori, dato un vettore arr, che differenza c'è fra arr e &arr?

Nel C Standard, &arr restituisce un puntatore all'intero vettore, di tipo puntatore-a-vettore-di-T. (Nel C pre-ANSI, la & in &arr di solito generava una warning ed era solitamente ignorata). Sotto tutti i compilatori C, un riferimento semplice a un vettore (senza la & esplicita), restituisce un puntatore al primo elemento del vettore, di tipo puntatore-a-T. (Vedi anche le domande 6.3, 6.13, e 6.18.)

Riferimenti: ANSI Sez. 3.2.2.1, Sez. 3.3.3.2; ISO Sez. 6.2.2.1, Sez. 6.3.3.2; Rationale Sez. 3.3.3.2; H&S Sez. 7.5.6.

6.13: Come si dichiara un puntatore a vettore?

Invece di un puntatore a un vettore, si dovrebbe provare a usare un puntatore a uno degli elementi del vettore. I vettori di tipo T degenerano in puntatori a T (vedi la domanda 6.3), il che è comodo; indicizzare o incrementare il puntatore risultante consente l'accesso ai singoli membri del vettore. I veri puntatori a vettori, quando vengono indicizzati o incrementati, si spostano di un intero vettore a ogni passo, e di solito sono utili al più quando si opera su vettori di vettori. (Vedi la domanda 6.18.)

Se si ha davvero bisogno di dichiarare un puntatore a un intero vettore, si deve usare qualcosa come "int (*ap)[N];" dove N è la dimensione del vettore. (Vedi anche la domanda 1.21.) Se la dimensione del vettore non è nota, si può, in linea di principio, ometterla; ma il tipo risultante, "puntatore a vettore di dimensione ignota", è inutile.

Vedi anche la domanda 6.12 sopra.

Riferimenti: ANSI Sez. 3.2.2.1; ISO Sez. 6.2.2.1.

6.14: Come faccio a decidere la dimensione di un vettore a run-time? Come si fa a creare vettori di dimensione variabile?

#include int *dynarray; dynarray = malloc(10 * sizeof(int));

(se la chiamata a malloc() ha successo), si può accedere a dynarray[i] (per i da 0 a 9) esattamente come se dynarray fosse un vettore convenzionale allocato staticamente (int a[10]). Vedi anche le domande 1.31a, 6.16, e 7.7.

6.15: Come si fa a dichiarare un vettore locale la cui dimensione si conformi di volta in volta a quella di un vettore passato alla funzione?

Riferimenti: ANSI Sez. 3.4, Sez. 3.5.4.2; ISO Sez. 6.4, Sez. 6.5.4.2.

6.16: Come si fa ad allocare dinamicamente un vettore multidimensionale?

#include <stdlib.h>

int **array1 = (int **)malloc(nrrighe * sizeof(int *));
for(i = 0; i < nrrighe; i++)
  array1[i] = (int *)malloc(nrcolonne * sizeof(int));

(In un vero programma, naturalmente, bisognerebbe controllare tutti i valori di ritorno delle malloc).

Usando un po' di aritmetica dei puntatori esplicita, è possibile forzare l'allocazione contigua di tutto il contenuto del vettore, al prezzo di rendere più difficile eventuali riallocazioni successive di singole righe:

int **array2 = (int **)malloc(nrrighe * sizeof(int *));
array2[0] = (int *)malloc(nrows * nrcolonne * sizeof(int));
for(i = 1; i < nrrighe; i++)
  array2[i] = array2[0] + i * nrcolonne;

In entrambi i casi, si può accedere agli elementi del vettore dinamico usando indici apparentemente normali: arrayx[i][j] (per 0 <= i < NROWS e 0 <= j < NCOLUMNS).

Se la doppia indirezione implicata dagli schemi qui sopra fosse per qualche motivo inaccettabile, è possibile simulare un vettore bidimensionale con un singolo vettore unidimensionale allocato dinamicamente:

int *array3 = (int *)malloc(nrrighe * nrcolonne * sizeof(int));

Tuttavia, in questo caso sarà necessario fare a mano i calcoli per l'indicizzazione, accedendo all'elemento di posizione (i, j) con array3[i * ncolumns + j]. (Una macro potrebbe nascondere il calcolo esplicito, ma la sua invocazione potrebbe richiedere parentesi e virgole che comunque non sembrerebbero identiche alla sintassi dei vettori multidimensionali, e la macro avrebbe comunque bisogno di accedere anche ad almeno una delle due dimensioni. Vedi anche la domanda 6.19.)

Infine, si possono usare puntatori a vettori:

int (*array4)[NRCOLONNE] = (int (*)[NRCOLONNE])malloc(nrrighe * sizeof(*array4));

ma la sintassi comincia a diventare orribile e almeno una dimensione deve essere specificata a runtime.

Con tutte queste tecniche, naturalmente, può essere necessario ricordarsi di liberare i vettori (il che richiede diversi passi, vedi domanda 7.23) quando non servono più, e non è sempre possibile mischiare vettori allocati dinamicamente con vettori convenzionali, allocati staticamente (vedi domanda 6.20, e anche 6.18).

Tutte queste tecniche possono anche essere estese a vettori a tre o più dimensioni.

6.17: Ecco un bel trucco: se scrivo

int realarray[10];
int *array = &realarray[-1];

posso trattare "array" come se fosse un vettore che parte da 1.

Riferimenti: K&R2 Sez. 5.3, Sez. 5.4, Sez. A7.7; ANSI Sez. 3.3.6; ISO Sez. 6.3.6; Rationale Sez. 3.2.2.3.

6.18: Il mio compilatore da errore se passo un vettore a due dimensioni a una funzione che si aspetta un puntatore a puntatore.

Se si passa un vettore bidimensionale a una funzione:

int array[NRRIGHE][NRCOLONNE];
f(array);

la dichiarazione della funzione dev'essere compatibile:

f(int a[][NRCOLONNE])

oppure

f(int (*ap)[NRCOLONNE]) /* ap è un puntatore a un vettore */

Nella prima dichiarazione, il compilatore esegue la normale sostituzione implicita del parametro da "vettore di vettori" a "puntatore a puntatore" (vedi le domande 6.3 e 6.4); nella seconda forma la dichiarazione come puntatore è esplicita. Poiché la funzione chiamata non alloca spazio per il vettore, non ha bisogno di conoscerne le dimensioni complessive, cosicché il numero delle righe NROWS può essere omesse. La "forma" del vettore è comunque importante, ragion per cui il numero di colonne NCOLUMNS (e, nel caso di vettori a tre o più dimensioni, tutte le altre dimensioni aggiunte) devono essere conservate.

Se una funzione è dichiarata ricevere un puntatore a puntatore, probabilmente è privo di senso passarle direttamente un vettore bidimensionale.

Vedi anche le domande 6.12 e 6.15.

Riferimenti: K&R1 Sez. 5.10; K&R2 Sez. 5.9; H&S Sez. 5.4.3.

6.19: Come si fa a scrivere funzioni che accettano vettori a due dimensioni quando la "larghezza" non è nota a tempo di compilazione?

f2(int *aryp, int nrrighe, int nrcolonne)
{ ... ad array[i][j] accedo con aryp[i * nrcolonne + j] ... }

Questa funzione può essere chiamata passandole il vettore della domanda 6.18 nel seguente modo:

f2(&array[0][0], NRRIGHE, NRCOLONNE);

Si deve comunque notare che un programma che fa indicizzazione "a mano" di vettori multidimensionali non è strettamente conforme allo stardard ANSI; secondo l'interpretazione ufficiale, il comportamento che si ottiene accedendo a (&array[0][0])[x] non è definito per x >= NCOLUMNS.

gcc consente la dichiarazione di vettori locali con dimensione specificata dagli argomenti della funzione, ma è un'estensione non standard.

Se volete usare una funzione su vettori multidimensionali di diverse dimensioni, una soluzione consiste nel simulare tutti i vettori dinamicamente, come nella domanda 6.16.

Vedi anche le domande 6.18, 6.20, e 6.15.

Riferimenti: ANSI Sez. 3.3.6; ISO Sez. 6.3.6.

6.20: Come si fa a usare vettori multidimensionali allocati staticamente e dinamicamente in modo interscambiabile quando li si passa a funzioni?

int array[NRRIGHE][NRCOLONNE];
int **array1; /* frastagliato */
int **array2; /* contiguo */
int *array3; /* "appiattito" */
int (*array4)[NRCOLONNE];

dove i puntatori sono inizializzati come nei frammenti di codice della domanda 6.16, e date le seguenti funzioni

f1(int a[][NRCOLONNE], int nrrighe, int nrcolonne);
f2(int *aryp, int nrrighe, int nrcolonne);
f3(int **pp, int nrrighe, int nrcolonne);

dove f1() accetta un vettore bidimensionale normale, f2() accetta un vettore bidimensionale "appiattito", e f3() accetta un vettore simulato via puntatore-a-puntatore (vedi anche le domande 6.18 e 6.19), le seguenti chiamate dovrebbero funzionare come ci si aspetta:

f1(array, NRRIGHE, NRCOLONNE);
f1(array4, nrrighe, NRCOLONNE);
f2(&array[0][0], NRRIGHE, NRCOLONNE);
f2(*array, NRRIGHE, NRCOLONNE);
f2(*array2, nrrighe, nrcolonne);
f2(array3, nrrighe, nrcolonne);
f2(*array4, nrrighe, NRCOLONNE);
f3(array1, nrrighe, nrcolonne);
f3(array2, nrrighe, nrcolonne);

Le seguenti due chiamate probabilmente funzionano sulla maggior parte dei sistemi, ma coinvolgono cast abbastanza discutibili, e funzionano solo se il ncolumns dinamico è uguale al NCOLUMNS statico:

f1((int (*)[NRCOLONNE])(*array2), nrrighe, nrcolonne);
f1((int (*)[NRCOLONNE])array3, nrrighe, nrcolonne);

Si deve notare, di nuovo, che passare a f2() &array[0][0] (o, equivalentamente, *array) non è strettamente conforme; vedi la domanda 6.19.

Chi capisce perché le chiamate elencate sopra funzionano e perché sono scritte in quel modo, e perché le combinazioni non elencate non funzionerebbero, ha una comprensione molto buona dei vettori e dei puntatori in C.

Invece di preoccuparsi di queste cose, un approccio all'uso di vettori multidimensionali è quello di farli *tutti* dinamici, come nella domanda 6.16. Se non ci sono vettori statici multidimensionali - cioè se tutti i vettori sono allocati come array1 o array2 della domanda 6.16 -si possono scrivere tutte le funzioni come f3().

6.21: Come mai sizeof non riporta correttamente la dimensione di un vettore quando questo è passato come parametro a una funzione?

Riferimenti: H&S Sez. 7.5.2.

7. Allocazione della memoria

7.1: Perché questo frammento non funziona?

char *answer;
printf("Scrivi qualcosa:\n");
gets(answer);
printf("Hai scritto \"%s\"\n", answer);

La variabile puntatore answer, che è passata a gets() come locazione in cui memorizzare la risposta, non è stata inizializzata a puntare ad alcuna area di memoria valida. In altre parole, non sappiamo dove answer punti. (Poiché le variabili locali non sono inizializzate, e solitamente contengono spazzatura, non è neppure garantito che answer sia inizialmente il puntatore nullo. Vedi le domande 1.30 e 5.1.)

Il modo più semplice di correggere il programma è quello di usare un vettore locale, invece di un puntatore, e lasciare che sia il compilatore a occuparsi dell'allocazione di memoria:

#include <stdio.h>
#include <string.h>

char answer[100], *p;
printf("Scrivi qualcosa:\n");
fgets(answer, sizeof answer, stdin);
if((p = strchr(answer, '\n')) != NULL)
  *p = '\0';
printf("Hai scritto \"%s\"\n", answer);

Questo esempio usa anche fgets() invece di gets(), in modo che il vettore non possa essere scritto oltre l'estremità. (Vedi domanda 12.23. Sfortunatamente per questo esempio, fgets non rimuove automaticamente il '\n' finale, come fa gets()). Sarebbe anche possibile usare malloc() per allocare il buffer answer.

7.2: Non riesco a far funzionare strcat(). Ho provato

char *s1 = "Hello, ";
char *s2 = "world!";
char *s3 = strcat(s1, s2);

ma ho avuto uno strano risultato.

strcat() non esegue alcuna allocazione; la seconda stringa è appesa in coda alla prima. Quindi, un modo per risolvere il problema consiste nel dichiarare la prima stringa come vettore:

char s1[20] = "Hello, ";

Poiché strcat() ritorna il valore del suo primo argomento (s1, in questo caso), la variabile è superflua.

La chiamata a strcat() nella domanda in effetti ha due problemi: la string letterale puntata da s1, oltre a non essere abbastanza grande da contenere testo concatenato, non è neppure necessariamente scrivibile. Vedi la domanda 1.32.

Riferimenti: CT&P Sez. 3.2.

7.3: Ma il man dice che strcat accetta due char* come argomenti. Come faccio a sapere che devo allocare qualcosa?

La sezione "synopsis" in testa ai manuali alla Unix o alla ANSI può essere fuorviante. I frammenti di codice presentati sono più vicini alla definizione della funzione usata dall'implementatore che alle invocazioni del chiamante. In particolare, molte funzioni che accettano puntatori (per esempio, a strutture o stringhe) devono essere in effetti chiamate passando l'indirizzo di un oggetto (una struttura, o un vettore - vedi le domande 6.3 e 6.4). Altri esempi comuni sono time() (vedi domanda 13.12) e stat().

7.5: Ho una funzione che dovrebbe tornare una stringa, ma quando torna al chiamante, la stringa tornata contiene spazzatura.

char *itoa(int n)
{
  char retbuf[20]; /* SBAGLIATO */
  sprintf(retbuf, "%d", n);
  return retbuf; /* SBAGLIATO */
}

Una soluzione (imperfetta, specialmente se la funzione è chiamata ricorsivamente, o se più valori di ritorno sono necessari contemporaneamente), sarebbe dichiarare il buffer da usare per il ritorno come

static char retbuf[20];

Vedi anche le domande 12.21 e 20.1.

Riferimenti: ANSI Sez. 3.1.2.4; ISO Sez. 6.1.2.4.

7.6: Perché la chiamata a malloc() mi genera in compilazione il messaggio "warning: assignment of pointer from integer lacks a cast"?

Riferimenti: H&S Sez. 4.7.

7.7: Perché in certi programmi il valore tornato da malloc() viene accuratamente convertito con un cast al tipo di puntatore allocato?

Nello Standard ANSI/ISO questi cast non sono più necessari, e anzi la pratica attuale li scoraggia perché possono sopprimere warning importanti nel caso in cui malloc() non sia dichiarata correttamente; vedi domanda 7.6 sopra.

Riferimenti: H&S Sez. 16.1.

7.8: Ho visto codice come il seguente:

char *p = malloc(strlen(s) + 1);
strcpy(p, s);

Non dovrebbe essere malloc((strlen(s) + 1) * sizeof(char))?

Riferimenti: ANSI Sez. 3.3.3.4; ISO Sez. 6.3.3.4; H&S Sez. 7.5.2.

7.14: Ho sentito che alcuni sistemi operativi non allocano effettivamente la memoria richiesta da malloc() fino a quando il programma non cerca effettivamente di usarla. È legale?

Riferimenti: ANSI Sez. 4.10.3; ISO Sez. 7.10.3.

7.16: Sto allocando un grosso vettore per certi calcoli numerici, usando

double *array = malloc(300 * 300 * sizeof(double));

malloc() non ritorna null, ma il programma si comporta in modo strano, come se stesse sovrascrivendo la memoria, o come se malloc() non stia allocando tutta la memoria che ho richiesto, o qualcosa del genere.

7.17: Ho 8 mega di memoria nel mio PC. Perché riesco a fare la malloc() solo di 640K o giù di lì?

7.19: Il mio programma si pianta, apparentemente da qualche parte durante malloc(), ma non ci vedo niente di sbagliato.

Vedi anche le domande 7.26, 16.8, e 18.2.

7.20: Non si può usare la memoria allocata dinamicamente dopo averla rilasciata con free, giusto?

Pochi programmatori userebbero deliberatamente il contenuto di memoria liberata, ma è facile farlo per sbaglio. Si consideri il seguente codice (corretto) per liberare una lista a link singolo:

struct list *listp, *nextp;
for(listp = base; listp != NULL; listp = nextp) {
nextp = listp->next;
free((void *)listp);
}

e si pensi a cosa accadrebbe se si fosse usata la più ovvia espressione di ciclo, listp = listp->next, senza il puntatore temporaneo nextp.

Riferimenti: K&R2 Sez. 7.8.5; ANSI Sez. 4.10.3; ISO Sez. 7.10.3; Rationale Sez. 4.10.3.2; H&S Sez. 16.2; CT&P Sez. 7.10.

7.21: Perché i puntatori non diventano nulli dopo la free()? Quanto è pericoloso usare (assegnare, confrontare) un valore di puntatore dopo che è stata fatta la free()?

Un valore puntatore che è stato liberato, strettamente parlando, è non valido, e qualsiasi uso di un valore non valido, anche se non derefenziato, può teoricamente causare dei problemi, anche se da un punto di vista pratico, la maggior parte delle implementazioni probabilmente non genererano eccezioni per usi innocui di puntatori non validi.

Riferimenti: ANSI Sez. 4.10.3; ISO Sez. 7.10.3; Rationale Sez. 3.2.2.3.

7.22: Quando chiamo malloc() per allocare memoria su un puntatore locale, devo poi esplicitamente liberarla con free()?

7.23: Sto allocando strutture che contengono puntatori ad altri oggetti allocati dinamicamente. Quando libero la struttura, devo anche invocare free() su ognuno di questi puntatori secondari?

Vedi ache la domanda 7.24.

7.24: È necessario liberare tutta la memoria allocata prima dell'uscita dal programma?

Riferimenti: ANSI Sez. 4.10.3.2; ISO Sez. 7.10.3.2.

7.25: Ho un programma che richiede con malloc(), e successivamente rilascia con free(), molta memoria, ma la sua occupazione di memoria (secondo quanto riportato da ps) sembra non ridursi con la free.

7.26: Come fa free() a sapere quanti byte liberare?

7.27: Quindi si può interrogare la libreria per sapere quanto è grande un blocco allocato?

7.30: È legale passare un puntatore nullo come primo argomento a realloc()? A cosa serve?

Riferimenti: ANSI Sez. 4.10.3.4; ISO Sez. 7.10.3.4; H&S Sez. 16.3.

7.31: Qual è la differenza fra calloc() e malloc()? C'è da fidarsi a usare il riempimento-a-zero di calloc? La free() funziona su memoria allocata con calloc(), o serve una cfree()?

p = malloc(m * n); memset(p, 0, m * n);

Il riempimento è a tutti bit a zero, e quindi *non* garantisce valori puntatori nulli (vedi sezione 5) o valori zero a virgola mobile. È corretto usare free() per liberare la memoria allocata da calloc().

Riferimenti: ANSI Sez. da 4.10.3 a 4.10.3.2; ISO Sez. da 7.10.3 a 7.10.3.2; H&S Sez. 16.1, Sez. 16.2; PCS Sez. 11.

7.32: Cos'è alloca() e perché se ne sconsiglia l'uso?

alloca() non può essere scritta in modo portabile, ed è difficile da implementare su macchine senza uno stack convenzionale. Il suo uso è problematico (e l'implementazione banale su una macchina basata su stack fallisce) quando il suo valore di ritorno è passato direttamente a un'altra funzione, come in fgets(alloca(100), 100, stdin).

Per queste ragioni, alloca() non appartiene allo Standard e, anche se utile, non deve essere usata in prorami che devono essere ampiamente portabili.

Vedi anche la domanda 7.22.

Riferimenti: Rationale Sez. 4.10.3.

8. Caratteri e stringhe

8.1: Perché

strcat(string, '!');

non funziona?

I caratteri sono rappresentati in C da piccoli interi che corrispondono al loro valore nel set dei caratteri (vedi anche la domanda 8.6 sotto). Le stringhe sono rappresentate da vettori di caratteri; normalmente si manipola un puntatore al primo carattere del vettore. Non è mai corretto usare un carattere laddove serve una stringa, o viceversa. Per appendere un ! a una stringa, si usi

strcat(string, "!");

Vedi anche le domande 1.32, 7.2, e 16.6.

Riferimenti: CT&P Sez. 1.5.

8.2: Devo controllare se una stringa contiene un particolare valore. Perché questo codice non funziona?

char *string;
...
if(string == "qualcosa") {
nbsp;nbsp;...
}

Le stringhe in C sono rappresentate come vettori di caratteri, e in C non è possibile manipolare (assegnare, confrontare, eccetera) interi vettori. L'operatore == nel frammento di codice sopra confronta due puntatori - il valore del puntatore variabile string e un puntatore alla stringa letterale "value" - per verificare se sono uguali, ovvero se puntano alla stessa cosa (nello stesso posto). Probabilmente questo non è vero, perció il confronto non ha mai successo.

Per confrontare due stringhe, si usa solitamente la funzione di libreria strcmp():

if(strcmp(string, "value") == 0) {
nbsp;nbsp;...
}

8.3: Se si può scrivere

char a[] = "Hello, world!";

perché non si può anche scrivere

char a[14];
a = "Hello, world!";

Le stringhe sono vettori, e non si possono assegnare direttamente. Si usi, invece, strcpy():

strcpy(a, "Hello, world!");

Nota del traduttore: in C, in generale, il fatto che nell'inizializzazione di variabili si usi il simbolo "=" fa pensare che una inizializzazione sia una sorta di abbinamento di dichiarazione e assegnamento, e che pertanto la si possa sempre spezzare in queste due parti. Questo non è vero; le inizializzazioni seguono regole diverse da quelle degli assegnamenti in moltissimi casi. (Per inciso, l'apprendimento del C++ chiarisce ulteriormente questa differenza).

Vedi anche le domande 1.32, 4.2, e 7.2.

8.6: Come si fa a ottenere il valore numerico che corrisponde a un carattere nel set di caratteri, o viceversa?

8.9: Penso che il mio compilatore abbia qualcosa che non va: ho notato che sizeof('a') è 2 e non 1 (ovvero, non è sizeof(char)).

Riferimenti: ANSI Sez. 3.1.3.4; ISO Sez. 6.1.3.4; H&S Sez. 2.7.3.

9. Espressioni booleane

9.1: Qual è il tipo giusto da usare per i valori booleani in C? Perché non è un tipo standard? È meglio usare delle #define o una enumerazione per i valori vero e falso?

La scelta fra usare due #define o una enumerazione per i valori vero e falso è arbitrario e non molto interessante (vedi anche le domande 2.22 e 17.10). Si usi una qualsiasi delle seguenti soluzioni

#define VERO 1
#define FALSO 0

enum bool {falso, vero};

o semplicemente 1 e 0, purché si faccia la scelta in modo consistente nell'intero programma o progetto. (Una enumerazione può essere preferibile se il vostro debugger mostra i nomi delle costanti enumerative quando si esaminano le variabili.)

Alcuni preferiscono varianti come

#define TRUE (1==1)
#define FALSE (!TRUE)

o definiscono macro "di appoggio" come

#define Istrue(e) ((e) != 0)

Queste tecniche non fanno guadagnare nulla (vedi la domanda 9.2 sotto; vedi anche le domande 5.12 e 10.2).

9.2: Non è pericoloso usare una #define di TRUE come 1, visto che qualsiasi valore diverso da zero viene considerato "vero" in C? Cosa succede se un operatore logico o relazionale "ritorna" qualcosa che non sia 1?

if((a == b) == TRUE)

funzionerebbe come previsto (se TRUE è 1), ma è chiaramente stupido. In generale, test espliciti di confronto con TRUE e FALSE sono sconsigliabili, perché alcune funzioni di libreria (tra cui isupper(), isalpha(), ecc.) ritornano, in caso di successo, un valore diverso da zero che *non è* necessariamente 1. (Inoltre, se uno pensa che "if((a == b) == TRUE)" sia meglio di "if(a == b)", perché fermarsi qui? Perché non usare "if(((a == b) == TRUE) == TRUE)"?). Una buona regola pratica è usare TRUE e FALSE (o simili) solo negli assegnamenti a variabili booleane o parametri di funzione, o come valore di ritorno da una funzione booleana, ma mai in un confronto.

Le macro di preprocessore TRUE e FALSE (e, naturalmente, NULL) sono usate per leggibilità del codice, non perché i valori effettivi possono cambiare. (Vedi anche le domande 5.3 e 5.10.)

D'altra parte, valori e definizioni booleane possono evidentemente generare confusione, e alcuni programmatori pensano che TRUE e FALSE peggiorino solo le cose. (Vedi anche la domanda 5.9.)

Riferimenti: K&R1 Sez. 2.6, Sez. 2.7; K&R2 Sez. 2.6, Sez. 2.7, Sez. A7.4.7, Sez. A7.9; ANSI Sez. 3.3.3.3, Sez. 3.3.8, Sez. 3.3.9, Sez. 3.3.13, Sez. 3.3.14, Sez. 3.3.15, Sez. 3.6.4.1, Sez. 3.6.5; ISO Sez. 6.3.3.3, Sez. 6.3.8, Sez. 6.3.9, Sez. 6.3.13, Sez. 6.3.14, Sez. 6.3.15, Sez. 6.6.4.1, Sez. 6.6.5; H&S Sez. 7.5.4, Sez. 7.6.4, Sez. 7.6.5, Sez. 7.7, Sez. 7.8, Sez. 8.5, Sez. 8.6; "Ciò che la tartaruga disse ad Achille".

9.3: if(p), dove p è un puntatore, è una condizione valida?

10. Preprocessore

10.2: Ecco un paio di belle macro:

#define begin {
#define end }

Che ne pensate?

Vedi anche sezione 17.

10.3: Come si fa a scrivere una macro generica per scambiare due valori?

La migliore soluzione è probabilmente lasciar perdere, a meno che si sia disposti a passarle il tipo come terzo argomento.

10.4: Qual è il modo migliore di scrivere una macro a più istruzioni (statement)?

La soluzione tradizionale è quindi usare

#define MACRO(arg1, arg2) do { \
/* declarations */ \
stmt1; \
stmt2; \
/* ... */ \
} while(0) /* (niente ; ) */

Quando il chiamante appende un punto e virgola, l'espansione diventa una singola istruzione indipendentemente dal contesto. (Un compilatore ottimizzante rimuoverà ogni condizione "morta" o i rami della condizione costante 0, anche se lint potrebbe protestare.)

Se tutte le istruzioni della macro desiderata sono espressioni semplici, senza dichiarazioni né cicli, un'altra tecnica consiste nello scrivere una singola espressione parentesizzata usando uno o più operatori virgola. (Come esempio, si veda la prima macro DEBUG() nella domanda 10.26.) Questa tecnica consente anche il "ritorno" di un valore.

Riferimenti: H&S Sez. 3.3.2; CT&P Sez. 6.3.

10.6: Sto spezzando un programma in più file sorgente per la prima volta, e mi chiedo cosa devo mettere nei file .c e cosa nei file .h. (Cosa significa ".h", a proposito?)

• definizioni di macro (#define)
• dichiarazioni di strutture, unioni, e enumerazioni
• dichiarazioni di typedef
• dichiarazioni di funzioni esterne (vedi anche la domanda 1.11)
• dichiarazioni di variabili globali

D'altra parte, quando una definizione o dichiarazione deve rimanere privata a un file sorgente, va benissimo lasciarla lì.

Vedi anche le domande 1.7 e 10.7.

Riferimenti: K&R2 Sez. 4.5; H&S Sez. 9.2.3; CT&P Sez. 4.6.

10.7: È accettabile che un header file ne includa (#include) un altro?

#ifndef HFILENAME_USED
#define HFILENAME_USED
...contenuti del file header...
#endif

(dove un diverso nome di macro "parentesizzante" è usato per ogni header file) rende "idempotenti" gli header file cosicché possono essere inclusi più volte senza problemi; e i tool di manutenzione automatica dei makefile (che sono comunque necessari nei grandi progetti; vedi la domanda 18.1) consentono di gestire facilmente le dipendenze anche nel caso di inclusioni annidate. Vedi anche la domanda 17.10.

Riferimenti: Rationale Sez. 4.1.2.

10.8: Dov'è che vengono cercati gli header file?

Tradizionalmente (specialmente sotto i compilatori Unix), si assume che il direttorio corrente sia quello che contiene il file in cui c'è la direttiva #include. Sotto altri compilatori, comunque, il direttorio corrente (se esiste) è quello in cui è stato invocato il compilatore. Controllate la documentazione del compilatore.

Riferimenti: K&R2 Sez. A12.4; ANSI Sez. 3.8.2; ISO Sez. 6.8.2; H&S Sez. 3.4.

10.9: Ricevo strani errori di sintassi sulla prima dichiarazione di un file, ma sembra a posto.

10.11: Sembra che mi manchi un header file di sistema . C'è qualcuno che potrebbe spedirmene una copia?

10.12: Come si fa a costruire espressioni #if di preprocessore che confrontino stringhe?

Vedi anche la domanda 20.17.

Riferimenti: K&R2 Sez. 4.11.3; ANSI Sez. 3.8.1; ISO Sez. 6.8.1; H&S Sez. 7.11.1.

10.13: L'operatore sizeof funziona anche nelle direttive #if?

Riferimenti: ANSI Sez. 2.1.1.2, Sez. 3.8.1; ISO Sez. 5.1.1.2, Sez. 6.8.1; H&S Sez. 7.11.1.

10.14: Posso usare una #ifdef in una linea #define, allo scopo di dare due definizioni alternative di qualcosa?

Riferimenti: ANSI Sez. 3.8.3, Sez. 3.8.3.4; ISO Sez. 6.8.3, Sez. 6.8.3.4; H&S Sez. 3.2.

10.15: Esiste qualcosa di simile a una #ifdef per le typedef?

Riferimenti: ANSI Sez. 2.1.1.2, Sez. 3.8.1; ISO Sez. 5.1.1.2, Sez. 6.8.1; H&S Sez. 7.11.1.

10.16: Come si può fare a usare una espressione #if per capire se una macchina è big-endian o little-endian?

Riferimenti: ANSI Sez. 3.8.1; ISO Sez. 6.8.1; H&S Sez. 7.11.1.

10.18: Ho ereditato del codice che contiene decisamente troppe #ifdef's per i miei gusti. Posso preprocessare il codice in modo da lasciare un solo insieme di compilazione condizionale, senza eseguire la normale precompilazione che mi espanderebbe anche tutte le #include e le #define?

10.19: Come faccio ad avere una lista di tutti gli identificatori predefiniti con #define?

10.20: Ho del vecchio codice che cerca di costruire degli identificatori con una macro come

#define Paste(a, b) a/**/b

ma non funziona più.

Il fatto che i commenti sparissero completamente e potessero quindi essere usati per "incollare" dei token era una caratteristica non documentata di alcuni vecchi compilatori (in particolare quello di John Reiser). L'ANSI (come anche K&R1) afferma che i commenti sono rimpiazzati con spazi bianchi. Comunque, poiché si è dimostrato che la necessità di incollare token è reale, l'ANSI ha introdotto un operatore ben definito per farlo, ##, che può essere usato come segue:

#define Paste(a, b) a##b

Vedi anche la domanda 11.17.

Riferimenti: ANSI Sez. 3.8.3.3; ISO Sez. 6.8.3.3; Rationale Sez. 3.8.3.3; H&S Sez. 3.3.9.

10.22: Come mai la macro

#define TRACE(n) printf("TRACE: %d\n", n)

causa la warning "macro replacement within a string literal"? Sembra che espanda

TRACE(count);

con

printf("TRACE: %d\count", count);

Vedi domanda 11.18.

10.23: Incontro dei problemi a usare argomenti macro dentro stringhe letterali, usando l'operatore #.

10.25: C'è un trucco che vorrei fare con il compilatore e non capisco come farlo.

(Se si vuole preprocessare qualcosa di diverso dal C, si può usare un preprocessore general-purpose. Uno un po' vecchio disponibile sulla maggior parte degli Unix è m4.)

10.26: Come si fa a scrivere una macro con un numero variabile di argomenti?

#define DEBUG(args) (printf("DEBUG: "), printf args)

if(n != 0) DEBUG(("n is %d\n", n));

L'ovvio svantaggio è che il chiamante deve sempre ricordarsi di usare le parentesi extra.

gcc ha una estensione che consente a una pseudofunzione realizzata con una macro di accettare un numero variabile di argomenti, ma non è standard. Altre possibili soluzioni consistono nell'usare macro diverse a seconda del numero degli argomenti (DEBUG1, DEBUG2, ecc.) o giocare con le virgole:

#define DEBUG(args) (printf("DEBUG: "), printf(args))
#define _ ,

DEBUG("i = %d" _ i)

Solitamente è meglio usare una funzione vera, che può ricevere un numero variabile di argomenti in un modo ben definito. Vedi le domande 15.4 e 15.5. (Se hai proprio bisogno di una sostituzione di macro, prova a usare una funzione più una macro non-pseudofunzione, p.es. #define printf myprintf .)

11. Lo Standard ANSI/ISO

11.1: Cos'è lo standard "ANSI C"?

Più recentemente, lo standard è stato adottato come standard internazionale come ISO/IEC 9899:1990, e questo standard ISO ha sostituito il predecessore X3.159 anche all'interno degli Stati Uniti (dove è attualmente noto come ANSI/ISO 9899-1990 [1992]). Le sezioni sono numerate diversamente (in sostanza, le sezioni da 5 a 7 dell'ISO corrispondono all'incirca alle vecchie sezioni da 2 a 4 dell'ANSI). In quanto ISO, lo standard è soggetto a revisione continua attraverso il rilascio di "Technical Corrigenda" e "Normative Addenda".

Nel 1994, Il Technical Corrigendum 1 ha modificato lo Standard in circa 40 punti, nella maggior parte dei casi con piccole correzioni or chiarimenti. Più recentemente, il Normative Addendum 1 ha aggiunti circa 50 pagine di nuovo materiale, che principalmente specifica nuove funzioni di libreria per l'internalizzazione. La produzione di Technical Corrigenda è un processo continuo, e se ne aspetta una nuova nella seconda metà del 1995. Inoltre, sia l'ANSI che l'ISO richiedono una revisione periodica dei loro standard. Questo processo è cominciato nel 1995, e probabilmente produrrà uno standard completamente rivisto (battezzato "C9X" in quanto si assume che sia completato nel 1999).

Lo standard ANSI originale comprendeva un "Rationale" che spiegava molte delle sue decisioni e discuteva molti punti sottili, alcuni dei quali non sono trattati qui. (Il Rationale non era parte dello standard X3.159-1989, ma era incluso solo a titolo informativo, e non è diventato parte dello standard ISO).

11.2: Dove posso trovare una copia dello Standard?

ISO Sales
Case Postale 56
CH-1211 Ginevra 20
Svizzera

(o vedere alla URL http://www.iso.ch, o consultare la FAQ di comp.std.internat, Standards.Faq).

Il libro "Annotated ANSI C Standard", con annotazioni di Herbert Schildt, contiene gran parte del testo dell'ISO 9899; è edito da Osborne/McGraw-Hill, ISBN 0-07-881952-0. Questo libro costa meno dello standard, e qualcuno ha suggerito che la differenza rifletta il valore delle annotazioni: sono piene di errori e omissioni, e mancano alcune pagine dello standard stesso. Molte persone sulla rete consigliano di ignorare del tutto le annotazioni. Una revisione delle annotazioni ("annotated annotations") di Clive Feather si trova sul web all'indirizzo http://www.lysator.liu.se/c/schildt.html .

Il testo del Rationale (non lo standard competo) si può scaricare via ftp anonima da ftp.uu.net (vedi domanda 18.16) dal direttorio doc/standards/ansi/X3.159-1989, ed è anche disponibile sul web all'indirizzo http://www.lysator.liu.se/c/rat/title.html. Il Rationale è stato anche stampato dalla Silicon Press, ISBN 0-929306-07-4.

Vedi anche la domanda 11.2a sotto.

11.2a: Dove posso trovare informazioni sugli aggiornamenti allo standard?

11.3: Il mio compilatore ANSI si lamenta di un "mismatch" quando compila:

extern int func(float);

int func(x)
float x;
{ ...
}

Avete mischiato la dichiarazione di prototipo, nel nuovo stile, "extern int func(float);" con la definizione della funzione, nel vecchio stile, "int func(x) float x;". Solitamente mischiare i due stili è innocuo (vedi domanda 11.4), ma non in questo caso.

Il vecchio C (e l'ANSI C, in assenza di prototipi, o in liste di argomenti a lunghezza variabile; vedi domanda 15.2) "allarga" alcuni argomenti quando vengono passati a funzioni. I float sono promossi a double, e i char e gli short int sono promossi a int. (Per le funzioni vecchio stile, i valori sono automaticamente riconvertiti ai tipi ridotti corrispondenti all'interno del corpo della funzione chiamata, se sono dichiarati in quel modo lì.)

Il problema si può risolvere usando la sintassi nuova in modo consistente anche nella definizione:

int func(float x) { ... }

o cambiando la dichiarazione di prototipo nuovo stile in modo che concordi con la definizione vecchio stile:

extern int func(double);

(In questo caso, sarebbe più chiaro cambiare la definizione vecchio stile in modo che usi anch'essa double, se l'indirizzo del parametro non viene letto.)

Può anche essere più sicuro evitare del tutto i tipi "stretti" (char, short int, e float) per gli argomenti di funzione e i tipi tornati.

Vedi anche la domanda 1.25.

Riferimenti: K&R1 Sez. A7.1; K&R2 Sez. A7.3.2; ANSI Sez. 3.3.2.2, Sez. 3.5.4.3; ISO Sez. 6.3.2.2, Sez. 6.5.4.3; Rationale Sez. 3.3.2.2, Sez. 3.5.4.3; H&S Sez. 9.2, Sez. 9.4.

11.4: Si possono mischiare la sintassi nuova e quella vecchia per le funzioni?

Riferimenti: ANSI Sez. 3.7.1, Sez. 3.9.5; ISO Sez. 6.7.1, Sez. 6.9.5; H&S Sez. 9.2.2, Sez. 9.2.5.

11.5: Perché la dichiarazione

extern f(struct x *p);

mi da una warning oscura del tipo "struct x introduced in prototype scope"?

Per risolvere il problema, si può anteporre al prototipo la dichiarazione vaga

struct x;

che colloca una dichiarazione (incompleta) della struct x nello scope di file, in modo che si possa essere certi che tutte le successive dichiarazioni che coinvolgono struct x siano riferita alla stessa struct x.

Riferimenti: ANSI Sez. 3.1.2.1, Sez. 3.1.2.6, Sez. 3.5.2.3; ISO Sez. 6.1.2.1, Sez. 6.1.2.6, Sez. 6.5.2.3.

11.8: Non capisco come mai non posso usare valori dichiarati const negli inizializzatori e nelle dimensioni dei vettori, come in

const int n = 5;
int a[n];

Il qualificatore const in realtà significa "a sola lettura"; un oggetto qualificato in questo modo è un oggetto a tempo di esecuzione che non può essere assegnato (normalmente). Il valore di un oggetto qualificato come const quindi non è una espressione costante nel vero senso del termine. (Su questo punto il C differisce dal C++). Se si ha bisogno di una vera costante a tempo di compilazione, si deve usare una #define di preprocessore (o magari una enum).

Riferimenti: ANSI Sez. 3.4; ISO Sez. 6.4; H&S Secz. 7.11.2,7.11.3.

11.9: Qual è la differenza fra "const char *p" e "char * const p"?

Queste dichiarazioni vanno lette "da dentro a fuori" per capirle; vedi anche la domanda 1.21.

Riferimenti: ANSI Sez. 3.5.4.1 esempi; ISO Sez. 6.5.4.1; Rationale Sez. 3.5.4.1; H&S Sez. 4.4.4.

11.10: Perché non posso passare un char ** a una funzione che si aspetta un const char **?

Riferimenti: ANSI Sez. 3.1.2.6, Sez. 3.3.16.1, Sez. 3.5.3; ISO Sez. 6.1.2.6, Sez. 6.3.16.1, Sez. 6.5.3; H&S Sez. 7.9.1.

11.12: Posso dichiarare il main() come void, per zittire questi fastidiosi messaggi "main returns no value"?

Dichiarare una funzione come void non serve semplicemente a evitare delle warning: può anche causare una diversa sequenza di invocazione/ritorno dalla funzione, incompatibile con quella attesa dal chiamante (nel caso del main, il codice di startup del sistema a tempo di esecuzione del C).

(Si noti che questa discussione a proposito del main() si applica solo ad implementazioni "ospiti"; niente di tutto ciò vale per le implementazioni "libere", che potrebbero persino non avere un main(). Comunque, le implementazioni libere sono relativamente rare, e se ne usate una, probabilmente lo sapete. Se non avete mai sentito questa distinzione, probabilmente state usando un'implementazione ospitata, e le regole di cui sopra valgono).

Riferimenti: ANSI Sez. 2.1.2.2.1, Sez. F.5.1; ISO Sez. 5.1.2.2.1, Sez. G.5.1; H&S Sez. 20.1; CT&P Sez. 3.10.

11.13: E cosa mi dite del terzo argomento del main, envp?

Riferimenti: ANSI Sez. F.5.1; ISO Sez. G.5.1; H&S Sez. 20.1.

11.14: Sono convinto che la dichiarazione void main() non possa darmi alcun problema, visto che chiamo exit() invece di usare l'istruzione return, e comunque il mio sistema operativo ignora lo stato di uscita/ritorno del programma.

11.15: Il libro che sto usando, "Programmazione C per il perfetto idiota", usa sempre void main().

11.16: È vero che exit(status) è equivalente a tornare status con return dal main()?

Riferimenti: K&R2 Sez. 7.6; ANSI Sez. 2.1.2.2.3; ISO Sez. 5.1.2.2.3.

11.17: Sto cercando di usare l'operatore di "stringhizzazione" ANSI `#' per inserire il valore di una costante simbolica in un messaggio, ma continua a stringhizzare il nome della macro invece del suo valore.

#define Str(x) #x
#define Xstr(x) Str(x)
#define OP plus
char *opname = Xstr(OP);

Questo codice rende opname uguale a "plus" anziché "OP".

Una circonlocuzione equivalente è necessaria quando si usa l'operatore di unione di token ## se si vogliono concatenare i valori (anziché i nomi) di due macro.

Riferimenti: ANSI Sez. 3.8.3.2, Sez. 3.8.3.5 esempio; ISO Sez. 6.8.3.2, Sez. 6.8.3.5.

11.18: Cosa significa il messaggio "warning: macro replacement within a string literal"?

#define TRACE(var, fmt) printf("TRACE: var = fmt\n", var)

in un modo per cui le invocazioni come

TRACE(i, %d);

erano espanse come

printf("TRACE: i = %d\n", i);

In altre parole, i parametri della macro erano espansi anche dentro le stringhe letterali e le costanti carattere. L'espansione di macro non è definita cosí da K&R o dallo standard. Quando si vuole proprio trasformare gli argomenti di macro in stringhe, si può usare il nuovo operatore di preprocessore #, insieme alla concatenazione di stringhe letterali (un'altra innovazione ANSI):

#define TRACE(var, fmt) \
printf("TRACE: " #var " = " #fmt "\n", var)

Vedi anche la domanda 11.17 sopra.

Riferimenti: H&S Sez. 3.3.8.

11.19: Ricevo strani errori all'interno di linee che ho tagliato fuori con #ifdef

Riferimenti: ANSI Sez. 2.1.1.2, Sez. 3.1; ISO Sez. 5.1.1.2, Sez. 6.1; H&S Sez. 3.2.

11.20: Cosa sono le #pragma e a cosa servono?

Riferimenti: ANSI Sez. 3.8.6; ISO Sez. 6.8.6; H&S Sez. 3.7.

11.21: Cosa significa "#pragma once"? L'ho trovato in diversi file di include.

11.22: È legale la dichiarazione char a[3] = "abc";? Cosa significa?

Nella maggior parte dei casi, si dovrebbe lasciare che il compilatore conti gli inizializzatori quando si inizializzano vettori (nel caso dell'inizializzatore "abc", naturalmente, la dimensione calcolata sarà 4).

Riferimenti: ANSI Sez. 3.5.7; ISO Sez. 6.5.7; H&S Sez. 4.6.4.

11.24: Perché non posso eseguire operazioni aritmetiche su un puntatore void*?

Riferimenti: ANSI Sez. 3.1.2.5, Sez. 3.3.6; ISO Sez. 6.1.2.5, Sez. 6.3.6; H&S Sez. 7.6.2.

11.25: Qual è la differenza fra memcpy() e memmove()?

Riferimenti: K&R2 Sez. B3; ANSI Sez. 4.11.2.1, Sez. 4.11.2.2; ISO Sez. 7.11.2.1, Sez. 7.11.2.2; Rationale Sez. 4.11.2; H&S Sez. 14.3; PCS Sez. 11.

11.26: Cosa dovrebbe fare malloc(0)? Tornare un puntatore nullo o un puntatore a 0 byte?

Riferimenti: ANSI Sez. 4.10.3; ISO Sez. 7.10.3; PCS Sez. 16.1.

11.27: Come mai lo standard ANSI non garantisce più di 6 caratteri case-insensitive significativi per gli identificatori esterni?

Questa concessione ai linker restrittivi attuali doveva necessariamente fatta, per quanto molti vi si siano opposti in modo veemente). (Il Rationale nota che mantenerla è stato "estremamente doloroso.") Se non siete d'accordo, o avete pensato un trucco attraverso il quale un compilatore soffocato da un linker restrittivo potrebbe fornire al programmatore l'illusione di più caratteri significativi negli identificatori esterni, leggete l'eccellente sezione 3.1.2 nel Rationale X3.159 (vedi domanda 11.1), che discute vari schemi del genere e spiega perché non potevano essere imposti dallo standard.

Riferimenti: ANSI Sez. 3.1.2, Sez. 3.9.1; ISO Sez. 6.1.2, Sez. 6.9.1; Rationale Sez. 3.1.2; H&S Sez. 2.5.

11.29: Il mio compilatore rifiuta i programmi più semplici, segnalando ogni tipo di errori di sintassi.

Vedi anche le domande 1.31, 10.9, 11.30, e 16.2a.

11.30: Perché alcune routine della libreria standard ANSI/ISO risultano indefinite, anche se ho un compilatore ANSI?

11.31: Esitono tool per convertire i programmi in C vecchio stile in ANSI C, o viceversa, o per generare automaticamente prototipi?

Il programma unproto (/pub/unix/unproto5.shar.Z su ftp.win.tue.nl) è un filtro che si pone fra il preprocessore e il passo successivo del compilatore, convertendo al volo la maggior parte dell'ANSI C in C tradizionale.

Il pacchetto GhostScript della GNU contiene un piccolo programma chiamato ansi2knr.

Convertire l'ANSI C al vecchio stile richiede attenzione in quanto questa conversione non sempre può essere fatta in automatico in modo sicuro. L'ANSI C ha caratteristiche complesse nuove che non c'erano nel C di K&R. Occorre soprattutto fare attenzione alle chiamate di funzioni prototipate; ci sarà probabilmente bisogno di inserire cast esplicit. Vedi anche le domande 11.3 e 11.29.

Esistono molti generatori di prototipi, spesso realizzati come modifiche a lint. Un programma chiamato CPROTO è stato pubblicato su comp.sources.misc nel marzo 1992. C'è un altro programma chiamato "cextract." Molti produttori forniscono semplici utility come queste insieme ai loro compilatori. Vedi anche la domanda 18.16. (Comunque si deve stare attenti quando si generano prototipi per vecchie funzioni con parametri "stretti"; vedi la domanda 11.3.)

Infine, siete proprio sicuri di aver bisogno di convertire tanto codice vecchio in C ANSI? La sintassi vecchio stile è ancora accettabile (a parte per le funzioni con un numero variabile di argomenti; vedi la sezione 15), e una conversione affrettata può introdurre facilmente errori. (Vedi la domanda 11.3.)

11.32: Perché il compilatore Frobozz Magic, che dice di essere conforme ANSI, non accetta questo codice? Sono certo che sia ANSI, perché gcc lo accetta.

11.33: Sembra che qualcuno ci tenga a distingere fra comportamento "definito dall'implementazione", "non specificato", e "non definito". Qual è la differenza?

Si noti che poiché lo standard non impone alcun requisito sul comportamento di un compilatore che si trovi a trattare un caso di comportamento indefinito, il compilatore può fare assolutamente qualsiasi cosa. In particolare, non c'è garanzia che il resto del programma si comporterà normalmente. È pericoloso pensare di poter tollerare un comportamento indefinito in un programma; vedi la domanda 3.2 per un esempio relativamente semplice.

Se si è interessati a scrivere codice portabile, si possono ignorare le distinzioni, poiché si vorrà evitare codice che dipenda da uno qualsiasi dei tre comportamenti.

Vedi anche le domande 3.9 e 11.34.

Riferimenti: ANSI Sez. 1.6; ISO Sez. 3.10, Sez. 3.16, Sez. 3.17; Rationale Sez. 1.6.

11.34: Sono stupito del fatto che lo standard ANSI lasci così tanti aspetti indefiniti. Non sarebbe compito di uno standard standardizzare queste cose?

Uno standard per un linguaggio di programmazione può essere visto come un patto fra gli utenti del linguaggio e i costruttori di compilatori. Il patto stabilisce le caratteristiche del linguaggio che i costruttori di compilatori si impegnano a fornire, e che gli utenti possono assumere. Esso stabilisce anche le regole che gli utenti si impegnano a seguire e che i costruttori di compilatori possono assumere siano seguite. Finché entrambe le parti tengono fede al patto, i programmi dovrebbero funzionare. Se una qualsiasi delle parti tradisce uno qualsiasi dei propri impegni, non è più garantito che funzioni nulla.

Vedi anche la domanda 11.35.

Riferimenti: Rationale Sez. 1.1.

11.35: La gente continua a sostenere che il comportamento di i = i++ è indefinito, ma io l'ho provato su un compilatore conforme ANSI, e ho ottenuto il risultato che mi aspettavo.

12. Stdio

12.1: Cosa c'è che non va in questo codice?

char c;
while((c = getchar()) != EOF) ...

La variabile usata per ricevere il valore di ritorno di getchar deve essere un int. La getchar() può tornare un qualsiasi valore char, oppure EOF. Se si passa il valore di ritorno di getchar a un char, può succedere che un carattere normale sia scorrettamente interpretato come EOF, oppure che l'EOF sia alterato (specialmente se il tipo char è senza segno) e quindi non riconosciuto.

Riferimenti: K&R1 Sez. 1.5; K&R2 Sez. 1.5.1; ANSI Sez. 3.1.2.5, Sez. 4.9.1, Sez. 4.9.7.5; ISO Sez. 6.1.2.5, Sez. 7.9.1, Sez. 7.9.7.5; H&S Sez. 5.1.3, Sez. 15.1, Sez. 15.6; CT&P Sez. 5.1; PCS Sez. 11.

12.2: Perché il codice

while(!feof(infp)) {
   fgets(buf, MAXLINE, infp);
   fputs(buf, outfp);
}

copia due volte l'ultima riga?

Riferimenti: K&R2 Sez. 7.6; ANSI Sez. 4.9.3, Sez. 4.9.7.1, Sez. 4.9.10.2; ISO Sez. 7.9.3, Sez. 7.9.7.1, Sez. 7.9.10.2; H&S Sez. 15.14.

12.4: Il prompt e l'output intermedio del mio programma non appaiono sempre a schermo, specialmente se metto l'output in pipe attraverso un altro programma.

Riferimenti: ANSI Sez. 4.9.5.2; ISO Sez. 7.9.5.2.

12.5: È possibile leggere un carattere alla volta, senza aspettare che l'utente digiti invio?

12.6: Come faccio a stampare il carattere '%' in una printf? Ho provato \%, ma non funziona.

Vedi anche la domanda 19.17.

Riferimenti: K&R1 Sez. 7.3; K&R2 Sez. 7.2; ANSI Sez. 4.9.6.1; ISO Sez. 7.9.6.1.

12.9: Qualcuno mi ha detto che è scorretto usare %lf con printf(). Come mai printf() usa %f per i double, se scanf() usa %lf?

Riferimenti: K&R1 Sez. 7.3, Sez. 7.4; K&R2 Sez. 7.2, Sez. 7.4; ANSI Sez. 4.9.6.1, Sez. 4.9.6.2; ISO Sez. 7.9.6.1, Sez. 7.9.6.2; H&S Sez. 15.8, Sez. 15.11; CT&P Sez. A.1.

12.10: Come si fa a implementare un campo a larghezza variabile con printf? Ovvero, invece di scrivere per esempio %8d, voglio che la dimensione sia specificata a run time.

Riferimenti: K&R1 Sez. 7.3; K&R2 Sez. 7.2; ANSI Sez. 4.9.6.1; ISO Sez. 7.9.6.1; H&S Sez. 15.11.6; CT&P Sez. A.1.

12.11: Come si fa a stampare numeri con punti che separano le migliaia? Come si fa a formattare i numeri che rappresentano somme di denaro?

Riferimenti: ANSI Sez. 4.4; ISO Sez. 7.4; H&S Sez. 11.6.

12.12: Perché la chiamata scanf("%d", i) non funziona?

12.13: Perché il codice:

double d;
scanf("%f", &d);

non funziona?

12.15: Come si fa a specificare un campo di dimensione variable nella stringa di formato della scanf()?

12.17: Se leggo un numero da tastiera con scanf ("%d\n", &n), sembra bloccarsi finché l'utente non inserisce una linea extra di input.

Riferimenti: K&R2 Sez. B1.3; ANSI Sez. 4.9.6.2; ISO Sez. 7.9.6.2; H&S Sez. 15.8.

12.18: Leggo un numero con scanf %d e poi una stringa con gets(), ma il compilatore sembra saltare la chiamata a gets()!

Come regola generale, non si dovrebbero alternare chiamate a scanf() con chiamate a gets() (o a qualsiasi altra routine di input); il trattamento particolare che la scanf fa dei newline conduce quasi sempre a problemi. Conviene usare la scanf() per leggere tutto o non usarla affatto.

Vedi anche le domande 12.20 e 12.23.

Riferimenti: ANSI Sez. 4.9.6.2; ISO Sez. 7.9.6.2; H&S Sez. 15.8.

12.19: Pensavo che per usare scanf() fosse più sicuro controllare il suo valore di ritorno per assicurarsi che l'utente abbia digitato i valori numerici che mi aspetto, ma ogni tanto sembra che entri in un ciclo infinito.

Vedi anche la domanda 12.20.

Riferimenti: ANSI Sez. 4.9.6.2; ISO Sez. 7.9.6.2; H&S Sez. 15.8.

12.20: Perché tutti sconsigliano di usare scanf()? Cosa si dovrebbe usare al suo posto?

(scanf può essere adeguata se viene utilizzata per leggere input prodotto automaticamente da un programma, per esempio un file dati realizzato con fprintf).

Riferimenti: K&R2 Sez. 7.4.

12.21: Come si fa a capire quanto deve essere grande il buffer in una chiamata a sprintf? Come si fa a evitare l'overflow del buffer?

Quando la stringa di formato usata da sprintf() è nota e relativamente semplice, di solito si può predire la dimensione del buffer ad hoc. Se il formato consiste di uno o due %s, si può contare i caratteri fissi nella stringa di formato (o farli contare da sizeof) e aggiungere il risultato della chiamata a strlen sulle stringhe da inserire. Il numero dei caratteri prodotti da %d non può superare

((sizeof(int) * CHAR_BIT + 2) / 3 + 1) /* +1 per il '-' */

(CHAR_BIT è definito in <limits.h>), anche se questo calcolo può essere troppo pessimista (calcola il numero di caratteri necessari per la rappresentazione in base 8 di un numero; è garantito che un'espansione in base 10 richieda lo stesso o meno spazio). Se la stringa di formato è più complessa, o addirittura non è nota fino a runtime, predire la dimensione necessaria per il buffer diventa difficile come reimplementare sprintf da capo, e di conseguenza è facile commettere errori (e lo si sconsiglia). Una soluzione estrema che viene talvolta suggerita consiste nell'usare fprintf per stampare lo stesso testo su un file temporaneo, e controllare il return di fprintf o la dimensione del file (ma vedi la domanda 19.12, e attenzione agli errori di scrittura). Se esiste la possibilità che il buffer non sia sufficientemente grande, probabilmente non vorrete chiamare sprintf senza qualche garanzia che il buffer non trabocchi e non venga sovrascritta qualche altra area di memoria. Se la stringa di formato è nota, si può limitare l'espansione di %s usando %Ns dove N è un qualche numero, oppure %.*s (vedi anche la domanda 12.10). Molte stdio (inclusa quella della GNU e di 4.4BSD) forniscono la ovvia funzione snprintf, che può essere usata così:

snprintf(buf, dimensione_buffer, "Hai scritto\"%s\"", answer);

e speriamo che una futura revisione del C ANSI/ISO includerà questa funzione.

12.23: Perché tutti sconsigliano di usare gets()?

Riferimenti: Rationale Sez. 4.9.7.2; H&S Sez. 15.7.

12.24: Perché errno contiene ENOTTY dopo una chiamata a printf()?

Riferimenti: ANSI Sez. 4.1.3, Sez. 4.9.10.3; ISO Sez. 7.1.4, Sez. 7.9.10.3; CT&P Sez. 5.4 p. 73; PCS Sez. 14.

12.25: Che differenza c'è fra fgetpos/fsetpos e ftell/fseek? A cosa servono fgetpos() e fsetpos()?

Riferimenti: K&R2 Sez. B1.6; ANSI Sez. 4.9.1, Sez. 4.9.9.1, 4.9.9.3; ISO Sez. 7.9.1, Sez. 7.9.9.1, 7.9.9.3; H&S Sez. 15.5.

12.26: Come faccio a eseguire il flush dell'input pendente in modo che i caratteri digitati in anticipo dall'utente non siano letti al prossimo prompt? fflush(stdin) funziona?

Non esiste un modo standard per scartare caratteri non letti da uno stream di input stdio, né questo servirebbe a molto, perché i caratteri non letti possono anche accumularsi in altri buffer a livello di sistema operativo. Si possono leggere e scartare caratteri fino al '\n', o usare la funzione flushinp() di curses, o usare qualche tecnica dipendente dal sistema. Vedi anche le domande 19.1 and 19.2.

Riferimenti: ANSI Sez. 4.9.5.2; ISO Sez. 7.9.5.2; H&S Sez. 15.2.

12.30: Sto cercando di aggiornare un file usando la modalità di fopen "r+", leggendo una stringa, e riscrivendola modificata, ma non funziona.

Riferimenti: ANSI Sez. 4.9.5.3; ISO Sez. 7.9.5.3.

12.33: È possibile redirigere stdin o stdout su file da dentro un programma?

Riferimenti: ANSI Sez. 4.9.5.4; ISO Sez. 7.9.5.4; H&S Sez. 15.2.

12.34: Una volta che ho usato freopen(), come faccio a recuperare lo stdout (o stdin) originale?

12.38: Come posso leggere correttamente un file binario? Mi capita di vedere che i valori 0x0a e 0x0d creino problemi, e sembra anche che venga raggiunta prematuramente la fine del file (EOF) se i dati contengono il valore 0x1a.

Si noti che la distinzione fra file binario e file di testo ha luogo all'apertura del file: una volta che il file è aperto, le funzioni di I/O che si utilizzano non contano. Vedi anche la domanda 20.5.

Riferimenti: ANSI Sez. 4.9.5.3; ISO Sez. 7.9.5.3; H&S Sez. 15.2.1.

13. Funzioni di libreria

13.1: Come si fa a convertire numeri in stringhe (il contrario di atoi)? C'è una funzione itoa?

Ovviamente sprintf() può anche essere usata per convertire long o numeri floating-point in stringhe (usando %ld o %f).

Riferimenti: K&R1 Sez. 3.6; K&R2 Sez. 3.6.

13.2: Perché strncpy() non piazza sempre il terminatore '\0' in fondo alla stringa di destinazione?

Quando si copiano byte qualsiasi (anziché stringhe) memcpy() è solitamente meglio di strncpy().

13.5: Perché alcune versioni di toupper() si comportano in modo strano se ricevono una lettera maiuscola? Perché alcuni programmi chiamano islower() prima di toupper()?

Riferimenti: ANSI Sez. 4.3.2; ISO Sez. 7.3.2; H&S Sez. 12.9; PCS.

13.6: Come si fa a suddividere una stringa in campi separati da spazi bianchi? Come si fa a simulare il procedimento con cui vengono passati argc e argv al main?

Riferimenti: K&R2 Sez. B3; ANSI Sez. 4.11.5.8; ISO Sez. 7.11.5.8; H&S Sez. 13.7; PCS.

13.7: Devo scrivere del codice per gestire espressioni regolari e wild characters.

Ci sono moltissimi package per la gestione di espressioni regolari. La maggior parte usano un paio di funzioni, una per "compilare" l'espressione regolare, e una per "eseguirle" (cioè verificare se c'è un match fra una data stringa e l'espressione). Cercate header file con nomi come o , e funzioni chiamate regcmp/regex, regcomp/regexec, o re_comp/re_exec. (Tali funzioni possono essere contenute in una libreria regexp). Un package molto popolare e free, realizzato da Henry Spencer, è disponibile presso ftp.cs.toronto.edu in pub/regexp.shar.Z o in altri archivi. Il GNU project include un package chiamato rx. Vedi anche la domanda 18.16.

Il matching di wildcard per i nomi di file (talvolta detto "globbing") si fa in modi diversi su diversi sistemi. Su Unix, le wildcards sono automaticamente espanse dalla shell prima che un processo venga invocato, pertanto è raro che un programma se ne debba occupare esplicitamente. Sotto i compilatori MS-DOS, spesso esiste uno speciale file oggetto che può essere linkato a un programma per espandere le wildcard durante la costruzione di argv. Molti sistemi (inclusi MS-DOS e VMS) forniscono servizi di sistema per elencare o aprire i file specificati usando wildcard. Verificate la documentazione del vostro compilatore o delle vostre librerie. Si vedano anche le domande 19.20 e 20.3.

13.8: Sto cercando di ordinare un vettore di stringhe con qsort(), usando strcmp() come funzione di confronto, ma non funziona.

/* compare strings via pointers */
int pstrcmp(const void *p1, const void *p2)
{
   return strcmp(*(char * const *)p1, *(char * const *)p2);
}

Gli argomenti della funzione di confronto sono espressi come "puntatori generici", const void *. Riconvertendoli in ciò che "sono realmente" (char**) e dereferenziandoli, si ottengono i char* che possono essere passati a strcmp(). (Nel caso di un compilatore pre-ANSI, i parametri puntatore devono essere dichiarati come char* invece che come void*, e i const vanno tolti).

(Non fatevi ingannare dalla discussione in K&R2 Sez. 5.11, che non parla della qsort della libreria Standard).

Riferimenti: ANSI Sez. 4.10.5.2; ISO Sez. 7.10.5.2; H&S Sez. 20.5.

13.9: Ora sto cercando di ordinare con qsort un vettore di strutture. La mia funzione di confronto prende in ingresso puntatori a strutture, ma il compilatore mi dà una warning dicendo che la funzione è del tipo sbagliato per qsort(). Quale cast devo fare per zittirlo?

int mystructcmp(const void *p1, const void *p2)
{
   const struct mystruct *sp1 = p1;
   const struct mystruct *sp2 = p2;
   /* confronta sp1->qualcosa e sp2->qualcosa ... */
}

(Le conversioni da puntatori generici a puntatori a struct avvengono all'inizializzaizone di sp1 e sp2; il compilatore esegue le conversioni implicitamente perché p1 e p2 sono puntatori a void. In un compilatore pre-ANSI si richiederebbero puntatori a char e cast espliciti. Vedi anche 7.7).

Se, d'altra parte, si vogliono ordinare puntatori a strutture, sarà necessaria un'ulteriore indirezione, come nel caso di 13.8: sp1 = *(struct mystruct **)p1.

In generale, non è una buona idea inserire dei cast per "zittire il compilatore". Le warning del compilatore, di solito, cercano di dirvi qualcosa, e a meno che non sappiate esattamente cosa state facendo, ignorarle o imbavagliarle è a vostro rischio. Vedi anche la domanda 4.9.

Riferimenti: ANSI Sez. 4.10.5.2; ISO Sez. 7.10.5.2; H&S Sez. 20.5.

13.10: Come si fa a ordinare una lista?

Riferimenti: Knuth Sez. 5.2.1, Sez. 5.2.4; Sedgewick Sez. 8, Sez. 12.

13.11: Posso ordinare più dati di quelli che ci stanno in memoria?

Riferimenti: Knuth Sez. 5.4; Sedgewick Sez. 13.

13.12: Come faccio ad accedere alla data o all'ora corrente in un programma C?

#include <stdio.h>
#include <time.h>

main()
{
   time_t now;
   time(&now);
   printf("Oggi è %.24s.\n", ctime(&now));
   return 0;
}

Riferimenti: K&R2 Sez. B10; ANSI Sez. 4.12; ISO Sez. 7.12; H&S Sez. 18.

13.13: So che la routine di libreria localtime() converte un time_t in una struttura struct tm, e che ctime() converte un time_t in una stringa stampabile. Come si fa l'operazione inversa di convertire una struct tm o una stringa in un time_t?

Convertire una stringa in time_t è più complesso, a causa della grande varietà di formati esistenti per le date e ore. Alcuni sistemi forniscono una funzione strptime() che è sostanzialmente il contrario di strftime(). Altre routine molto usate sono partime() (distribuita con il package RCS) e getdate() (e alcune altre della distribuzione C news). Vedi 18.16.

Riferimenti: K&R2 Sez. B10; ANSI Sez. 4.12.2.3; ISO Sez. 7.12.2.3; H&S Sez. 18.4.

13.14: Come faccio a sommare N giorni a una data? Come faccio a calcolare la differenza fra due date?

La garanzia che queste soluzioni funzionino c'è solo per date nel range che può essere rappresentato da time_t. Il campo tm_mday è un int, perciò distanza di più di circa 32,736 giorni possono causare overflow. Si noti anche che in caso di cambiamenti di ora legale, i giorni non sono lunghi 24 ore (perciò non bisogna assumere che la divisione per 86400 sia esatta).

Un altro approccio a entrambi i problemi consiste nell'usare "giorni giuliani". Implementazioni di routine per i giorni giuliani si trovano nel file JULCAL10.ZIP negli archivi Simtel/Oakland (vedi 18.16) e nell'articolo "Date conversions" citato nella Bibliografia.

Vedi anche 13.13, 20.31, e 20.32.

Riferimenti: K&R2 Sez. B10; ANSI Sez. 4.12.2.2,4.12.2.3; ISO Sez. 7.12.2.2,7.12.2.3; H&S Sez. 18.4,18.5; David Burki, "Date Conversions".

13.15: Devo generare numeri casuali.

Se proprio avete bisogno di implementare un generatore di numeri casuali, c'è abbondanza di materiale al riguardo in letteratura; si veda la Bibliografia. C'è anche un vasto numero di package in rete: cercate r250, RANLIB, e FSULTRA (vedi 18.16).

Riferimenti: K&R2 Sez. 2.7, Sez. 7.8.7; ANSI Sez. 4.10.2.1; ISO Sez. 7.10.2.1; H&S Sez. 17.7; PCS Sez. 11; Knuth Vol. 2 Cap. 3; Park and Miller, "Random Number Generators: Good Ones are hard to Find".

13.16: Come posso ottenere un numero casuale in un certo range?

rand() % N

(che torna numeri da 0 a N-1) è un po' debole, perchè i bit bassi dei numeri prodotti da alcuni generatori non sono molto random. (Vedi 13.18). Un metodo migliore è qualcosa come

(int)((double)rand() / ((double)RAND_MAX + 1) * N)

Se non volete usare i numeri in virgola mobile, si può usare

rand() / (RAND_MAX / N + 1)

Entrambi i metodi richiedono che si conosca RAND_MAX (definita nei compilatore ANSI in ), e assumono che N sia molto minore di RAND_MAX.

(Si noti, tra l'altro, che RAND_MAX è una *costante* che vi dice qual è il range fissato della funzione rand(). Non è possibile cambiare il valore di RAND_MAX, e non c'è modo di richiedere che rand() ritorni numeri in un altro range.)

Se usate un generatore di numeri casuali che torna valori in virgola mobile fra 0 e 1, tutto ciò che dovete fare per ottenere numeri da 0 a N-1 è moltiplicare per N il valore generato.

Riferimenti: K&R2 Sez. 7.8.7; PCS Sez. 11.

13.17: Ogni volta che eseguo il mio programma, rand() ritorna la stessa sequenza di numeri casuali.

Riferimenti: K&R2 Sez. 7.8.7; ANSI Sez. 4.10.2.2; ISO Sez. 7.10.2.2; H&S Sez. 17.7.

13.18: Ho bisogno di un valore casuale vero/falso, sto usando rand()%2, ma alterna 0, 1, 0, 1, 0...

Riferimenti: Knuth Sez. 3.2.1.1.

13.20: Come si fa a generare numeri casuali con distribuzione normale o gaussiana?

#include <stdlib.h>
#include <math.h>

double gaussrand()
{
   static double V1, V2, S;
   static int phase = 0;
   double X;

   if(phase == 0) {
     do {
       double U1 = (double)rand() / RAND_MAX;
       double U2 = (double)rand() / RAND_MAX;

       V1 = 2 * U1 - 1;
       V2 = 2 * U2 - 1;
       S = V1 * V1 + V2 * V2;
     } while(S >= 1 || S == 0);

     X = V1 * sqrt(-2 * log(S) / S);
   } else
     X = V2 * sqrt(-2 * log(S) / S);
   phase = 1 - phase;
   return X;
}

Si veda la versione estesa di questo listato (domanda 20.40) per ulteriori idee.

Riferimenti: Knuth Sez. 3.4.1; Box e Muller, "A Note on the Generation of Random Normal Deviates"; Press et al., _Numerical Recipes in C_ Sez. 7.2.

13.24: Sto cercando di fare il porting di un vecchio programma. Ho errori di tipo "undefined external" per le seguenti funzioni: index, rindex, bcopy, bcmp, bzero.

Al contrario, se vi capita di usare un vecchio sistema che non ha le funzioni strchr, strrchr, memmove, eccetera, è possibile implementarle attraverso le funzioni vecchie (con le sostituzioni opposte).

Riferimenti: PCS Sez. 11.

13.25: Continuo ad avere errori per funzioni di libreria non definite, anche se sto facendo #include di tutti i file header.

13.26: Continuo ad avere errori per funzioni di libreria non definite, anche se sto esplicitamente richiedendo il link delle librerie.

13.28: Cosa significa quando il linker dice che _end è indefinito?

14. Virgola mobile

14.1: Perché quando assegno, per esempio, 3.1 a una variabile float, la printf stampa il suo valore come 3.0999999?

14.2: Sto cercando di calcolare radici quadrate, ma ottengo numeri assurdi.

Riferimenti: CT&P Sez. 4.5.

14.3: Sto cercando di eseguire alcuni semplici calcoli trigonometrici, e ho incluso , ma ho ancora l'errore "undefined: sin".

14.4: I miei calcoli in virgola mobile si comportano in modo strano e danno risultati diversi su diverse macchine.

Se il problema non è così semplice, ricorda che il formato in virgola mobile fornisce solo un'approssimazione della reale aritmetica dei numeri reali. Underflow, perdita cumulativa di precisione e altre anomalie sono comuni.

Non assumete che i risultati dei calcoli in virgola mobile siano esatti, e specialmente non assumere di poter confrontare due numeri in virgola mobile correttamente. (Non usare neanche strani "fattori fuzzy"; vedi 14.5).

Questi problemi non sono più gravi per il C di quanto siano per altri linguaggi. Molti aspetti dell'aritmetica floating point sono definiti dallo standard con l'espressione "secondo le regole del processore" (vedi anche 11.34) perché altrimenti il compilatore, su una macchina che non ha il modello "giusto", sarebbe costretto a fare simulazioni troppo costose.

In questo articoloo è impossibile elencare tutte le numerosissime trappole associate all'uso dei numeri in virgola mobile, o le soluzioni a questi problemi. Un buon libro di programmazione numerica dovrebbe fornire delle indicazioni di base; vedi anche i riferimenti.

Riferimenti: Kernighan e Plauger, _The Elements of Programming Style_ Sez. 6; Knuth, vol. 2 cap. 4; David Goldberg, "What Every Computer Scientist Should Know about Floating-Point Arithmetic".

14.5: Visto che normalmente non si può verificare l'uguaglianza esatta di due numeri in virgola mobile, c'è almeno un buon modo per verificare se sono "abbastanza vicini"?

double a, b;
...
if(a == b) /* SBAGLIATO */

si può usare qualcosa come

#include <math.h>

if(fabs(a - b) <= epsilon * fabs(a))

per un epsilon scelto opportunamente (non zero!)

Riferimenti: Knuth Sez. 4.2.2.

14.6: Come si arrotondano i numeri?

(int)(x + 0.5)

Questa tecnica non funziona correttamente per numeri negativi (per tener conto dei quali si potrebbe usare qualcosa come (int)(x < 0 ? x - 0.5 : x + 0.5)).

14.7: Come mai il C non ha un'operatore di elevamento a potenza?

Riferimenti: ANSI Sez. 4.5.5.1; ISO Sez. 7.5.5.1; H&S Sez. 17.6.

14.8: Sembra che nel mio <math.h> manchi la #define M_PI.

Riferimenti: PCS Sez. 13.

14.9: Come faccio a verificare se una variabile contiene IEEE NaN o altri valori speciali?