Specificatori di Formato per l'Output in Linguaggio C

La libreria standard del linguaggio C mette a disposizione tutta una serie di funzioni per l'output formattato che appartengono alla famiglia delle funzioni printf. Queste funzioni sono: printf, fprintf, sprintf, snprintf e vprintf.

Nelle lezioni precedenti abbiamo visto come utilizzare la funzione printf per stampare valori di vari tipi di dato, come interi, numeri in virgola mobile e stringhe di caratteri. Così come abbiamo studiato anche fprintf per scrivere su file e sprintf per scrivere su stringhe.

Tutte queste funzioni hanno un comportamento simile e condividono lo stesso meccanismo per specificare il formato di output dei dati. Questo meccanismo si basa sull'utilizzo di specificatori di formato all'interno della stringa di formato passata come primo argomento alle funzioni di output formattato.

Finora, man mano che abbiamo incontrato nuovi tipi di dato, abbiamo visto i relativi specificatori di formato. In questa lezione, invece, li studieremo in modo sistematico e completo.

Struttura di uno specificatore di formato

Una qualunque delle funzioni di output formattato della famiglia printf accetta come primo argomento una stringa di formato.

Quando tali funzioni processano la stringa, esse sostanzialmente producono in output i caratteri della stringa stessa, uno dopo l'altro. I caratteri normali vengono stampati così come sono, mentre le sequenze di escape vengono interpretate e sostituite con il carattere corrispondente (ad esempio, \n viene sostituito con un carattere di nuova linea).

Viceversa, quando la funzione incontra uno specificatore di formato, essa preleva il valore corrispondente dall'elenco degli argomenti passati alla funzione e lo converte in una rappresentazione testuale secondo le regole definite dallo specificatore di formato stesso.

Uno specificatore di formato ha la seguente struttura generale:

Come si può vedere, uno specificatore di formato inizia sempre con il carattere % ed è composto da diverse parti opzionali e da una parte obbligatoria. Studiamole in dettaglio.

Flag dello specificatore di formato

I flag sono caratteri opzionali che modificano l'aspetto dell'output. Uno specificatore di formato può contenere zero o più flag, che devono essere posizionati immediatamente dopo il carattere %.

I flag sono i seguenti:

Larghezza minima del campo

La larghezza minima del campo è un numero intero opzionale che specifica il numero minimo di caratteri da utilizzare per rappresentare il valore in output.

Il suo comportamento è il seguente:

1. Se il numero di caratteri necessari per rappresentare il valore è inferiore alla larghezza minima specificata, lo spazio rimanente viene riempito con spazi (o zeri, se è presente il flag 0).
2. Se il numero di caratteri necessari per rappresentare il valore è maggiore o uguale alla larghezza minima specificata, il valore viene stampato normalmente senza alcun riempimento.

Per specificare la larghezza minima del campo, si inserisce un numero intero positivo immediatamente dopo i flag (se presenti) nello specificatore di formato.

Si può anche utilizzare un asterisco (*) al posto di un numero intero per indicare che la larghezza minima del campo sarà specificata come argomento aggiuntivo alla funzione di output formattato. In questo caso, l'argomento corrispondente deve essere di tipo int e deve precedere il valore da stampare nell'elenco degli argomenti. Ad esempio:

printf("%*d", 5, 42);

In questo esempio, la larghezza minima del campo è specificata come 5, quindi il numero 42 verrà stampato con tre spazi iniziali per raggiungere una larghezza totale di cinque caratteri.

Precisione

La precisione è un numero intero opzionale preceduto sempre da un punto (.).

Il suo significato varia a seconda del tipo di dato che viene stampato:

Anche in questo caso, al posto di specificare un numero intero, si può utilizzare un asterisco (*) per indicare che la precisione sarà specificata come argomento aggiuntivo alla funzione di output formattato. L'argomento corrispondente deve essere di tipo int e deve precedere il valore da stampare nell'elenco degli argomenti. Ad esempio:

printf("%.*f", 2, 3.14159);

In questo esempio, la precisione è specificata come 2, quindi il numero 3.14159 verrà stampato come 3.14, con due cifre dopo il punto decimale.

Se, invece, il numero intero che specifica la precisione è assente, viene assunto come valore predefinito 0.

Modificatori di dimensione

I modificatori di dimensione sono sequenze di caratteri opzionali che modificano la dimensione del tipo di dato che viene stampato.

In altre parole, se specifichiamo, ad esempio, un numero intero con lo specificatore %d, il compilatore si aspetta un argomento di tipo int. Tuttavia, se utilizziamo un modificatore di dimensione come l (elle minuscola), lo specificatore diventa %ld e il compilatore si aspetta un argomento di tipo long int. Analogamente, con il modificatore h (acca minuscola), lo specificatore diventa %hd e il compilatore si aspetta un argomento di tipo short int.

Nella tabella che segue sono elencati i modificatori di dimensione, le associazioni con gli specificatori di tipo e il loro significato:

Specificatore di tipo

Lo specificatore di tipo è l'ultima parte di uno specificatore di formato ed è obbligatorio.

Lo specificatore di tipo indica il tipo di dato che viene stampato e determina come il valore deve essere convertito in una rappresentazione testuale.

Nella tabella che segue sono elencati tutti gli specificatori di tipo disponibili, insieme al tipo di dato corrispondente e a una breve descrizione del loro utilizzo:

Perché non esiste uno specificatore di formato per il tipo float?

Se osserviamo bene la tabella 3 che raccoglie tutti gli specificatori di tipo supportati dal linguaggio C e osserviamo la tabella 2 che, invece, mostra i modificatori di lunghezza, possiamo notare che non esiste un modo per dire alla funzione printf di stampare un valore float. Possiamo, infatti, stampare valori double con gli specificatori f, F, e, E, g, G, a e A. Possiamo stampare anche valori long double apponendo il modificatore L davanti agli specificatori visti prima. Ma non c'è un modo per stampare valori float.

Sorge spontanea la domanda: perché non si può?

La risposta deriva da due motivi tecnici:

1. Per prima cosa, le funzioni della famiglia printf sono funzioni che accettano un numero variabile di argomenti.

   Quando si utilizzano funzioni che hanno un numero variabile di argomenti il compilatore, sebbene conosca il prototipo della funzione, non conosce e non può conoscere in anticipo il tipo degli argomenti passati. Il che ci porta al secondo motivo.

2. Non conoscendo il tipo degli argomenti passati, il compilatore effettua una promozione automatica del tipo come farebbe nel caso di funzioni di cui non conosce il prototipo.

   Abbiamo visto che nello standard C89 non è un errore invocare una funzione di cui il compilatore non conosce il prototipo o che non è stata precedentemente definita. Solo che, in questo caso, il compilatore effettua delle conversioni automatiche di tipo. Come, ad esempio, convertire qualunque valore float in double.

   A partire dallo standard C99, invocare una funzione senza che il compilatore ne conosca la definizione o il prototipo è un errore.

   Tuttavia, le funzioni con un numero variabile di argomenti sono una sorta di area grigia, in quanto il compilatore ne conosce un prototipo parziale.

   Motivo per cui, quando passiamo un float ad una funzione printf, che è una funzione con un numero variabile di argomenti, esso verrà sempre e comunque convertito in un double prima di essere passato alla funzione.

La conseguenza dei punti 1 e 2 è che non è necessario uno specificatore apposito per il tipo float.

La differenza tra gli specificatori f e F

Abbiamo visto che esistono due specificatori di tipo per stampare numeri in virgola mobile in notazione decimale: f e F.

Questi due specificatori mostrano numeri decimali usando un numero di cifre decimali che dipende dalla precisione specificata (o dal valore predefinito di 6 cifre decimali se la precisione non è specificata).

Sebbene entrambi gli specificatori producano lo stesso output per i numeri normali, la differenza tra f e F si manifesta quando si stampano valori speciali come NaN (Not a Number) e Infinity (Infinito).

La differenza nasce dal fatto che la maggior parte dei processori e delle librerie matematiche utilizzano la rappresentazione IEEE 754 per i numeri in virgola mobile. Questo standard permette alle operazioni in virgola mobile di produrre risultati speciali: infinito, infinito negativo e NaN (Not a Number, ovvero "non un numero").

Per esempio, se dividiamo un numero double positivo per zero, il risultato sarà Infinity. Se dividiamo un numero double negativo per zero, il risultato sarà -Infinity. Se eseguiamo un'operazione matematica non definita, come ad esempio dividere zero per zero, il risultato sarà NaN dal momento che il risultato di una tale operazione non è matematicamente definito.

A partire dallo standard C99, gli specificatori f e F gestiscono questi valori speciali in modo diverso:

• Lo specificatore f stampa nan per NaN, inf per Infinity e -inf per -Infinity, utilizzando lettere minuscole.
• Lo specificatore F stampa NAN per NaN, INF per Infinity e -INF per -Infinity, utilizzando lettere maiuscole.

Questa differenza può essere importante in contesti in cui la distinzione tra lettere maiuscole e minuscole è significativa, come ad esempio nei file di log o nei report scientifici.

Anche gli specificatori e, E, g e G seguono la stessa convenzione per quanto riguarda la gestione di NaN e Infinity.

Esempi di specificatori di formato

Adesso che abbiamo visto in dettaglio la struttura di uno specificatore di formato, vediamo alcuni esempi pratici di specificatori di formato completi.

Nel mostrare l'output di ciascun esempio, utilizzeremo il carattere ␣ per rappresentare uno spazio vuoto, in modo da rendere più chiaro l'effetto dei flag e della larghezza minima del campo.

Come primo esempio, consideriamo la stampa di due numeri interi, 123 e -456, utilizzando lo specificatore di formato %d applicando, però, diversi flag e larghezze minime del campo:

Passiamo ora a un esempio sempre con numeri interi, ma questa volta li mostriamo in diverse basi numeriche utilizzando gli specificatori di formato %o, %x e %X, includendo anche il flag # per mostrare i prefissi appropriati:

Per altri esempi, rimandiamo alle lezioni sui numeri interi e sui numeri in virgola mobile, dove sono mostrati numerosi esempi di specificatori di formato applicati a tali tipi di dato.

Vediamo, invece, qualche esempio di specificatori di formato applicati a stringhe di caratteri. Supponiamo di avere la stringa "Ciao" e la stringa "Automobile" e di volerle stampare con diversi specificatori di formato:

Passare Precisione e Larghezza minima del campo come Argomenti

Finora, abbiamo assunto che la precisione e la larghezza minima del campo fossero specificate direttamente all'interno dello specificatore di formato come numeri interi costanti cablati nella stringa di formato.

Tuttavia, la flessibilità delle funzioni di output formattato consente di specificare la precisione e la larghezza minima del campo come argomenti separati, utilizzando l'asterisco (*) all'interno dello specificatore di formato.

Per capire meglio questo concetto, consideriamo un esempio pratico:

printf("%6.4d", x);

In questo esempio, stiamo stampando un numero intero x con una larghezza minima del campo di 6 caratteri e una precisione di 4 cifre.

Possiamo, però, ottenere lo stesso risultato specificando la larghezza minima del campo e la precisione come argomenti separati:

printf("%*.*d", 6, 4, x);

In questo caso, il primo asterisco (*) indica che la larghezza minima del campo sarà specificata come il primo argomento aggiuntivo (in questo caso, 6), mentre il secondo asterisco indica che la precisione sarà specificata come il secondo argomento aggiuntivo (in questo caso, 4). Infine, l'argomento x è il valore da stampare.

Si noti che gli argomenti che specificano la larghezza minima del campo e la precisione devono essere di tipo int e devono precedere il valore da stampare nell'elenco degli argomenti.

Il vantaggio di questo approccio è che consente di determinare dinamicamente la larghezza minima del campo e la precisione in fase di esecuzione, rendendo il codice più flessibile e adattabile a diverse situazioni.

Inoltre, si possono usare delle macro o delle variabili per specificare la larghezza minima del campo e la precisione, rendendo il codice ancora più leggibile e manutenibile.

Ad esempio, ritornando al codice di sopra, potremmo specificare la larghezza minima del campo attraverso una macro che chiamiamo WIDTH e la precisione attraverso una variabile chiamata precision:

#define WIDTH 6
int precision = 4;

printf("%*.*d", WIDTH, precision, x);

Lo specificatore di formato %p per i puntatori

Lo specificatore di formato %p è utilizzato per stampare i puntatori in linguaggio C. Quando si utilizza questo specificatore, la funzione di output formattato converte l'indirizzo di memoria puntato dal puntatore in una rappresentazione esadecimale leggibile.

Ad esempio, supponiamo di avere un puntatore a un intero:

int x = 42;
int *ptr = &x;

Possiamo stampare l'indirizzo di memoria puntato da ptr utilizzando lo specificatore di formato %p come segue:

printf("L'indirizzo di memoria di x è: %p\n", (void *)ptr);

L'output potrebbe essere simile a questo:

L'indirizzo di memoria di x è: 0x7ffee3b8c8ac

Si noti che, per conformarsi allo standard C, è buona pratica convertire il puntatore a void * quando si utilizza lo specificatore di formato %p. Questo garantisce che il puntatore venga interpretato correttamente indipendentemente dal tipo di dato a cui punta.

Questa è una di quelle funzionalità di basso livello che rende il linguaggio C particolarmente potente e flessibile, permettendo agli sviluppatori di lavorare direttamente con gli indirizzi di memoria quando necessario.

Lo specificatore di formato %n

Uno specificatore di formato particolare è %n. A differenza degli altri specificatori di formato, %n non produce alcun output. Invece, esso consente di memorizzare il numero di caratteri stampati fino a quel punto in una variabile.

Ad esempio, consideriamo il seguente codice:

double pi = 3.141592653589793;
double raggio = 5.0;
int count;

printf("L'area del cerchio di raggio %.2f%n è: %.2f\n",
       raggio,
       &count,
       3.14159 * raggio * raggio);

printf("Numero di caratteri stampati prima di %%n: %d\n", count);

L'output di questo codice sarà simile a:

L'area del cerchio di raggio 5.00 è: 78.54
Numero di caratteri stampati prima di %n: 33

In questo esempio, lo specificatore di formato %n viene utilizzato per memorizzare il numero di caratteri stampati fino a quel punto nella variabile count. Dopo la chiamata a printf, count conterrà il valore 33, che rappresenta il numero di caratteri stampati prima di %n.

Da notare che l'argomento corrispondente a %n deve essere un puntatore a un intero (ad esempio, int *, long *, ecc.), e il tipo di intero deve essere coerente con il modificatore di dimensione utilizzato (se presente). Per questo motivo, nell'esempio sopra, abbiamo passato l'indirizzo di count utilizzando l'operatore di indirizzo (&).

Inoltre, lo specificatore di formato %n non produce alcun output, quindi non influisce sulla formattazione della stringa stampata. Il suo utilizzo riguarda principalmente il conteggio dei caratteri stampati in modo programmatico.