sprintf, , _sprintf_l, _swprintfswprintf, , _swprintf_l__swprintf_l

Écrire des données mises en forme dans une chaîne. Des versions plus sécurisées de certaines de ces fonctions sont disponibles ; voir , , swprintf_s_sprintf_s_l, _swprintf_s_l.sprintf_s Les versions sécurisées de swprintf la mémoire tampon et _swprintf_l prennent la taille de la mémoire tampon en tant que paramètre.

Syntaxe

int sprintf(
   char *buffer,
   const char *format [,
   argument] ...
);

int _sprintf_l(
   char *buffer,
   const char *format,
   _locale_t locale [,
   argument] ...
);

int swprintf(
   wchar_t *buffer,
   size_t count,
   const wchar_t *format [,
   argument]...
);

int _swprintf(
   wchar_t *buffer,
   const wchar_t *format [,
   argument]...
);

int _swprintf_l(
   wchar_t *buffer,
   size_t count,
   const wchar_t *format,
   _locale_t locale [,
   argument] ...
);

int __swprintf_l(
   wchar_t *buffer,
   const wchar_t *format,
   _locale_t locale [,
   argument] ...
);

template <size_t size>
int sprintf(
   char (&buffer)[size],
   const char *format [,
   argument] ...
); // C++ only

template <size_t size>
int _sprintf_l(
   char (&buffer)[size],
   const char *format,
   _locale_t locale [,
   argument] ...
); // C++ only

Paramètres

buffer
Emplacement de stockage pour la sortie

count
Nombre maximal de caractères à stocker dans la version Unicode de cette fonction.

format
Chaîne de contrôle de format

argument
Arguments facultatifs

locale
Paramètres régionaux à utiliser.

Pour plus d’informations, consultez Syntaxe de spécification de format.

Valeur retournée

Nombre de caractères écrits ou -1 si une erreur s’est produite. Si buffer ou format est un pointeur Null, le gestionnaire de paramètres non valide est appelé, comme décrit dans la validation des paramètres. Si l'exécution est autorisée à se poursuivre, ces fonctions retournent -1 et définissent errno avec la valeur EINVAL.

sprintf retourne le nombre d'octets stockés dans buffer, sans compter le caractère null de fin. swprintf retourne le nombre de caractères larges stockés dans buffer, sans compter le caractère large null de fin.

Notes

La fonction sprintf met en forme une série de caractères et de valeurs et la stocke dans buffer. Chaque argument (le cas échéant) est converti et sorti selon la spécification de format correspondante dans format. Le format se compose de caractères ordinaires et a la même forme et la même fonction que l’argument format pour printf. Un caractère null est ajouté après le dernier caractère écrit. Si une copie se produit entre des chaînes qui se chevauchent, le comportement est indéfini.

Important

En utilisant sprintf, il n'existe aucun moyen de limiter le nombre de caractères écrits, ce qui signifie que le code qui utilise sprintf s'expose à des dépassements de mémoire tampon. Envisagez d’utiliser la fonction snprintfassociée, qui spécifie un nombre maximal de caractères à écrire bufferou utilisez _scprintf pour déterminer la taille requise d’une mémoire tampon. De même, assurez-vous que format n'est pas une chaîne définie par l'utilisateur.

À compter de Windows 10 version 2004 (build 19041), la famille de fonctions printf imprime exactement les nombres à virgule flottante pouvant être représentés en suivant les règles IEEE 754 pour l’arrondi. Dans les versions précédentes de Windows, les nombres à virgule flottante pouvant être représentés exactement qui se terminent par « 5 » sont toujours arrondis à la valeur supérieure. IEEE 754 indique qu’ils doivent être arrondis au chiffre pair le plus proche (également appelé « arrondi du banquier »). Par exemple, printf("%1.0f", 1.5) et printf("%1.0f", 2.5) doivent être arrondis à 2. Avant, 1.5 aurait été arrondi à 2 et 2.5 à 3. Ce changement affecte uniquement les nombres représentables avec précision. Par exemple, 2.35 (qui, lorsqu’il est représenté en mémoire, est plus proche de 2.35000000000000008) continue d’être arrondi à la valeur supérieure 2.4. L’arrondi effectué par ces fonctions respecte également le mode d’arrondi à virgule flottante défini par fesetround. Avant, l’arrondi choisissait toujours le comportement FE_TONEAREST. Ce changement affecte uniquement les programmes générés à l’aide de Visual Studio 2019 versions 16.2 et ultérieures. Pour utiliser le comportement d’arrondi à virgule flottante hérité, liez avec 'legacy_stdio_float_rounding.obj'.

swprintf est une version à caractères larges de sprintf; les arguments de pointeur de swprintf sont des chaînes à caractères larges. La détection des erreurs d’encodage peut swprintf différer de sprintf. swprintf et fwprintf se comportent de la même façon, à l’exception swprintf des écritures de sortie dans une chaîne plutôt que dans une destination de type FILE, et swprintf nécessite que le count paramètre spécifie le nombre maximal de caractères à écrire. Les versions de ces fonctions avec le _l suffixe sont identiques, sauf qu’elles utilisent le paramètre de paramètres régionaux transmis au lieu des paramètres régionaux actuels du thread.

Avant la signature pour swprintf laquelle la signature a été normalisée, une version fournie dans une ancienne bibliothèque d’exécution Microsoft C qui n’a pas pris le paramètre de nombre de caractères. L’ancienne version est toujours disponible dans la bibliothèque runtime Microsoft C, mais elle est déconseillée et a été renommée _swprintf(). Pour le code qui a été écrit sur l’ancienne signature, définissez _CRT_NON_CONFORMING_SWPRINTFS, qui mappe les appels à swprintf _swprintf. Sachant que l'ancien comportement risque d'être retiré dans une version ultérieure, il est conseillé de modifier le code pour utiliser le nouveau comportement conforme.

En C++, ces fonctions ont des surcharges de modèle qui appellent les équivalents plus récents et sécurisés de ces fonctions. Pour plus d'informations, consultez Sécuriser les surcharges de modèle.

Mappages de routines de texte générique

Routine TCHAR.H	_UNICODE et _MBCS non définis	_MBCS défini	_UNICODE défini
_stprintf	sprintf	sprintf	_swprintf
_stprintf_l	_sprintf_l	_sprintf_l	__swprintf_l

Spécifications

Routine	En-tête requis
sprintf, _sprintf_l	<stdio.h>
swprintf, , _swprintf_swprintf_l	<stdio.h> ou <wchar.h>

Pour plus d’informations sur la compatibilité, consultez Compatibility.

Exemple : Utiliser sprintf pour mettre en forme des données

// crt_sprintf.c
// compile with: /W3
// This program uses sprintf to format various
// data and place them in the string named buffer.

#include <stdio.h>

int main( void )
{
   char  buffer[200], s[] = "computer", c = 'l';
   int   i = 35, j;
   float fp = 1.7320534f;

   // Format and print various data:
   j  = sprintf( buffer,     "   String:    %s\n", s ); // C4996
   j += sprintf( buffer + j, "   Character: %c\n", c ); // C4996
   j += sprintf( buffer + j, "   Integer:   %d\n", i ); // C4996
   j += sprintf( buffer + j, "   Real:      %f\n", fp );// C4996
   // Note: sprintf is deprecated; consider using sprintf_s instead

   printf( "Output:\n%s\ncharacter count = %d\n", buffer, j );
}

Output:
   String:    computer
   Character: l
   Integer:   35
   Real:      1.732053

character count = 79

Exemple : Gestion du code d’erreur

// crt_swprintf.c
// wide character example
// also demonstrates swprintf returning error code
#include <stdio.h>

int main( void )
{
   wchar_t buf[100];
   int len = swprintf( buf, 100, L"%s", L"Hello world" );
   printf( "wrote %d characters\n", len );
   len = swprintf( buf, 100, L"%s", L"Hello\xffff world" );
   // swprintf fails because string contains WEOF (\xffff)
   printf( "wrote %d characters\n", len );
}

wrote 11 characters
wrote -1 characters

Voir aussi

E/S de flux
fprintf, , _fprintf_lfwprintf, ,_fwprintf_l
printf, , _printf_lwprintf, ,_wprintf_l
scanf, , _scanf_lwscanf, ,_wscanf_l
sscanf, , _sscanf_lswscanf, ,_swscanf_l
vprintf, fonctions