Namespaces
Variants

    vwprintf, vfwprintf, vswprintf, vwprintf_s, vfwprintf_s, vswprintf_s, vsnwprintf_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 de fichier
    Gestion des erreurs
    Opérations sur les fichiers
     
    Défini dans l'en-tête <wchar.h> 
    int vwprintf( const wchar_t* format, va_list vlist );
    		(1) (depuis C95)
    (jusqu'à C99)    		 
    int vwprintf( const wchar_t* restrict format, va_list vlist );
    		(depuis C99) 
    int vfwprintf( FILE* stream, const wchar_t* format, va_list vlist );
    		(2) (depuis C95)
    (jusqu'à C99)    		 
    int vfwprintf( FILE* restrict stream,
               const wchar_t* restrict format, va_list vlist );
    		(depuis C99) 
    int vswprintf( wchar_t* buffer, size_t bufsz,
               const wchar_t* format, va_list vlist );
    		(3) (depuis C95)
    (jusqu'à C99)    		 
    int vswprintf( wchar_t* restrict buffer, size_t bufsz,
               const wchar_t* restrict format, va_list vlist );
    		(depuis C99) 
    int vwprintf_s( const wchar_t* restrict format, va_list vlist);
    		(4) (depuis C11) 
    int vfwprintf_s( FILE* restrict stream,
                 const wchar_t* restrict format, va_list vlist);
    		(5) (depuis C11) 
    int vswprintf_s( wchar_t* restrict buffer, rsize_t bufsz,
                 const wchar_t* restrict format, va_list vlist);
    		(6) (depuis C11) 
    int vsnwprintf_s( wchar_t* restrict buffer, rsize_t bufsz,
                  const wchar_t* restrict format, va_list vlist);
    		(7) (depuis C11)

    Charge les données depuis les emplacements, définis par vlist, les convertit en équivalents de chaînes larges et écrit les résultats vers une variété de destinations.

    1) Écrit les résultats dans stdout.
    2) Écrit les résultats dans un flux de fichier stream.
    3) Écrit les résultats dans une chaîne large buffer. Au maximum bufsz - 1 caractères larges sont écrits suivis d'un caractère large nul. La chaîne large résultante sera terminée par un caractère large nul, sauf si bufsz est zéro.
    4-6) Identique à (1-3), sauf que les erreurs suivantes sont détectées à l'exécution et appellent la fonction gestionnaire 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
    • (pour vswprintf_s uniquement), la chaîne à stocker dans buffer (y compris le nul large final) dépasserait bufsz.
    7) Identique à (6), sauf qu'elle tronquera le résultat pour qu'il tienne dans le tableau pointé par buffer.
    Comme pour toutes les fonctions avec vérification des bornes, vwprintf_s, vfwprintf_s, vswprintf_s et vsnwprintf_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 large de sortie vers lequel écrire
    buffer - pointeur vers une chaîne large vers laquelle écrire
    bufsz - nombre maximal de caractères larges à écrire
    format - pointeur vers une chaîne large terminée par un nul spécifiant comment interpréter les données
    vlist - liste d'arguments variables contenant les données à imprimer.


    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 % d'introduction.
    • (optionnel) un ou plusieurs drapeaux qui modifient le comportement de la conversion :
    • -: le résultat de la conversion est justifié à gauche dans le champ (par défaut, il est justifié à 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é d'un moins seulement 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.
    • #: la 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 non significatifs sont utilisés pour remplir le champ au lieu des 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 de champ minimale. Le résultat est rempli avec des caractères espace (par défaut), si nécessaire, à gauche lorsqu'il est justifié à droite, ou à droite s'il est justifié à 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 le drapeau - spécifié 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 de champ minimale si celui-ci 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 zéro. 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 le littéral %. 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 en appelant 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 multi-octets 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 premier terminateur nul exclus.
    • 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 la 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 la 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 la 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 dans le 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 la implémentation alternative, le point décimal est écrit même si aucun chiffre ne le suit.
    • Pour la conversion des infinis et des non-nombres, voir les 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, la notation [-]d.ddd e±dd est utilisée.
    • Pour le style de conversion E, la notation [-]d.ddd E±dd est utilisée.
    • 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 la implémentation alternative, le point décimal est écrit même si aucun chiffre ne le suit.
    • Pour la conversion des infinis et des non-nombres, voir les 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, la notation [-] 0xh.hhh p±d est utilisée.
    • Pour le style de conversion A, la notation [-] 0Xh.hhh P±d est utilisée.
    • 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 la implémentation alternative, le point décimal est écrit même si aucun chiffre ne le suit.
    • Pour la conversion des infinis et des non-nombres, voir les 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 une précision P − 1 − X.
      • Sinon, la conversion est avec le style e ou E et une 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 la conversion des infinis et des non-nombres, voir les 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 à virgule flottante convertissent l'infini en inf ou infinity. Le choix est défini par l'implémentation.

    Un non-nombre est converti en nan ou nan(char_sequence). Le choix 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 de 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 grâce à 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 mémoire %n est une cible courante des exploits de sécurité où les chaînes de format dépendent d'une entrée utilisateur et n'est pas pris en charge par la famille de fonctions avec vérification des bornes 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 extrême, d'imprimer une chaîne modifiée par un %n antérieur dans le même appel.

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

    Valeur de retour

    1,4) Le nombre de caractères larges écrits en cas de succès ou une valeur négative en cas d'erreur.
    3) Le nombre de caractères larges écrits en cas de succès ou une valeur négative en cas d'erreur. Si la chaîne résultante est tronquée à cause de la limite bufsz, la fonction retourne le nombre total de caractères (sans compter le caractère large nul de fin) qui auraient été écrits, si la limite n'était pas imposée.
    2,5) nombre de caractères larges 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.
    6) nombre de caractères larges écrits dans buffer, sans compter le caractère large 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/sizeof(wchar_t)), ou zéro en cas de violation de contrainte d'exécution, et valeur négative en cas d'erreurs d'encodage.
    7) nombre de caractères larges ne comprenant pas le caractère nul de fin (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/sizeof(wchar_t)), qui auraient été écrits dans buffer si bufsz était ignoré, ou une valeur négative si une violation de contrainte d'exécution ou une erreur d'encodage s'est produite.

    Notes

    Toutes ces fonctions invoquent va_arg au moins une fois, la valeur de arg est indéterminée après le retour. Ces fonctions n'invoquent pas va_end, et cela doit être fait par l'appelant.

    Alors que les chaînes étroites fournissent vsnprintf, qui permet de déterminer la taille de tampon de sortie nécessaire, il n'y a pas d'équivalent pour les chaînes larges (jusqu'à vsnwprintf_s de C11), et pour déterminer la taille du tampon, le programme peut avoir besoin d'appeler vswprintf, de vérifier la valeur de retour et de réallouer un tampon plus grand, en réessayant jusqu'à réussite.

    vsnwprintf_s, contrairement à vswprintf_s, va tronquer 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 avec vérification des bornes.

    Exemple

    Exécuter ce code
    #include <locale.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <time.h>
#include <wchar.h>

void debug_wlog(const wchar_t* fmt, ...)
{
    struct timespec ts;
    timespec_get(&ts, TIME_UTC);
    char time_buf[100];
    size_t rc = strftime(time_buf, sizeof time_buf, "%D %T", gmtime(&ts.tv_sec));
    snprintf(time_buf + rc, sizeof time_buf - rc, ".%06ld UTC", ts.tv_nsec / 1000);

    va_list args;
    va_start(args, fmt);
    wchar_t buf[1024];
    int rc2 = vswprintf(buf, sizeof buf / sizeof *buf, fmt, args);
    va_end(args);

    if (rc2 > 0)
       wprintf(L"%s [debug]: %ls\n", time_buf, buf);
    else
       wprintf(L"%s [debug]: (string too long)\n", time_buf);
}

int main(void)
{
    setlocale(LC_ALL, "");
    debug_wlog(L"Logging, %d, %d, %d", 1, 2, 3);
}

    Sortie possible : 

    02/20/15 22:12:38.476575 UTC [debug]: Logging, 1, 2, 3

    Références

    • Norme C23 (ISO/IEC 9899:2024) :
    • 7.29.2.5 La fonction vfwprintf (p: TBD)
    • 7.29.2.7 La fonction vswprintf (p: TBD)
    • 7.29.2.9 La fonction vwprintf (p: TBD)
    • K.3.9.1.6 La fonction vfwprintf_s (p: TBD)
    • K.3.9.1.8 La fonction vsnwprintf_s (p: TBD)
    • K.3.9.1.9 La fonction vswprintf_s (p: TBD)
    • K.3.9.1.11 La fonction vwprintf_s (p: TBD)
    • Norme C17 (ISO/IEC 9899:2018) :
    • 7.29.2.5 La fonction vfwprintf (p: TBD)
    • 7.29.2.7 La fonction vswprintf (p: TBD)
    • 7.29.2.9 La fonction vwprintf (p: TBD)
    • K.3.9.1.6 La fonction vfwprintf_s (p: TBD)
    • K.3.9.1.8 La fonction vsnwprintf_s (p: TBD)
    • K.3.9.1.9 La fonction vswprintf_s (p: TBD)
    • K.3.9.1.11 La fonction vwprintf_s (p: TBD)
    • Norme C11 (ISO/IEC 9899:2011) :
    • 7.29.2.5 La fonction vfwprintf (p: 417-418)
    • 7.29.2.7 La fonction vswprintf (p: 419)
    • 7.29.2.9 La fonction vwprintf (p: 420)
    • K.3.9.1.6 La fonction vfwprintf_s (p: 632)
    • K.3.9.1.8 La fonction vsnwprintf_s (p: 633-634)
    • K.3.9.1.9 La fonction vswprintf_s (p: 634-635)
    • K.3.9.1.11 La fonction vwprintf_s (p: 636)
    • Norme C99 (ISO/IEC 9899:1999) :
    • 7.24.2.5 La fonction vfwprintf (p: 363)
    • 7.24.2.7 La fonction vswprintf (p: 364)
    • 7.24.2.9 La fonction vwprintf (p: 365)

    Voir aussi

    (C99)(C11)(C11)(C11)(C11)
    		 imprime une sortie formatée dans stdout, un flux de fichier ou un tampon
    en utilisant une liste d'arguments variables
    (fonction)
    (C95)(C95)(C95)(C11)(C11)(C11)(C11)
    		 imprime une sortie de caractères larges formatée dans stdout, un flux de fichier ou un tampon
    (fonction)
    Documentation C++ pour vwprintf, vfwprintf, vswprintf