printf in C: stringhe di formato, specificatori e stampa dei float

printf è la prima funzione che ogni programmatore C impara e quella di cui quasi nessuno legge mai tutto il manuale. Vale dieci minuti, perché la sua stringa di formato è un piccolo linguaggio a sé, e perché sbagliare uno specificatore non è un refuso: è comportamento indefinito.

Si trova in <stdio.h>, quindi ogni programma che la usa inizia con #include <stdio.h>.

Il modello della stringa di formato

printf percorre la stringa di formato un carattere alla volta. Tutto ciò che non è un % viene stampato esattamente come è scritto. Un % inizia una specifica di conversione, che consuma l'argomento successivo e lo stampa nella forma richiesta.

#include <stdio.h>

int main(void) {
    int    count = 5;
    double price = 2.5;
    char   grade = 'A';
    const char *name = "mele";

    printf("Testo semplice, senza argomenti.\n");
    printf("%d %s costano $%.2f (qualita %c)\n", count, name, price, grade);
    return 0;
}

Gli argomenti vengono abbinati agli specificatori rigorosamente per posizione: il primo % prende count, il secondo prende name e così via. printf non ha modo di controllare che tu abbia passato ciò che hai promesso, perché non vede i tipi, quindi la stringa di formato è un contratto che devi rispettare tu. Ecco perché conviene attivare -Wall: GCC legge la stringa di formato letterale durante la compilazione e avvisa quando un argomento non corrisponde.

Nessuno impone un a capo. printf("Hello") lascia il cursore dopo la o, ed è per questo che quasi ogni stringa di formato finisce con \n.

Gli specificatori che usi ogni giorno

Cinque coprono la maggior parte del codice:

#include <stdio.h>

int main(void) {
    int x = 42;

    printf("int       : %d\n", x);
    printf("double    : %f\n", 2.5);
    printf("stringa   : %s\n", "ciao");
    printf("carattere : %c\n", 'A');
    printf("puntatore : %p\n", (void *)&x);
    printf("percento  : 100%%\n");
    return 0;
}

In questo frammento si nascondono due regole. Un % letterale si scrive %%: un % isolato alla fine di una stringa di formato è comportamento indefinito. E %p richiede un void *, quindi fai il cast del puntatore; passare direttamente un int * è tecnicamente indefinito, anche se in pratica stampa senza problemi.

La tabella completa, con ogni specificatore, ogni modificatore di lunghezza e la colonna di scanf, si trova nella pagina sugli specificatori di formato. Questa pagina resta su quelli che usi davvero.

Larghezza, precisione e allineamento

Tra il % e la lettera puoi mettere dei flag, una larghezza e una precisione. È così che trasformi un ciclo in una tabella.

#include <stdio.h>

int main(void) {
    printf("|%5d|\n", 42);        /* larghezza 5, riempimento prima del valore */
    printf("|%-5d|\n", 42);       /* flag meno: riempimento dopo il valore     */
    printf("|%05d|\n", 42);       /* flag zero: riempie con zeri               */
    printf("|%+d|\n", 42);        /* flag piu: mostra sempre il segno          */
    printf("|%8.2f|\n", 3.14159); /* larghezza 8, 2 cifre dopo il punto        */
    printf("|%-10s|\n", "ok");    /* anche le stringhe vengono riempite        */
    printf("|%.3s|\n", "tagliami");  /* la precisione su una stringa la taglia */
    return 0;
}

La larghezza è un minimo, mai un massimo: %3d con il valore 123456 stampa tutte e sei le cifre. La precisione significa cose diverse a seconda del tipo: cifre dopo il punto decimale per %f, numero massimo di caratteri per %s, numero minimo di cifre per %d.

Entrambe si possono fornire a runtime con un *, che legge un argomento int:

#include <stdio.h>

int main(void) {
    const char *names[] = {"Ada", "Grace", "Alan"};
    double scores[] = {92.5, 105.25, 87.0};
    int width = 10;

    printf("%-*s %8s\n", width, "NOME", "PUNTEGGIO");
    for (int i = 0; i < 3; i++) {
        printf("%-*s %8.2f\n", width, names[i], scores[i]);
    }
    return 0;
}

Cambiando width si ridisegna l'intera tabella. È il modo standard per stampare colonne allineate in C, senza bisogno di funzioni di supporto per il riempimento delle stringhe.

Stampare i float in modo sensato

%f senza precisione stampa sempre sei cifre dopo il punto, che raramente è quello che si vuole:

#include <stdio.h>

int main(void) {
    double value = 1234.5;
    double tiny  = 0.000012345;
    double huge  = 123456789012.0;

    printf("%%f    : %f\n", value);
    printf("%%.2f  : %.2f\n", value);
    printf("%%.0f  : %.0f\n", value);
    printf("%%e    : %e\n", tiny);
    printf("%%g    : %g\n", tiny);
    printf("%%g    : %g\n", huge);
    printf("%%g    : %g\n", value);
    return 0;
}

Tre scelte, e una regola pratica per ciascuna:

• %.Nf per soldi, misure e tutto ciò che ha un numero naturale di decimali. %.2f è quello che ti serve per le valute.
• %e per la notazione scientifica, sempre nella forma d.dddddde±dd.
• %g quando non conosci in anticipo l'ordine di grandezza. Sceglie tra %f e %e quello più corto ed elimina gli zeri finali: il default più sensato per registrare un valore che non hai ancora visto.

Una trappola da dire chiaramente: in printf non esiste %lf. Gli argomenti float vengono promossi a double prima che printf li veda, quindi %f gestisce entrambi, e %lf ha senso solo in scanf, dove conta la dimensione della destinazione. (C99 accetta %lf in printf come sinonimo, ma l'abitudine di scriverlo porta a scrivere %f in scanf, e lì si rompe davvero.)

Interi di altre dimensioni

%d è per gli int. I tipi più grandi o senza segno richiedono un modificatore di lunghezza, e sbagliarlo è comportamento indefinito, non un errore di arrotondamento:

#include <stdio.h>
#include <stdint.h>

int main(void) {
    long           big  = 3000000000L;
    unsigned int   u    = 4000000000u;
    size_t         len  = sizeof "hello";
    uint64_t       id   = 1234567890123456789ULL;

    printf("long     : %ld\n", big);
    printf("unsigned : %u\n", u);
    printf("size_t   : %zu\n", len);
    printf("uint64_t : %llu\n", (unsigned long long)id);

    printf("hex      : %x  HEX: %X  octal: %o\n", 255, 255, 8);
    return 0;
}

%zu per size_t è quello che si sbaglia più spesso: sizeof restituisce un size_t, non un int, quindi printf("%d", sizeof x) è un bug che per caso funziona sui sistemi a 32 bit e si comporta male su quelli a 64 bit.

Il valore di ritorno

printf restituisce il numero di caratteri che ha scritto, oppure un numero negativo in caso di errore. Di solito viene ignorato e quasi sempre va bene così, ma è davvero utile quando devi sapere quanto era largo l'output:

#include <stdio.h>

int main(void) {
    int written = printf("Ciao, mondo!\n");
    printf("quella chiamata ha scritto %d caratteri\n", written);

    /* Comodo per sottolineare qualcosa di cui non conosci la larghezza: */
    const char *title = "Rapporto";
    int n = printf("%s\n", title) - 1;   /* meno l'a capo */
    for (int i = 0; i < n; i++) {
        putchar('=');
    }
    putchar('\n');
    return 0;
}

Le funzioni collegate sprintf e snprintf scrivono in un buffer invece che sullo schermo e restituiscono la lunghezza prodotta. Preferisci sempre snprintf, che riceve la dimensione del buffer e non può andare in overflow:

#include <stdio.h>

int main(void) {
    char buffer[32];
    int n = snprintf(buffer, sizeof buffer, "%s ha preso %.1f", "Ada", 92.5);

    printf("[%s] (%d caratteri richiesti)\n", buffer, n);
    return 0;
}

snprintf restituisce la lunghezza che sarebbe servita per la stringa completa, quindi un valore di ritorno uguale o superiore alla dimensione del buffer ti dice che l'output è stato troncato.

La vulnerabilità delle stringhe di formato

È l'unico problema di sicurezza di printf, ed è grave. Non passare mai come stringa di formato dati che non hai scritto tu:

/* PERICOLOSO: non farlo mai */
printf(user_input);

/* Corretto */
printf("%s", user_input);

Se user_input contiene %s, printf legge un argomento mai passato e segue qualunque spazzatura a forma di puntatore trovi, di solito andando in crash. %x ripetuto riversa sullo schermo il contenuto dello stack, che può includere password o chiavi. E %n, che scrive il conteggio dei caratteri in un argomento, storicamente ha trasformato tutto questo in corruzione arbitraria della memoria ed esecuzione di codice remoto.

La regola è assoluta e non costa nulla: la stringa di formato è sempre un letterale scritto da te. Tutto ciò che è variabile entra come argomento. L'opzione -Wformat-security di GCC segnala l'errore ed è inclusa in -Wall -Wextra.

Buffering: perché a volte l'output arriva in ritardo

printf non scrive subito sul terminale. L'output passa da un buffer, che viene svuotato quando si riempie, quando compare un a capo su un terminale o quando il programma termina normalmente. Due conseguenze:

• Un programma che va in crash può perdere output che "era già stato stampato". Se fai debug con printf e l'ultimo messaggio non compare mai, il crash è avvenuto dopo quella riga, non prima. Aggiungi fflush(stdout) oppure manda l'output di debug su stderr, che non ha buffer.
• fprintf(stderr, ...) è il modo giusto per stampare gli errori. Non ha buffer e va su uno stream separato, che gli utenti possono reindirizzare indipendentemente dall'output normale.

#include <stdio.h>

int main(void) {
    printf("l'output normale va su stdout\n");
    fprintf(stderr, "gli errori vanno su stderr\n");
    fflush(stdout);
    return 0;
}