_snprintf, _snprintf_l, _snwprintf, _snwprintf_l

Article
03/04/2013

Données mises en forme d'Écritures en chaîne.plus les versions sécurisées de ces fonctions sont disponibles ; consultez _snprintf_s, _snprintf_s_l, _snwprintf_s, _snwprintf_s_l.

int _snprintf(
   char *buffer,
   size_t count,
   const char *format [,
   argument] ... 
);
int _snprintf_l(
   char *buffer,
   size_t count,
   const char *format,
   locale_t locale [,
   argument] ... 
);
int _snwprintf(
   wchar_t *buffer,
   size_t count,
   const wchar_t *format [,
   argument] ... 
);
int _snwprintf_l(
   wchar_t *buffer,
   size_t count,
   const wchar_t *format,
   locale_t locale [,
   argument] ... 
);
template <size_t size>
int _snprintf(
   char (&buffer)[size],
   size_t count,
   const char *format [,
   argument] ... 
); // C++ only
template <size_t size>
int _snprintf_l(
   char (&buffer)[size],
   size_t count,
   const char *format,
   locale_t locale [,
   argument] ... 
); // C++ only
template <size_t size>
int _snwprintf(
   wchar_t (&buffer)[size],
   size_t count,
   const wchar_t *format [,
   argument] ... 
); // C++ only
template <size_t size>
int _snwprintf_l(
   wchar_t (&buffer)[size],
   size_t count,
   const wchar_t *format,
   locale_t locale [,
   argument] ... 
); // C++ only

Paramètres

buffer
emplacement de stockage pour la sortie.
count
Nombre maximal de caractères à les enregistrer.
format
Chaîne de format.
argument
arguments facultatifs.
locale
Les paramètres régionaux à utiliser.

Pour plus d'informations, consultez Spécifications de format.

Valeur de retour

Laissez len avoir une longueur de la chaîne mise en forme de données (sans caractère null de fin).len et count sont en octets pour _snprintf, caractères larges pour _snwprintf.

Si len < count, alors caractères d' len sont stockés dans buffer, une marque de fin null est ajoutée, et len est retourné.

Si len = count, alors caractères d' len sont stockés dans buffer, aucune marque de fin null n'est ajoutée, et len est retourné.

Si len > count, alors caractères d' count sont stockés dans buffer, aucune marque de fin null n'est ajoutée, et une valeur négative est retournée.

si buffer est un pointeur null et count est différent de zéro, ou format est un pointeur null, le gestionnaire de paramètre non valide est appelé, comme décrit dans Validation des paramètres.Si est autorisé à l'exécution de se poursuivre, ces fonctions retournent -1 et errno défini à EINVAL.

Pour plus d'informations sur ces éléments et d'autres codes d'erreur, consultez _doserrno, errno, _sys_errlist, et _sys_nerr.

Notes

La fonction d' _snprintf met en forme et enregistre count ou moins caractères dans buffer, puis ajoute un caractère de fin NULL si la longueur mise en forme de chaîne est strictement inférieure que des caractères d' count .Chaque argument (le cas échéant) est converti et de sortie en fonction de la spécification du format correspondante dans format.Le format est constituée de caractères ordinaires et a le même formulaire et fonction que l'argument d' format pour printf.Si copier se produit entre les chaînes qui se chevauchent, le comportement n'est pas défini.

Note de sécurité
assurez-vous qu' format n'est pas une chaîne définie par l'utilisateur.Étant donné que cette fonction ne garantit pas la fin NULL (en particulier, la valeur de retour est count), assurez -vous qu'il est suivi par le code qui ajoute le terminateur null.Pour plus d'informations, consultez Solutions contre les dépassements de mémoire tampon.

_snwprintf est une version à caractère élargi d' _snprintf; les arguments du pointeur vers _snwprintf sont des chaînes à caractères larges.La détection d'erreurs d'encodage dans _snwprintf diffère de celui du _snprintf._snwprintf, comme swprintf, sortie d'écritures à une chaîne plutôt qu'à une destination de type FILE.

Les versions de ces fonctions par le suffixe d' _l sont identiques mais elles utilisent le paramètre de paramètres régionaux passé au lieu des paramètres régionaux du thread courant.

En C++, ces fonctions ont des surcharges de modèle qui appellent plus le nouveau, sécuriser des équivalents de ces fonctions.Pour plus d'informations, consultez Surcharges sécurisées de modèle.

mappages de routines de texte générique

routine de Tchar.h	_UNICODE et _MBCS non définis	_MBCS défini	_UNICODE défini
_sntprintf	_snprintf	_snprintf	_snwprintf
_sntprintf_l	_snprintf_l	_snprintf_l	_snwprintf_l

Configuration requise

routine	en-tête requis
_snprintf, _snprintf_l	<stdio.h>
_snwprintf, _snwprintf_l	<stdio.h> ou <wchar.h>

Pour plus d'informations de compatibilité, consultez compatibilité dans l'introduction.

Exemple

// crt_snprintf.c
// compile with: /W3
#include <stdio.h>
#include <stdlib.h>

#if !defined(__cplusplus)
typedef int bool;
const bool true = 1;
const bool false = 0;
#endif

#define FAIL 0 // change to 1 and see what happens

int main(void)
{
   char buffer[200];
   const static char s[] = "computer"
#if FAIL
"computercomputercomputercomputercomputercomputercomputercomputer"
"computercomputercomputercomputercomputercomputercomputercomputer"
"computercomputercomputercomputercomputercomputercomputercomputer"
"computercomputercomputercomputercomputercomputercomputercomputer"
#endif
   ;
   const char c = 'l'; 
   const int i = 35;
#if FAIL
   const double fp = 1e300; // doesn't fit in the buffer
#else
   const double fp = 1.7320534;
#endif
   /* !subtract one to prevent "squeezing out" the terminal nul! */
   const int bufferSize = sizeof(buffer)/sizeof(buffer[0]) - 1;
   int bufferUsed = 0;
   int bufferLeft = bufferSize - bufferUsed;
   bool bSuccess = true;
   buffer[0] = 0;

   /* Format and print various data: */

   if (bufferLeft > 0)
   {
      int perElementBufferUsed = _snprintf(&buffer[bufferUsed], 
      bufferLeft, "   String: %s\n", s ); // C4996
      // Note: _snprintf is deprecated; consider _snprintf_s instead
      if (bSuccess = (perElementBufferUsed >= 0))
      {
         bufferUsed += perElementBufferUsed;
         bufferLeft -= perElementBufferUsed;
         if (bufferLeft > 0)
         {
            int perElementBufferUsed = _snprintf(&buffer[bufferUsed], 
            bufferLeft, "   Character: %c\n", c ); // C4996
            if (bSuccess = (perElementBufferUsed >= 0))
            {
               bufferUsed += perElementBufferUsed;
               bufferLeft -= perElementBufferUsed;
               if (bufferLeft > 0)
               {
                  int perElementBufferUsed = _snprintf(&buffer
                  [bufferUsed], bufferLeft, "   Integer: %d\n", i ); // C4996
                  if (bSuccess = (perElementBufferUsed >= 0))
                  {
                     bufferUsed += perElementBufferUsed;
                     bufferLeft -= perElementBufferUsed;
                     if (bufferLeft > 0)
                     {
                        int perElementBufferUsed = _snprintf(&buffer
                        [bufferUsed], bufferLeft, "   Real: %f\n", fp ); // C4996
                        if (bSuccess = (perElementBufferUsed >= 0))
                        {
                           bufferUsed += perElementBufferUsed;
                        }
                     }
                  }
               }
            }
         }
      }
   }

   if (!bSuccess)
   {
      printf("%s\n", "failure");
   }
   else
   {
      /* !store nul because _snprintf doesn't necessarily (if the string 
       * fits without the terminal nul, but not with it)!
       * bufferUsed might be as large as bufferSize, which normally is 
       * like going one element beyond a buffer, but in this case 
       * subtracted one from bufferSize, so we're ok.
       */
      buffer[bufferUsed] = 0;
      printf( "Output:\n%s\ncharacter count = %d\n", buffer, bufferUsed );
   }
   return EXIT_SUCCESS;
}