Namespaces
Variants

    printf, fprintf, sprintf, snprintf, printf_s, fprintf_s, sprintf_s, snprintf_s

    De fr.cppreference.net
    < c | io
     
    C
     
    Entrée/sortie de fichier
    Types et objets
            
    Fonctions
    Accès aux fichiers
    (C11)
    (C11)  
    (C95)
    Entrée/sortie non formatée
    (C95)(C95)
    (C95)
    (C95)(C95)
    (C95)
    (C95)
    (C95)
    (C95)

    Entrée formatée
    (C99)(C99)(C99)(C11)(C11)(C11)
    (C99)(C99)(C99)(C11)(C11)(C11)  
    Entrée/sortie directe
    Sortie formatée
    Positionnement dans le fichier
    Gestion des erreurs
    Opérations sur les fichiers
     
    Défini dans l'en-tête <stdio.h> 
    int printf( const char* format, ... );
    		(1) (jusqu'à C99) 
    int printf( const char* restrict format, ... );
    		(depuis C99) 
    int fprintf( FILE* stream, const char* format, ... );
    		(2) (jusqu'à C99) 
    int fprintf( FILE* restrict stream, const char* restrict format, ... );
    		(depuis C99) 
    int sprintf( char* buffer, const char* format, ... );
    		(3) (jusqu'à C99) 
    int sprintf( char* restrict buffer, const char* restrict format, ... );
    		(depuis C99) 
    int snprintf( char* restrict buffer, size_t bufsz,
              const char* restrict format, ... );
    		(4) (depuis C99) 
    int printf_s( const char* restrict format, ... );
    		(5) (depuis C11) 
    int fprintf_s( FILE* restrict stream, const char* restrict format, ... );
    		(6) (depuis C11) 
    int sprintf_s( char* restrict buffer, rsize_t bufsz,
               const char* restrict format, ... );
    		(7) (depuis C11) 
    int snprintf_s( char* restrict buffer, rsize_t bufsz,
                const char* restrict format, ... );
    		(8) (depuis C11)

    Charge les données depuis les emplacements donnés, les convertit en équivalents de chaînes de caractères et écrit les résultats dans diverses sorties/flux :

    1) Écrit les résultats dans le flux de sortie stdout.
    2) Écrit les résultats dans le flux de sortie stream.
    3) Écrit les résultats dans une chaîne de caractères buffer. Le comportement est indéfini si la chaîne à écrire (plus le caractère nul de terminaison) dépasse la taille du tableau pointé par buffer.
    4) Écrit les résultats dans une chaîne de caractères buffer. Au maximum bufsz - 1 caractères sont écrits. La chaîne de caractères résultante sera terminée par un caractère nul, sauf si bufsz est zéro. Si bufsz est zéro, rien n'est écrit et buffer peut être un pointeur nul, mais la valeur de retour (nombre d'octets qui seraient écrits sans inclure le terminateur nul) est toujours calculée et retournée.
    5-8) Identique à (1-4), sauf que les erreurs suivantes sont détectées à l'exécution et appellent la fonction gestionnaire de contrainte installée :
    • le spécificateur de conversion %n est présent dans format
    • l'un des arguments correspondant à %s est un pointeur nul
    • stream ou format ou buffer est un pointeur nul
    • bufsz est zéro ou supérieur à RSIZE_MAX
    • des erreurs d'encodage se produisent dans les spécificateurs de conversion de chaîne et de caractère
    • (pour sprintf_s seulement), la chaîne à stocker dans buffer (y compris le nul final) dépasserait bufsz.
    Comme toutes les fonctions vérifiées aux limites, printf_s, fprintf_s, sprintf_s et snprintf_s ne sont garanties disponibles que si __STDC_LIB_EXT1__ est défini par l'implémentation et si l'utilisateur définit __STDC_WANT_LIB_EXT1__ comme la constante entière 1 avant d'inclure <stdio.h>.

    Paramètres

    stream - flux de fichier de sortie vers lequel écrire
    buffer - pointeur vers une chaîne de caractères dans laquelle écrire
    bufsz - jusqu'à bufsz - 1 caractères peuvent être écrits, plus le terminateur nul
    format - pointeur vers une chaîne d'octets terminée par un nul spécifiant comment interpréter les données
    ... - arguments spécifiant les données à imprimer. Si un argument après promotions d'arguments par défaut n'est pas du type attendu par la spécification de conversion correspondante (le type attendu est le type promu ou un type compatible du type promu), ou s'il y a moins d'arguments que requis par format, le comportement est indéfini. S'il y a plus d'arguments que requis par format, les arguments supplémentaires sont évalués et ignorés.

    La chaîne format se compose de caractères d'octet ordinaires (sauf %), qui sont copiés tels quels dans le flux de sortie, et de spécifications de conversion. Chaque spécification de conversion a le format suivant :

    • caractère % d'introduction.
    • (optionnel) un ou plusieurs drapeaux qui modifient le comportement de la conversion :
    • - : le résultat de la conversion est aligné à gauche dans le champ (par défaut, il est aligné à droite).
    • + : le signe des conversions signées est toujours préfixé au résultat de la conversion (par défaut, le résultat est précédé du signe moins uniquement lorsqu'il est négatif).
    • espace : si le résultat d'une conversion signée ne commence pas par un caractère de signe, ou est vide, un espace est préfixé au résultat. Il est ignoré si le drapeau + est présent.
    • # : une forme alternative de la conversion est effectuée. Voir le tableau ci-dessous pour les effets exacts, sinon le comportement est indéfini.
    • 0 : pour les conversions de nombres entiers et à virgule flottante, des zéros en tête sont utilisés pour remplir le champ au lieu de caractères espace. Pour les nombres entiers, il est ignoré si la précision est explicitement spécifiée. Pour les autres conversions, l'utilisation de ce drapeau entraîne un comportement indéfini. Il est ignoré si le drapeau - est présent.
    • (optionnel) valeur entière ou * qui spécifie la largeur minimale du champ. Le résultat est rempli avec des caractères espace (par défaut), si nécessaire, à gauche lorsqu'il est aligné à droite, ou à droite s'il est aligné à gauche. Dans le cas où * est utilisé, la largeur est spécifiée par un argument supplémentaire de type int, qui apparaît avant l'argument à convertir et l'argument fournissant la précision si celle-ci est fournie. Si la valeur de l'argument est négative, cela entraîne la spécification du drapeau - et une largeur de champ positive (Remarque : Ceci est la largeur minimale : La valeur n'est jamais tronquée.).
    • (optionnel) . suivi d'un nombre entier ou de *, ou ni l'un ni l'autre, qui spécifie la précision de la conversion. Dans le cas où * est utilisé, la précision est spécifiée par un argument supplémentaire de type int, qui apparaît avant l'argument à convertir, mais après l'argument fournissant la largeur minimale du champ si celle-ci est fournie. Si la valeur de cet argument est négative, elle est ignorée. Si ni un nombre ni * n'est utilisé, la précision est considérée comme nulle. Voir le tableau ci-dessous pour les effets exacts de la précision.
    • (optionnel) modificateur de longueur qui spécifie la taille de l'argument (en combinaison avec le spécificateur de format de conversion, il spécifie le type de l'argument correspondant).
    • spécificateur de format de conversion.

    Les spécificateurs de format suivants sont disponibles :

    Conversion
    Spécificateur     		Explication Type
    d'Argument Attendu
    Modificateur de Longueur→ hh h aucun l ll j z t L
    Disponible uniquement depuis C99→ Oui Oui Oui Oui Oui
    % Écrit littéralement %. La spécification de conversion complète doit être %%. N/A N/A N/A N/A N/A N/A N/A N/A N/A
    c

    Écrit un seul caractère.

    • L'argument est d'abord converti en unsigned char.
    • Si le modificateur l est utilisé, l'argument est d'abord converti en une chaîne de caractères comme par %ls avec un argument wchar_t[2].
    		 N/A N/A
    int
    wint_t
    		 N/A N/A N/A N/A N/A
    s

    Écrit une chaîne de caractères.

    • L'argument doit être un pointeur vers l'élément initial d'un tableau de caractères.
    • Précision spécifie le nombre maximum d'octets à écrire. Si Précision n'est pas spécifiée, écrit chaque octet jusqu'au premier terminateur nul non inclus.
    • Si le spécificateur l est utilisé, l'argument doit être un pointeur vers l'élément initial d'un tableau de wchar_t, qui est converti en tableau char comme par un appel à wcrtomb avec un état de conversion initialisé à zéro.
    		 N/A N/A
    char*
    wchar_t*
    		 N/A N/A N/A N/A N/A
    d
    i

    Convertit un entier signé en représentation décimale [-]dddd.

    • Précision spécifie le nombre minimum de chiffres à apparaître. La précision par défaut est 1.
    • Si la valeur convertie et la précision sont toutes deux 0, la conversion ne produit aucun caractère.
    • Pour le modificateur z, le type d'argument attendu est la version signée de size_t.
    signed char
    short
    int
    long
    long long
    intmax_t
    ※
    ptrdiff_t
    		 N/A
    b
    B (optionnel)

    (C23)

    Convertit un entier non signé en représentation binaire bbbb.

    • Précision spécifie le nombre minimum de chiffres à apparaître. La précision par défaut est 1.
    • Si la valeur convertie et la précision sont toutes deux 0, la conversion ne produit aucun caractère.
    • Dans l'implémentation alternative 0b ou 0B est préfixé aux résultats si la valeur convertie est non nulle.
    unsigned char
    unsigned short
    unsigned int
    unsigned long
    unsigned long long
    uintmax_t
    size_t
    version non signée de ptrdiff_t
    		 N/A
    o

    Convertit un entier non signé en représentation octale oooo.

    • Précision spécifie le nombre minimum de chiffres à apparaître. La précision par défaut est 1.
    • Si la valeur convertie et la précision sont toutes deux 0, la conversion ne produit aucun caractère.
    • Dans l'implémentation alternative, la précision est augmentée si nécessaire pour écrire un zéro en tête. Dans ce cas, si la valeur convertie et la précision sont toutes deux 0, un seul 0 est écrit.
    		 N/A
    x
    X

    Convertit un entier non signé en représentation hexadécimale hhhh.

    • Pour la conversion x, les lettres abcdef sont utilisées.
    • Pour la conversion X, les lettres ABCDEF sont utilisées.
    • Précision spécifie le nombre minimum de chiffres à apparaître. La précision par défaut est 1.
    • Si la valeur convertie et la précision sont toutes deux 0, la conversion ne produit aucun caractère.
    • Dans l'implémentation alternative 0x ou 0X est préfixé aux résultats si la valeur convertie est non nulle.
    		 N/A
    u

    Convertit un entier non signé en représentation décimale dddd.

    • Précision spécifie le nombre minimum de chiffres à apparaître.
    • La précision par défaut est 1.
    • Si la valeur convertie et la précision sont toutes deux 0, la conversion ne produit aucun caractère.
    		 N/A
    f
    F (C99)

    Convertit un nombre à virgule flottante en notation décimale sous la forme [-]ddd.ddd.

    • Précision spécifie le nombre exact de chiffres à apparaître après le point décimal.
    • La précision par défaut est 6.
    • Dans l'implémentation alternative, le point décimal est écrit même si aucun chiffre ne le suit.
    • Pour le style de conversion de l'infini et de « pas un nombre », voir notes.
    		 N/A N/A
    double
    double (C99)
    		 N/A N/A N/A N/A
    long double
    e
    E

    Convertit un nombre à virgule flottante en notation exponentielle décimale.

    • Pour le style de conversion e, [-]d.ddd e±dd est utilisé.
    • Pour le style de conversion E, [-]d.ddd E±dd est utilisé.
    • L'exposant contient au moins deux chiffres, plus de chiffres sont utilisés seulement si nécessaire.
    • Si la valeur est 0, l'exposant est aussi 0.
    • Précision spécifie le nombre exact de chiffres à apparaître après le point décimal.
    • La précision par défaut est 6.
    • Dans l'implémentation alternative, le point décimal est écrit même si aucun chiffre ne le suit.
    • Pour le style de conversion de l'infini et de « pas un nombre », voir notes.
    		 N/A N/A N/A N/A N/A N/A
    a
    A

    (C99)

    Convertit un nombre à virgule flottante en notation exponentielle hexadécimale.

    • Pour le style de conversion a, [-] 0xh.hhh p±d est utilisé.
    • Pour le style de conversion A, [-] 0Xh.hhh P±d est utilisé.
    • Le premier chiffre hexadécimal n'est pas 0 si l'argument est une valeur à virgule flottante normalisée.
    • Si la valeur est 0, l'exposant est aussi 0.
    • Précision spécifie le nombre exact de chiffres à apparaître après le point hexadécimal.
    • La précision par défaut est suffisante pour la représentation exacte de la valeur.
    • Dans l'implémentation alternative, le point décimal est écrit même si aucun chiffre ne le suit.
    • Pour le style de conversion de l'infini et de « pas un nombre », voir notes.
    		 N/A N/A N/A N/A N/A N/A
    g
    G

    Convertit un nombre à virgule flottante en notation décimale ou exponentielle décimale selon la valeur et la précision.

    • Pour le style de conversion g, la conversion sera effectuée avec le style e ou f.
    • Pour le style de conversion G, la conversion sera effectuée avec le style E ou f(jusqu'à C99)F(depuis C99).
    • Soit P égal à la précision si non nulle, 6 si la précision n'est pas spécifiée, ou 1 si la précision est 0. Alors, si une conversion avec le style E aurait un exposant de X :
      • Si P > X ≥ −4, la conversion est avec le style f ou F(depuis C99) et la précision P − 1 − X.
      • Sinon, la conversion est avec le style e ou E et la précision P − 1.
    • Sauf si la représentation alternative est demandée, les zéros de fin sont supprimés, et le point décimal est également supprimé s'il ne reste plus de partie fractionnaire.
    • Pour le style de conversion de l'infini et de « pas un nombre », voir notes.
    		 N/A N/A N/A N/A N/A N/A
    n

    Retourne le nombre de caractères écrits jusqu'à présent par cet appel à la fonction.

    • Le résultat est écrit dans la valeur pointée par l'argument.
    • La spécification ne peut contenir ni drapeau, ni largeur de champ, ni précision.
    • Pour le modificateur z, le type d'argument attendu est S*, où S est la version signée de size_t.
    signed char*
    short*
    int*
    long*
    long long*
    intmax_t*
    ※
     ptrdiff_t* 
    		 N/A
    p

    Écrit une séquence de caractères définie par l'implémentation définissant un pointeur.

    		N/A N/A
    void*
    		 N/A N/A N/A N/A N/A N/A
    Notes

    Les fonctions de conversion à virgule flottante convertissent l'infini en inf ou infinity. Lequel est utilisé est défini par l'implémentation.

    Pas un nombre est converti en nan ou nan(char_sequence). Lequel est utilisé est défini par l'implémentation.

    Les conversions F, E, G, A produisent INF, INFINITY, NAN à la place.

    Le spécificateur de conversion utilisé pour imprimer char, unsigned char, signed char, short et unsigned short attend les types promus des promotions d'arguments par défaut, mais avant d'imprimer, sa valeur sera convertie en char, unsigned char, signed char, short et unsigned short. Il est sûr de passer des valeurs de ces types en raison de la promotion qui a lieu lors de l'appel d'une fonction variadique.

    Les spécifications de conversion correctes pour les types de caractères à largeur fixe (int8_t, etc.) sont définies dans l'en-tête <inttypes.h> (bien que PRIdMAX, PRIuMAX, etc. soient synonymes de %jd, %ju, etc.).

    Le spécificateur de conversion d'écriture en mémoire %n est une cible courante d'exploits de sécurité où les chaînes de format dépendent de l'entrée utilisateur et n'est pas supporté par la famille de fonctions vérifiées aux limites printf_s(depuis C11).

    Il y a un point de séquence après l'action de chaque spécificateur de conversion ; cela permet de stocker plusieurs résultats %n dans la même variable ou, comme cas limite, d'imprimer une chaîne modifiée par un %n précédent dans le même appel.

    Si une spécification de conversion est invalide, le comportement est indéfini.

    Valeur de retour

    1,2) nombre de caractères transmis au flux de sortie ou valeur négative si une erreur de sortie ou une erreur d'encodage (pour les spécificateurs de conversion de chaîne et de caractère) s'est produite.
    3) nombre de caractères écrits dans buffer (sans compter le caractère nul de terminaison), ou une valeur négative si une erreur d'encodage (pour les spécificateurs de conversion de chaîne et de caractère) s'est produite.
    4) nombre de caractères (sans inclure le caractère nul de terminaison) qui auraient été écrits dans buffer si bufsz avait été ignoré, ou une valeur négative si une erreur d'encodage (pour les spécificateurs de conversion de chaîne et de caractère) s'est produite.
    5,6) nombre de caractères transmis au flux de sortie ou valeur négative si une erreur de sortie, une erreur de violation de contrainte d'exécution ou une erreur d'encodage s'est produite.
    7) nombre de caractères écrits dans buffer, sans compter le caractère nul (qui est toujours écrit tant que buffer n'est pas un pointeur nul et que bufsz n'est pas zéro et n'est pas supérieur à RSIZE_MAX), ou zéro en cas de violation de contrainte d'exécution, et valeur négative en cas d'erreur d'encodage.
    8) nombre de caractères sans inclure le caractère nul de terminaison (qui est toujours écrit tant que buffer n'est pas un pointeur nul et que bufsz n'est pas zéro et n'est pas supérieur à RSIZE_MAX), qui auraient été écrits dans buffer si bufsz avait été ignoré, ou une valeur négative si une violation de contrainte d'exécution ou une erreur d'encodage s'est produite.

    Notes

    La norme C et POSIX spécifient que le comportement de sprintf et de ses variantes est indéfini lorsqu'un argument chevauche la zone de destination. Exemple : 

    sprintf(dst, "%s and %s", dst, t); // <- broken: undefined behavior

    POSIX spécifie que errno est défini en cas d'erreur. Il spécifie également des spécifications de conversion supplémentaires, notamment la prise en charge du réordonnancement des arguments (n$ immédiatement après % indique le nème argument).

    Appeler snprintf avec bufsz nul et un pointeur nul pour buffer est utile pour déterminer la taille de tampon nécessaire pour contenir la sortie : 

    const char fmt[] = "sqrt(2) = %f";
int sz = snprintf(NULL, 0, fmt, sqrt(2));
char buf[sz + 1]; // note +1 for terminating null byte
snprintf(buf, sizeof buf, fmt, sqrt(2));

    snprintf_s, tout comme snprintf, mais contrairement à sprintf_s, tronquera la sortie pour qu'elle tienne dans bufsz - 1.

    Exemple

    Exécuter ce code
    #include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const char* s = "Hello";
    printf("Strings:\n"); // same as puts("Strings");
    printf(" padding:\n");
    printf("\t[%10s]\n", s);
    printf("\t[%-10s]\n", s);
    printf("\t[%*s]\n", 10, s);
    printf(" truncating:\n");
    printf("\t%.4s\n", s);
    printf("\t%.*s\n", 3, s);

    printf("Characters:\t%c %%\n", 'A');

    printf("Integers:\n");
    printf("\tDecimal:\t%i %d %.6i %i %.0i %+i %i\n",
                         1, 2,   3, 0,   0,  4,-4);
    printf("\tHexadecimal:\t%x %x %X %#x\n", 5, 10, 10, 6);
    printf("\tOctal:\t\t%o %#o %#o\n", 10, 10, 4);

    printf("Floating-point:\n");
    printf("\tRounding:\t%f %.0f %.32f\n", 1.5, 1.5, 1.3);
    printf("\tPadding:\t%05.2f %.2f %5.2f\n", 1.5, 1.5, 1.5);
    printf("\tScientific:\t%E %e\n", 1.5, 1.5);
    printf("\tHexadecimal:\t%a %A\n", 1.5, 1.5);
    printf("\tSpecial values:\t0/0=%g 1/0=%g\n", 0.0 / 0.0, 1.0 / 0.0);

    printf("Fixed-width types:\n");
    printf("\tLargest 32-bit value is %" PRIu32 " or %#" PRIx32 "\n",
                                     UINT32_MAX,     UINT32_MAX );
}

    Sortie possible : 

    Strings:
 padding:
        [     Hello]
        [Hello     ]
        [     Hello]
 truncating:
        Hell
        Hel
Characters:     A %
Integers:
        Decimal:        1 2 000003 0  +4 -4
        Hexadecimal:    5 a A 0x6
        Octal:          12 012 04
Floating-point:
        Rounding:       1.500000 2 1.30000000000000004440892098500626
        Padding:        01.50 1.50  1.50
        Scientific:     1.500000E+00 1.500000e+00
        Hexadecimal:    0x1.8p+0 0X1.8P+0
        Special values: 0/0=-nan 1/0=inf
Fixed-width types:
        Largest 32-bit value is 4294967295 or 0xffffffff

    Références

    • Norme C23 (ISO/IEC 9899:2024) :
    • 7.21.6.1 La fonction fprintf (p : à déterminer)
    • 7.21.6.3 La fonction printf (p : à déterminer)
    • 7.21.6.5 La fonction snprintf (p : à déterminer)
    • 7.21.6.6 La fonction sprintf (p : à déterminer)
    • K.3.5.3.1 La fonction fprintf_s (p : à déterminer)
    • K.3.5.3.3 La fonction printf_s (p : à déterminer)
    • K.3.5.3.5 La fonction snprintf_s (p : à déterminer)
    • K.3.5.3.6 La fonction sprintf_s (p : à déterminer)
    • Norme C17 (ISO/IEC 9899:2018) :
    • 7.21.6.1 La fonction fprintf (p : 225-230)
    • 7.21.6.3 La fonction printf (p : 236)
    • 7.21.6.5 La fonction snprintf (p : 237)
    • 7.21.6.6 La fonction sprintf (p : 237)
    • K.3.5.3.1 La fonction fprintf_s (p : 430)
    • K.3.5.3.3 La fonction printf_s (p : 432)
    • K.3.5.3.5 La fonction snprintf_s (p : 432-433)
    • K.3.5.3.6 La fonction sprintf_s (p : 433)
    • Norme C11 (ISO/IEC 9899:2011) :
    • 7.21.6.1 La fonction fprintf (p : 309-316)
    • 7.21.6.3 La fonction printf (p : 324)
    • 7.21.6.5 La fonction snprintf (p : 325)
    • 7.21.6.6 La fonction sprintf (p : 325-326)
    • K.3.5.3.1 La fonction fprintf_s (p : 591)
    • K.3.5.3.3 La fonction printf_s (p : 593-594)
    • K.3.5.3.5 La fonction snprintf_s (p : 594-595)
    • K.3.5.3.6 La fonction sprintf_s (p : 595-596)
    • Norme C99 (ISO/IEC 9899:1999) :
    • 7.19.6.1 La fonction fprintf (p : 274-282)
    • 7.19.6.3 La fonction printf (p : 290)
    • 7.19.6.5 La fonction snprintf (p : 290-291)
    • 7.19.6.6 La fonction sprintf (p : 291)
    • Norme C89/C90 (ISO/IEC 9899:1990) :
    • 4.9.6.1 La fonction fprintf
    • 4.9.6.3 La fonction printf
    • 4.9.6.5 La fonction sprintf

    Voir aussi

    (C95)(C95)(C95)(C11)(C11)(C11)(C11)
    		 imprime une sortie formatée de caractères larges vers stdout, un flux de fichier ou un tampon
    (fonction)
    (C99)(C11)(C11)(C11)(C11)
    		 imprime une sortie formatée vers stdout, un flux de fichier ou un tampon
    en utilisant une liste d'arguments variables
    (fonction)
    		écrit une chaîne de caractères dans un flux de fichier
    (fonction)
    (C11)(C11)(C11)
    		 lit une entrée formatée depuis stdin, un flux de fichier ou un tampon
    (fonction)
    Documentation C++ pour printf, fprintf, sprintf, snprintf