Namespaces
Variants

    wprintf, fwprintf, swprintf, wprintf_s, fwprintf_s, swprintf_s, snwprintf_s

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

    Entrées formatées
    (C99)(C99)(C99)(C11)(C11)(C11)
    (C99)(C99)(C99)(C11)(C11)(C11)  
    Entrées/sorties directes
    Sorties formatées
    Positionnement dans le fichier
    Gestion des erreurs
    Opérations sur les fichiers
     
    Définie dans l'en-tête <wchar.h> 
    int wprintf( const wchar_t* format, ... );
    		(1) (depuis C95)
    (jusqu'à C99)    		 
    int wprintf( const wchar_t* restrict format, ... );
    		(depuis C99) 
    int fwprintf( FILE* stream, const wchar_t* format, ... );
    		(2) (depuis C95)
    (jusqu'à C99)    		 
    int fwprintf( FILE* restrict stream,
              const wchar_t* restrict format, ... );
    		(depuis C99) 
    int swprintf( wchar_t* buffer, size_t bufsz,
              const wchar_t* format, ... );
    		(3) (depuis C95)
    (jusqu'à C99)    		 
    int swprintf( wchar_t* restrict buffer, size_t bufsz,
              const wchar_t* restrict format, ... );
    		(depuis C99) 
    int wprintf_s( const wchar_t* restrict format, ... );
    		(4) (depuis C11) 
    int fwprintf_s( FILE* restrict stream,
                const wchar_t* restrict format, ... );
    		(5) (depuis C11) 
    int swprintf_s( wchar_t* restrict buffer, rsize_t bufsz,
                const wchar_t* restrict format, ... );
    		(6) (depuis C11) 
    int snwprintf_s( wchar_t* restrict s, rsize_t n,
                 const wchar_t* restrict format, ... );
    		(7) (depuis C11)

    Charge les données depuis les emplacements donnés, les convertit en chaînes larges équivalentes et écrit les résultats dans diverses destinations.

    1) Écrit les résultats dans stdout.
    2) Écrit les résultats dans un flux de fichier stream.
    3) Si bufsz est supérieur à zéro, écrit les résultats dans une chaîne large buffer. Au maximum bufsz - 1 caractères larges sont écrits, suivis du caractère large nul. Si bufsz est zéro, rien n'est écrit (et buffer peut être un pointeur nul).
    4-6) Identique à (1-3), sauf que les erreurs suivantes sont détectées à l'exécution et appellent la fonction de gestion de contrainte actuellement installée :
    • le spécificateur de conversion %n est présent dans format
    • l'un des arguments correspondant à %s est un pointeur nul
    • format ou buffer est un pointeur nul
    • bufsz est zéro ou supérieur à RSIZE_MAX / sizeof(wchar_t)
    • des erreurs d'encodage se produisent dans les spécificateurs de conversion de chaîne et de caractère
    • (uniquement pour swprintf_s) le nombre de caractères larges à écrire, y compris le nul, dépasserait bufsz.
    7) Identique à (6), sauf qu'il tronquera le résultat pour qu'il tienne dans le tableau pointé par s.
    Comme toutes les fonctions vérifiées aux limites, wprintf_s, fwprintf_s, swprintf_s, et snwprintf_s ne sont garanties d'être disponibles que si __STDC_LIB_EXT1__ est défini par l'implémentation et si l'utilisateur définit __STDC_WANT_LIB_EXT1__ par 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 larges dans laquelle écrire
    bufsz - au plus bufsz - 1 caractères larges peuvent être écrits, plus le terminateur nul
    format - pointeur vers une chaîne large 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 les promotions d'arguments par défaut n'est pas du type attendu par le spécificateur de conversion correspondant, 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 larges ordinaires (sauf %), qui sont copiés inchangés dans le flux de sortie, et de spécifications de conversion. Chaque spécification de conversion a le format suivant :

    • Caractère introductif %.
    • (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 n'est précédé d'un moins que 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 d'entiers et de nombres à virgule flottante, des zéros non significatifs 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 d'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 elle est fournie. Si la valeur de l'argument est négative, cela résulte en la spécification du drapeau - et une largeur de champ positive (Remarque : il s'agit de 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 s'il est fourni. 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 :

    Spécificateur
    de conversion     		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 caractère unique.

    • L'argument est d'abord converti en wchar_t comme par un appel à btowc.
    • Si le modificateur l est utilisé, l'argument wint_t est d'abord converti en wchar_t.
    		 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 contenant une séquence de caractères multioctets commençant dans l'état de décalage initial, qui est convertie en tableau de caractères larges comme par un appel à mbrtowc avec un état de conversion initialisé à zéro.
    • Précision spécifie le nombre maximal de caractères larges à écrire. Si Précision n'est pas spécifiée, écrit tous les caractères larges jusqu'au (et sans inclure) premier terminateur nul.
    • Si le spécificateur l est utilisé, l'argument doit être un pointeur vers l'élément initial d'un tableau de wchar_t.
    		 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 minimal 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 minimal 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 minimal 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 non significatif. 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 minimal 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 minimal 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 du style [-]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 d'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 ne sont utilisés que 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 d'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 une 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 d'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, une conversion avec le style e ou f sera effectuée.
    • Pour le style de conversion G, une conversion avec le style E ou f(jusqu'à C99)F(depuis C99) sera effectuée.
    • Soit P égal à la précision si elle est 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 se fait avec le style f ou F(depuis C99) et la précision P − 1 − X.
      • Sinon, la conversion se fait 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 aucune partie fractionnaire.
    • Pour le style de conversion d'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 aucun drapeau, largeur de champ, ou 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écrivant un pointeur.

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

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

    Pas-un-nombre (NaN) est converti en nan ou nan(char_sequence). Le choix est défini par l'implémentation.

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

    Le spécificateur de conversion utilisé pour afficher char, unsigned char, signed char, short, et unsigned short attend les types promus par les promotions d'arguments par défaut, mais avant d'afficher 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 des 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, dans un cas limite, d'afficher 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 larges écrits en cas de succès, ou valeur négative si une erreur s'est produite.
    3) Nombre de caractères larges écrits (sans compter le caractère large nul terminal) en cas de succès, ou valeur négative si une erreur d'encodage s'est produite ou si le nombre de caractères à générer était égal ou supérieur à bufsz (y compris lorsque bufsz est zéro).
    4,5) Nombre de caractères larges écrits en cas de succès, ou valeur négative si une erreur s'est produite.
    6) Nombre de caractères larges (sans compter le nul terminal) qui ont été écrits dans buffer. Retourne une valeur négative en cas d'erreurs d'encodage et de dépassement. Retourne zéro pour toutes les autres erreurs.
    7) Nombre de caractères larges (sans compter le nul terminal) qui auraient été écrits dans buffer si bufsz avait été suffisamment grand, ou une valeur négative si une erreur se produit. (Cela signifie que l'écriture est réussie et complète seulement si la valeur de retour est non négative et inférieure à bufsz)

    Notes

    Alors que les chaînes étroites fournissent snprintf, qui permet de déterminer la taille du tampon de sortie nécessaire, il n'existe pas d'équivalent pour les chaînes larges (jusqu'à snwprintf_s)(depuis C11), et pour déterminer la taille du tampon, le programme peut avoir besoin d'appeler swprintf, de vérifier la valeur de retour, de réallouer un tampon plus grand, et de réessayer jusqu'à réussite.

    snwprintf_s, contrairement à swprintf_s, tronquera le résultat pour qu'il tienne dans le tableau pointé par buffer, même si la troncature est traitée comme une erreur par la plupart des fonctions vérifiées aux limites.

    Exemple

    Exécuter ce code
    #include <locale.h>
#include <wchar.h>

int main(void)
{
    char narrow_str[] = "z\u00df\u6c34\U0001f34c";
                  // or "zß水🍌"
                  // or "\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9f\x8d\x8c";
    wchar_t warr[29]; // the expected string is 28 characters plus 1 null terminator
    setlocale(LC_ALL, "en_US.utf8");
    swprintf(warr, sizeof warr / sizeof* warr,
             L"Converted from UTF-8: '%s'", narrow_str);
    wprintf(L"%ls\n", warr);
}

    Sortie : 

    Converted from UTF-8: 'zß水🍌'

    Références

    • Norme C23 (ISO/IEC 9899:2024) :
    • 7.29.2.1 La fonction fwprintf (p: TBD)
    • 7.29.2.3 La fonction swprintf (p: TBD)
    • 7.29.2.11 La fonction wprintf (p: TBD)
    • K.3.9.1.1 La fonction fwprintf_s (p: TBD)
    • K.3.9.1.4 La fonction swprintf_s (p: TBD)
    • K.3.9.1.13 La fonction wprintf_s (p: TBD)
    • Norme C17 (ISO/IEC 9899:2018) :
    • 7.29.2.1 La fonction fwprintf (p: TBD)
    • 7.29.2.3 La fonction swprintf (p: TBD)
    • 7.29.2.11 La fonction wprintf (p: TBD)
    • K.3.9.1.1 La fonction fwprintf_s (p: TBD)
    • K.3.9.1.4 La fonction swprintf_s (p: TBD)
    • K.3.9.1.13 La fonction wprintf_s (p: TBD)
    • Norme C11 (ISO/IEC 9899:2011) :
    • 7.29.2.1 La fonction fwprintf (p: 403-410)
    • 7.29.2.3 La fonction swprintf (p: 416)
    • 7.29.2.11 La fonction wprintf (p: 421)
    • K.3.9.1.1 La fonction fwprintf_s (p: 628)
    • K.3.9.1.4 La fonction swprintf_s (p: 630-631)
    • K.3.9.1.13 La fonction wprintf_s (p: 637-638)
    • Norme C99 (ISO/IEC 9899:1999) :
    • 7.24.2.1 La fonction fwprintf (p: 349-356)
    • 7.24.2.3 La fonction swprintf (p: 362)
    • 7.24.2.11 La fonction wprintf (p: 366)

    Voir aussi

    (C99)(C11)(C11)(C11)(C11)
    		 affiche la sortie formatée vers stdout, un flux de fichier ou un tampon
    (fonction)
    (C95)(C95)(C95)(C11)(C11)(C11)(C11)
    		 affiche la sortie formatée de caractères larges vers stdout, un flux de fichier
    ou un tampon en utilisant une liste d'arguments variables
    (fonction)
    (C95)
    		 écrit une chaîne de caractères larges dans un flux de fichier
    (fonction)
    Documentation C++ pour wprintf, fwprintf, swprintf