_snprintf, _snprintf_l, _snwprintf, _snwprintf_l

Articolo
03/05/2013

Writes formattata i dati in una stringa.Più versioni sicure di queste funzioni sono disponibili, vedere _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

Parametri

buffer
percorso di archiviazione per l'output.
count
Numero massimo di caratteri da archiviare.
format
stringa del Formato-controllo.
argument
argomenti facoltativi.
locale
le impostazioni locali da utilizzare.

Per ulteriori informazioni, vedere Specifiche di formato.

Valore restituito

lasciare len la lunghezza della stringa formattata di dati (a esclusione di di terminazione null).len e count essere in byte per _snprintf, caratteri di tipo " wide " per _snwprintf.

se len < count, quindi len i caratteri sono archiviati in buffer, un terminatore null viene aggiunto e len viene restituito.

se len = count, quindi len i caratteri sono archiviati in buffer, nessun carattere di terminazione null viene aggiunto e len viene restituito.

se len > count, quindi count i caratteri sono archiviati in buffer, nessun carattere di terminazione null viene aggiunto e un valore negativo viene restituito.

se buffer è un puntatore null e count è diverso da zero, o format è un puntatore null, il gestore non valido di parametro viene richiamato, come descritto in Convalida dei parametri.Se l'esecuzione è consentita per continuare, queste funzioni restituiscono -1 e impostate errno in EINVAL.

Per informazioni su questi e altri codici di errore, vedere _doserrno, errno, _sys_errlist e _sys_nerr.

Note

_snprintf formatta e archivi di funzione count o meno caratteri in buffere viene aggiunto un carattere di terminazione null se la lunghezza della stringa formattata è rigorosamente minore di count caratteri.ciascuno argument (se presenti) viene convertito e restituito in base alla specifica di formato corrispondente in format.Il formato è costituita da caratteri normali e ha lo stesso form e di funzione format argomento per printf.Se copiare si verifica tra stringhe che si sovrappongono, il comportamento sarà indefinito.

Nota sulla sicurezza
Assicurarsi che format non è una stringa definita dall'utente.Poiché questa funzione non garantisce la terminazione NULL (in particolare, quando il valore restituito è count), verificare che sia seguito dal codice che aggiunge il carattere di terminazione null.Per ulteriori informazioni, vedere Evitare i sovraccarichi del buffer.

_snwprintf è una versione a caratteri estesi di _snprintf; gli argomenti del puntatore su _snwprintf sono le stringhe di caratteri estesi.Rilevamento degli errori di codifica in _snwprintf potrebbe non corrispondere a quello di _snprintf._snwprintf, ad esempio swprintf, scrivere l'output in una stringa anziché una destinazione di tipo FILE.

le versioni di queste funzioni con _l il suffisso è identico con la differenza che utilizzano il parametro delle impostazioni locali passato alle impostazioni locali del thread corrente.

In C++, queste funzioni presentano overload del modello da richiamare le più recenti, controparti sicure di queste funzioni.Per ulteriori informazioni, vedere Assicurarsi che gli overload del modello.

Mapping di routine a testo generico

routine di Tchar.h	_UNICODE e _MBCS non definiti	_MBCS definito	_UNICODE definito
_sntprintf	_snprintf	_snprintf	_snwprintf
_sntprintf_l	_snprintf_l	_snprintf_l	_snwprintf_l

Requisiti

routine	Intestazione di associazione
_snprintf, _snprintf_l	<stdio.h>
_snwprintf, _snwprintf_l	<stdio.h> o <wchar.h>

Per ulteriori informazioni sulla compatibilità, vedere compatibilità nell'introduzione.

Esempio

// 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;
}