printf en C : chaînes de format, spécificateurs et affichage des flottants

printf est la première fonction que tout programmeur C apprend et celle dont la plupart ne lisent jamais entièrement le manuel. Elle vaut dix minutes, car sa chaîne de format est un petit langage à part entière - et parce que se tromper de spécificateur n'est pas une faute de frappe, c'est un comportement indéfini.

Elle vit dans <stdio.h>, donc tout programme qui l'utilise commence par #include <stdio.h>.

Le modèle de la chaîne de format

printf parcourt la chaîne de format un caractère à la fois. Tout ce qui n'est pas un % est affiché exactement tel qu'écrit. Un % commence une spécification de conversion, qui consomme l'argument suivant et l'affiche sous la forme demandée.

#include <stdio.h>

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

    printf("Du texte simple, sans arguments.\n");
    printf("%d %s coutent %.2f EUR (note %c)\n", count, name, price, grade);
    return 0;
}

Les arguments sont appariés aux spécificateurs strictement par position : le premier % prend count, le second prend name, et ainsi de suite. printf n'a aucun moyen de vérifier que vous avez passé ce que vous promettiez - il ne peut pas voir les types - donc la chaîne de format est un contrat que vous devez tenir. C'est ce qui rend -Wall digne d'être activé : GCC lit la chaîne de format littérale à la compilation et avertit quand un argument ne correspond pas.

Rien ne force un saut de ligne. printf("Bonjour") laisse le curseur après le r, c'est pourquoi presque toute chaîne de format se termine par \n.

Les spécificateurs du quotidien

Cinq couvrent la plupart du code :

#include <stdio.h>

int main(void) {
    int x = 42;

    printf("int      : %d\n", x);
    printf("double   : %f\n", 2.5);
    printf("chaine   : %s\n", "bonjour");
    printf("char     : %c\n", 'A');
    printf("pointeur : %p\n", (void *)&x);
    printf("pourcent : 100%%\n");
    return 0;
}

Deux règles se cachent dans cet extrait. Un % littéral s'écrit %% - un % seul à la fin d'une chaîne de format est un comportement indéfini. Et %p exige un void *, alors convertissez le pointeur ; passer un int * directement est techniquement indéfini même si cela s'affiche très bien en pratique.

Le tableau complet - chaque spécificateur, chaque modificateur de longueur, la colonne scanf - est sur la page spécificateurs de format. Cette page s'en tient à ceux que vous utilisez.

Largeur, précision et alignement

Entre le % et la lettre, vous pouvez mettre des drapeaux, une largeur et une précision. C'est ainsi qu'on transforme une boucle en tableau.

#include <stdio.h>

int main(void) {
    printf("|%5d|\n", 42);        /* largeur 5, remplissage avant la valeur */
    printf("|%-5d|\n", 42);       /* drapeau moins : remplissage apres      */
    printf("|%05d|\n", 42);       /* drapeau zero : remplir avec des zeros  */
    printf("|%+d|\n", 42);        /* drapeau plus : toujours montrer le signe */
    printf("|%8.2f|\n", 3.14159); /* largeur 8, 2 chiffres apres la virgule */
    printf("|%-10s|\n", "ok");    /* les chaines se remplissent aussi       */
    printf("|%.3s|\n", "coupe-moi");  /* une precision sur une chaine la coupe */
    return 0;
}

La largeur est un minimum, jamais un maximum : %3d avec la valeur 123456 affiche les six chiffres. La précision signifie autre chose selon le type - chiffres après la virgule pour %f, caractères maximum pour %s, chiffres minimum pour %d.

Les deux peuvent être fournies à l'exécution avec un *, qui lit un argument 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, "NOM", "SCORE");
    for (int i = 0; i < 3; i++) {
        printf("%-*s %8.2f\n", width, names[i], scores[i]);
    }
    return 0;
}

Changer width remet en page tout le tableau. C'est la façon standard d'afficher des colonnes alignées en C - aucune fonction de remplissage de chaîne nécessaire.

Afficher les flottants de façon sensée

%f sans précision affiche toujours six chiffres après la virgule, ce que personne ne veut vraiment :

#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;
}

Trois choix, et une règle empirique pour chacun :

• %.Nf pour l'argent, les mesures, tout ce qui a un nombre naturel de décimales. %.2f est ce qu'il vous faut pour une monnaie.
• %e pour la notation scientifique, toujours d.dddddde±dd.
• %g quand vous ne connaissez pas l'ordre de grandeur à l'avance. Il choisit %f ou %e, le plus court des deux, et supprime les zéros terminaux - le choix par défaut le plus raisonnable pour journaliser une valeur que vous n'avez pas vue.

Un piège à énoncer clairement : il n'y a pas de %lf dans printf. Les arguments float sont promus en double avant même que printf ne les voie, donc %f gère les deux, et %lf n'a de sens que dans scanf, où la taille de la destination compte. (C99 accepte bien %lf dans printf comme synonyme, mais l'habitude de l'écrire pousse les gens à écrire %f dans scanf, ce qui casse réellement.)

Les entiers d'autres largeurs

%d est pour int. Les types plus grands ou non signés ont besoin d'un modificateur de longueur, et les mélanger est un comportement indéfini plutôt qu'une erreur d'arrondi :

#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("hexa     : %x  HEXA : %X  octal : %o\n", 255, 255, 8);
    return 0;
}

%zu pour size_t est celui que l'on rate le plus souvent - sizeof renvoie un size_t, pas un int, donc printf("%d", sizeof x) est un bug qui fonctionne par hasard sur les systèmes 32 bits et déraille sur les 64 bits.

La valeur de retour

printf renvoie le nombre de caractères écrits, ou un nombre négatif en cas d'échec. Elle est généralement ignorée, et c'est le plus souvent sans conséquence - mais elle est réellement utile quand vous avez besoin de connaître la largeur de la sortie :

#include <stdio.h>

int main(void) {
    int written = printf("Bonjour, le monde !\n");
    printf("cet appel a ecrit %d caracteres\n", written);

    /* Pratique pour souligner quelque chose dont on ignore la largeur : */
    const char *title = "Rapport";
    int n = printf("%s\n", title) - 1;   /* moins le saut de ligne */
    for (int i = 0; i < n; i++) {
        putchar('=');
    }
    putchar('\n');
    return 0;
}

Les fonctions voisines sprintf et snprintf écrivent dans un tampon plutôt qu'à l'écran, et renvoient la longueur produite. Préférez toujours snprintf, qui prend la taille du tampon et ne peut pas déborder :

#include <stdio.h>

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

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

snprintf renvoie la longueur dont la chaîne complète aurait eu besoin, donc une valeur de retour égale ou supérieure à la taille du tampon vous dit que la sortie a été tronquée.

La vulnérabilité des chaînes de format

C'est le seul problème de sécurité de printf, et il est sévère. Ne passez jamais des données que vous n'avez pas écrites comme chaîne de format :

/* DANGEREUX - ne faites jamais cela */
printf(user_input);

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

Si user_input contient %s, printf lit un argument jamais passé et suit le garbage en forme de pointeur qu'il y trouve, plantant généralement. %x répété déverse le contenu de la pile à l'écran, ce qui peut inclure des mots de passe ou des clés. Et %n, qui écrit le compte de caractères dans un argument, a historiquement transformé cela en corruption mémoire arbitraire et en exécution de code à distance.

La règle est absolue et ne coûte rien : la chaîne de format est toujours un littéral que vous avez écrit. Tout ce qui est variable entre en argument. Le -Wformat-security de GCC signale l'erreur, et il est inclus dans -Wall -Wextra.

Le tamponnage : pourquoi la sortie arrive parfois en retard

printf n'écrit pas immédiatement dans le terminal. La sortie est tamponnée - vidée quand le tampon se remplit, quand un saut de ligne apparaît sur un terminal, ou quand le programme se termine normalement. Deux conséquences :

• Un programme qui plante peut perdre de la sortie « déjà affichée ». Si vous déboguez avec printf et que le dernier message n'apparaît jamais, le plantage a eu lieu après cette ligne, pas avant. Ajoutez fflush(stdout) ou envoyez la sortie de débogage vers stderr, qui n'est pas tamponné.
• fprintf(stderr, ...) est la bonne façon d'afficher des erreurs. Ce flux n'est pas tamponné et part vers un canal distinct que les utilisateurs peuvent rediriger indépendamment de la sortie normale.

#include <stdio.h>

int main(void) {
    printf("la sortie normale va vers stdout\n");
    fprintf(stderr, "les erreurs vont vers stderr\n");
    fflush(stdout);
    return 0;
}