Les spécificateurs de format en C : la référence complète printf et scanf

Un spécificateur de format dit à printf comment transformer une valeur en texte, et à scanf comment transformer du texte en valeur. C'est la seule partie du C où le compilateur ne peut pas vous aider par défaut - les types des arguments sont invisibles pour la fonction - donc cette page est le tableau à consulter.

La forme générale d'une spécification est :

%[drapeaux][largeur][.precision][longueur]conversion

Seuls le % et la lettre de conversion sont obligatoires. %-8.2lf utilise les cinq parties.

Le tableau des conversions

#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", "texte");
    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;
}

Deux entrées méritent un avertissement. %n écrit en mémoire au lieu d'afficher, et c'est le mécanisme derrière la vulnérabilité des chaînes de format - ne laissez jamais du texte utilisateur atteindre une chaîne de format. Et %p exige un void * ; passer un int * directement est indéfini même si tous les vrais compilateurs affichent quand même l'adresse.

Les modificateurs de longueur

Le modificateur de longueur se place entre la précision et la lettre de conversion, et dit quelle est la vraie taille de l'argument.

Les conversions signées (d i) et non signées (u x o) prennent des types différents - %lu attend un unsigned long, pas un long, et se tromper là-dessus est un comportement indéfini, pas une approximation cosmétique.

Et pour les familles flottante et caractère :

Les combinaisons que vous tapez réellement :

#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("hello");
    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 est celui à mémoriser. sizeof, strlen et toutes les tailles de la bibliothèque standard renvoient un size_t, qui fait 8 octets sur un système 64 bits alors qu'int en fait 4. printf("%d", strlen(s)) est un vrai bug qui semble fonctionner sur certaines plateformes - utilisez %zu.

Les modificateurs hh et h existent surtout pour scanf, où la taille de destination compte. Dans printf, un short est promu en int avant l'appel, donc %d l'afficherait correctement de toute façon ; %hd ne fait que documenter l'intention.

Les types de largeur fixe

Pour les types de <stdint.h> comme int32_t, les spécificateurs portables sont des macros de <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 se développe en les bonnes lettres pour votre plateforme, et les littéraux de chaîne adjacents se concatènent, ce qui explique que le format soit coupé en trois morceaux. C'est laid ; l'alternative - convertir en long long et utiliser %lld - est souvent plus lisible et toujours correcte.

Les drapeaux

Les drapeaux se placent immédiatement après le % et modifient la présentation. Ils ne s'appliquent qu'à 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;
}

Les drapeaux se combinent : %-+8.2f signifie largeur minimale 8, deux décimales, toujours signé, rempli après le nombre. - l'emporte sur 0 si vous écrivez les deux.

Largeur et précision

La largeur est une taille de champ minimale - la sortie est complétée pour l'atteindre, et jamais tronquée pour y tenir. La précision (après un point) signifie autre chose pour chaque famille :

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* largeur 10, 3 decimales */
    printf("|%.5d|\n",   42);          /* minimum 5 chiffres      */
    printf("|%.3s|\n",   "abcdefg");   /* au plus 3 caracteres    */
    printf("|%.0f|\n",   2.71828);     /* aucune decimale         */
    printf("|%*d|\n",    8, 42);       /* largeur depuis un argument */
    printf("|%.*f|\n",   3, 3.14159);  /* precision depuis un argument */
    return 0;
}

Un * à la place de l'un des nombres le prend dans un argument int, lu avant la valeur elle-même. C'est ainsi qu'on construit des tableaux dont les largeurs de colonnes sont calculées à l'exécution.

Dans scanf, la largeur a un rôle différent et bien plus important : elle limite ce qu'une conversion consommera, ce qui est la seule chose qui sépare %s d'un débordement de tampon.

Là où printf et scanf diffèrent

Ils se ressemblent et divergent en quatre points. Chacun est une source de bugs bien vivante :

#include <stdio.h>

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

    printf("Entrez un nombre decimal et un mot : ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf et une largeur */
        printf("%.3f et \"%s\"\n", d, word);  /* %f et une precision */
    } else {
        printf("La saisie ne correspond pas.\n");
    }
    return 0;
}

Essayez 2.5 hello. Le format qui le lit et le format qui l'affiche utilisent des lettres différentes pour le même double, et le 15 de %15s plafonne l'entrée à 15 caractères plus le terminateur - exactement la taille de word.

L'ensemble de caractères de scanf

%[...] lit un ensemble de caractères plutôt qu'un mot délimité par des espaces. C'est la façon de lire une ligne entière avec scanf, même si fgets reste le meilleur outil :

#include <stdio.h>

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

    printf("Tapez une phrase : ");
    if (scanf("%63[^\n]", line) == 1) {     /* tout jusqu'a un saut de ligne */
        printf("Vous avez tape : %s\n", line);
    }
    return 0;
}

[^\n] signifie « tous les caractères sauf un saut de ligne ». %[0-9] ne lirait que des chiffres, %[abc] que ces trois lettres. Contrairement à %s, un scanset ne saute pas les espaces initiaux, donc un saut de ligne égaré dans le tampon lui fait ne rien correspondre du tout.

Se tromper est un comportement indéfini

printf ne peut pas voir le vrai type de votre argument. Il lit le nombre d'octets que le spécificateur implique, interprétés comme le spécificateur le dit. Une discordance n'est donc pas un pépin de mise en forme - c'est lire de la mémoire comme la mauvaise chose :

printf("%d\n", 3.5);        /* affiche du garbage : lit les bits d'un double comme un int */
printf("%s\n", 42);         /* traite 42 comme une adresse - plantage */
printf("%d\n", strlen(s));  /* size_t lu comme int - faux en 64 bits */
printf("%f\n", 3);          /* int lu comme double - garbage */

La défense coûte une option. Compilez avec -Wall et GCC vérifie chaque chaîne de format littérale par rapport à ses arguments :

gcc -Wall -Wextra program.c -o program

Il signale chacune des quatre lignes ci-dessus à la compilation. C'est l'avertissement le plus rentable du C, et il est actif par défaut dans l'éditeur ci-dessus.

Pour le côté pratique de leur usage - tableaux alignés, affichage lisible des flottants, lecture d'entrée sans le classique bug du saut de ligne - voir printf et scanf.