Specificatori di formato in C: guida completa a printf e scanf

Uno specificatore di formato dice a printf come trasformare un valore in testo, e a scanf come trasformare del testo in un valore. È l'unica parte del C in cui il compilatore di default non può aiutarti, perché i tipi degli argomenti sono invisibili alla funzione, quindi questa pagina è la tabella da tenere sottomano.

La forma generale di una specifica è:

%[flag][larghezza][.precisione][lunghezza]conversione

Sono obbligatori solo il % e la lettera di conversione. %-8.2lf usa tutte e cinque le parti.

La tabella delle conversioni

#include <stdio.h>

int main(void) {
    int x = 255;

    printf("%%d  : %d\n", x);
    printf("%%u  : %u\n", x);
    printf("%%x  : %x\n", x);
    printf("%%X  : %X\n", x);
    printf("%%o  : %o\n", x);
    printf("%%c  : %c\n", 65);
    printf("%%s  : %s\n", "testo");
    printf("%%f  : %f\n", 3.5);
    printf("%%e  : %e\n", 3.5);
    printf("%%g  : %g\n", 3.5);
    printf("%%p  : %p\n", (void *)&x);
    return 0;
}

Due voci meritano un avvertimento. %n scrive in memoria invece di stampare, ed è il meccanismo dietro la vulnerabilità delle stringhe di formato: non lasciare mai che il testo dell'utente arrivi in una stringa di formato. E %p richiede un void *; passare direttamente un int * è indefinito, anche se tutti i compilatori reali stampano comunque l'indirizzo.

Modificatori di lunghezza

Il modificatore di lunghezza sta tra la precisione e la lettera di conversione, e dice quanto è grande davvero l'argomento.

Le conversioni con segno (d i) e quelle senza segno (u x o) accettano tipi diversi: %lu vuole un unsigned long, non un long, e sbagliare qui è comportamento indefinito, non una svista estetica.

E per le famiglie in virgola mobile e dei caratteri:

Le combinazioni che scrivi davvero:

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

int main(void) {
    short              s   = -12;
    long               l   = 3000000000L;
    long long          ll  = 9000000000000000000LL;
    unsigned long      ul  = 4000000000UL;
    unsigned long long ull = 18000000000000000000ULL;
    size_t             len = strlen("ciao");
    long double        ld  = 2.5L;

    printf("short              : %hd\n", s);
    printf("long               : %ld\n", l);
    printf("long long          : %lld\n", ll);
    printf("unsigned long      : %lu\n", ul);
    printf("unsigned long long : %llu\n", ull);
    printf("size_t             : %zu\n", len);
    printf("long double        : %Lf\n", ld);
    return 0;
}

%zu è quello da imparare a memoria. sizeof, strlen e qualsiasi dimensione della libreria standard restituiscono size_t, che occupa 8 byte su un sistema a 64 bit mentre int ne occupa 4. printf("%d", strlen(s)) è un bug reale che su alcune piattaforme sembra funzionare: usa %zu.

I modificatori hh e h esistono soprattutto per scanf, dove conta la dimensione della destinazione. In printf uno short viene promosso a int prima della chiamata, quindi %d lo stamperebbe correttamente comunque; %hd documenta solo l'intenzione.

Tipi a larghezza fissa

Per i tipi di <stdint.h> come int32_t, gli specificatori portabili sono macro di <inttypes.h>:

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

int main(void) {
    int32_t  a = -2000000000;
    uint64_t b = 18000000000000000000ULL;

    printf("int32_t  : %" PRId32 "\n", a);
    printf("uint64_t : %" PRIu64 "\n", b);
    return 0;
}

PRId32 si espande nelle lettere giuste per la tua piattaforma, e i letterali stringa adiacenti vengono concatenati, ed è per questo che il formato è spezzato in tre pezzi. È brutto; l'alternativa, convertire a long long e usare %lld, di solito è più leggibile ed è sempre corretta.

Flag

I flag vanno subito dopo il % e cambiano la presentazione. Valgono solo per printf.

#include <stdio.h>

int main(void) {
    printf("|%6d|\n",   42);
    printf("|%-6d|\n",  42);
    printf("|%06d|\n",  42);
    printf("|%+d|\n",   42);
    printf("|% d|\n",   42);
    printf("|%#x|\n",  255);
    printf("|%#o|\n",   64);
    printf("|%#.0f|\n", 3.0);
    return 0;
}

I flag si possono combinare: %-+8.2f significa larghezza minima 8, due decimali, segno sempre presente, riempimento dopo il numero. Se scrivi sia - sia 0, vince -.

Larghezza e precisione

La larghezza è una dimensione minima del campo: l'output viene riempito fino a raggiungerla, e non viene mai troncato per starci dentro. La precisione (dopo un punto) significa una cosa diversa per ogni famiglia:

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* larghezza 10, 3 decimali */
    printf("|%.5d|\n",   42);          /* almeno 5 cifre        */
    printf("|%.3s|\n",   "abcdefg");   /* al massimo 3 caratteri */
    printf("|%.0f|\n",   2.71828);     /* nessun decimale       */
    printf("|%*d|\n",    8, 42);       /* larghezza presa da un argomento */
    printf("|%.*f|\n",   3, 3.14159);  /* precisione presa da un argomento */
    return 0;
}

Un * al posto di uno dei due numeri lo prende da un argomento int, letto prima del valore stesso. È così che costruisci tabelle con larghezze delle colonne calcolate a runtime.

In scanf la larghezza ha un compito diverso e molto più importante: limita quanto input consuma una conversione, ed è l'unica cosa che si frappone tra %s e un buffer overflow.

Dove printf e scanf si differenziano

Si somigliano ma non concordano in quattro punti. Ognuno di questi è una fonte concreta di bug:

#include <stdio.h>

int main(void) {
    double d;
    char   word[16];

    printf("Scrivi un numero decimale e una parola: ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf e una larghezza */
        printf("%.3f e \"%s\"\n", d, word);   /* %f e una precisione */
    } else {
        printf("L'input non corrisponde.\n");
    }
    return 0;
}

Prova con 2.5 ciao. Il formato che lo legge e quello che lo stampa usano lettere diverse per lo stesso double, e il 15 di %15s limita l'input a 15 caratteri più il terminatore, esattamente la dimensione di word.

L'insieme di caratteri di scanf

%[...] legge un insieme di caratteri invece di una parola delimitata da spazi. È il modo per leggere una riga intera con scanf, anche se fgets resta lo strumento migliore:

#include <stdio.h>

int main(void) {
    char line[64];

    printf("Scrivi una frase: ");
    if (scanf("%63[^\n]", line) == 1) {     /* tutto fino a un a capo */
        printf("Hai scritto: %s\n", line);
    }
    return 0;
}

[^\n] significa "qualsiasi carattere tranne un a capo". %[0-9] leggerebbe solo cifre, %[abc] solo quelle tre lettere. A differenza di %s, un insieme di caratteri non salta gli spazi iniziali, quindi un a capo rimasto nel buffer fa sì che non corrisponda a niente.

Sbagliare è comportamento indefinito

printf non può vedere il tipo reale del tuo argomento. Legge il numero di byte che lo specificatore implica, interpretati come dice lo specificatore. Quindi una discrepanza non è un difetto di formattazione: è leggere la memoria come se fosse un'altra cosa.

printf("%d\n", 3.5);        /* stampa spazzatura: legge i bit di un double come int */
printf("%s\n", 42);         /* tratta 42 come un indirizzo: crash */
printf("%d\n", strlen(s));  /* size_t letto come int: sbagliato a 64 bit */
printf("%f\n", 3);          /* int letto come double: spazzatura */

La difesa costa un flag. Compila con -Wall e GCC confronta ogni stringa di formato letterale con i suoi argomenti:

gcc -Wall -Wextra program.c -o program

Segnala ognuna delle quattro righe qui sopra in fase di compilazione. È l'avviso più utile di tutto il C, ed è attivo di default nell'editor qui sopra.

Per il lato pratico del loro uso, cioè tabelle allineate, decimali stampati in modo leggibile e lettura dell'input senza il classico bug dell'a capo, vedi printf e scanf.