`snprintf`, `_snprintf`, `_snprintf_l`, `_snwprintf_snwprintf_l`

Formázott adatokat ír egy sztringbe. A függvények biztonságosabb verziói érhetők el; lásd _snprintf_s, _snprintf_s_l, _snwprintf_s, _snwprintf_s_l.

Szemantika

int snprintf(
   char *buffer,
   size_t count,
   const char *format [,
   argument] ...
);

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éterek

buffer
A kimenet tárolási helye.

count
Írható karakterek maximális száma. A függvények wchar_tesetében az írható karakterek maximális száma.

format
Formátumvezérlő sztring.

argument
Nem kötelező argumentumok.

locale
A kimenet formázásához használandó területi beállítás.

További információ: A specifikáció szintaxisának és printf függvényeinek formázásawprintf.

Visszaadott érték

Azoknak a karaktereknek a száma, amelyeket a pufferbe írtak volna, ha count figyelmen kívül hagyják. A darabszám nem tartalmazza a megszüntető NULL karaktert.

Legyen len a formázott adatsztring hossza, a végződést NULLnem beleértve.
Az összes függvény esetében, ha len < counta len karaktereket a rendszer tárolja buffer, a program null-terminátort fűz hozzá, és az írott karakterek számát adja vissza, a befejezést NULLnem beleértve.

Ezeknek a függvényeknek a széles karakterverziói a széles karakterek számát adja vissza, a végződést NULLnem beleértve.

Részletekért tekintse meg a viselkedés összefoglalását .

Megjegyzések

A Visual Studio 2015-ben és a Windows 10-ben snprintf az UCRT már nem azonos a _snprintf. A snprintf viselkedés most már C99 szabványnak megfelelő. A különbség az, hogy ha elfogy a puffer, null-leállítja a puffer végét, snprintf és visszaadja azoknak a karaktereknek a számát, amelyek szükségesek lettek volna, míg _snprintf a puffer nem null-leállítja a puffert, és -1 értéket ad vissza. _snprintf() Emellett egy további karaktert is tartalmaz a kimenetben, mert az nem szünteti meg nullhibaként a puffert.

snprintfés a _snprintf függvénycsalád formázza és tárolja count a karaktereket.buffer
snprintf mindig tárol egy végződő NULL karaktert, szükség esetén csonkolva a kimenetet.
Ha snprintf egy - 1 értéket >count ad vissza, a kimenet csonkolt.
A _snprintf függvénycsalád csak akkor fűz hozzá egy végződő NULL karaktert, ha a formázott sztring hossza szigorúan kisebb, mint count a karaktereké.
Mindegyik argument (ha van ilyen) konvertálva van, és a kimenet a megfelelő formátumspecifikációnak megfelelően jelenik meg a következőben format: . A formátum egyszerű karakterekből áll, és az formatprintf argumentumával megegyező formában és függvénnyel rendelkezik. Ha a másolás átfedésben lévő sztringek között történik, a viselkedés nincs meghatározva.

Viselkedés összefoglalása

A következő táblázathoz:

Legyen sizeOfBuffer a mérete buffer. Ha a függvény puffert char vesz igénybe, a méret bájtban van. Ha a függvény puffert wchar_t vesz igénybe, a méret a 16 bites szavak számát adja meg.
Legyen len a formázott adatok mérete. Ha a függvény puffert char vesz igénybe, a méret bájtban van. Ha a függvény puffert wchar_t vesz igénybe, a méret a 16 bites szavak számát adja meg.
A karakterek a char puffert char használó függvények karaktereire, a wchar_t puffert használó wchar_t függvények karaktereire vonatkoznak.
Az érvénytelen paraméterkezelőről további információt a Paraméterérvényesítés című témakörben talál.

Állapot	Magatartás	Visszaadott érték	`errno`	Érvénytelen paraméterkezelő meghívása
(No changes required, the translation remains "Siker.")	A megadott formátumsztring használatával írja be a karaktereket a pufferbe.	Az írott karakterek száma.	Nincs adat.	Nem
Kódolási hiba a formázás során	Ha a feldolgozási sztringkijelölő `sS` , `Z`vagy `NULL`a formátumspecifikáció feldolgozása leáll, a rendszer a puffer elejére kerül.	-1	`EILSEQ` (42)	Nem
Kódolási hiba a formázás során	Ha a karaktermegjelölőt `cC`vagy az érvénytelen karaktert kihagyja a program. Az írott karakterek száma nem növekszik a kihagyott karakterhez, és nem ír rá semmilyen adatot. A formátumspecifikáció feldolgozása folytatódik, miután kihagyta a kijelölőt a kódolási hibával.	Az írott karakterek száma, a befejezést `NULL`nem beleértve.	`EILSEQ` (42)	Nem
`buffer == NULL` és `count != 0`	Ha a végrehajtás az érvénytelen paraméterkezelő végrehajtása után is folytatódik, negatív értéket állít be `errno` és ad vissza.	-1	`EINVAL` (22)	Igen
`count == 0`	Azoknak a karaktereknek a száma, amelyek meg lettek volna írva, és nem tartalmazzák a végződést `NULL`. Ezzel az eredménnyel lefoglalhat elegendő pufferterületet a sztringhez és a befejezéshez, majd újra meghívhatja a függvényt `NULL`a puffer kitöltéséhez.	Nincs adat.	Nem
`count < 0`	Nem biztonságos: a rendszer aláíratlanként kezeli az értéket, ami valószínűleg egy nagy értéket hoz létre, amely felülírja a puffert követő memóriát.	Az írott karakterek száma	Nincs adat.	Nem
`count < sizeOfBuffer` és `len <= count`	Az összes adat meg van írva, és a program hozzáfűzi a befejezést `NULL` .	Az írott karakterek száma, a befejezést `NULL`nem beleértve.	Nincs adat.	Nem
`count < sizeOfBuffer` és `len > count`	Az első `count-1` karaktereket null terminátor követi.	A megírt karakterek száma megfelelt volna `count` a kimenethez tartozó karakterek számának, a null-terminátort nem beleértve.	Nincs adat.	Nem
`count >= sizeOfBuffer` és `len < sizeOfBuffer`	Az összes adat meg van írva egy végződéssel `NULL`.	Az írott karakterek száma, a befejezést `NULL`nem beleértve.	Nincs adat.	Nem
`count >= sizeOfBuffer` és `len >= sizeOfBuffer`	Nem biztonságos: Felülírja a puffert követő memóriát.	Az írott karakterek száma, a befejezést `NULL`nem beleértve.	Nincs adat.	Nem
`format == NULL`	Nincs adat megírva. Ha a végrehajtás az érvénytelen paraméterkezelő végrehajtása után is folytatódik, negatív értéket állít be `errno` és ad vissza.	-1	`EINVAL` (22)	Igen

Ezekről és más hibakódokról további információt a _doserrno, errno, _sys_errlistés _sys_nerr.

Fontos

Győződjön meg arról, hogy format ez nem felhasználó által definiált sztring. Mivel a függvények nem garantálják a _snprintf null végződést – különösen a visszatérési érték countesetében –, győződjön meg arról, hogy azokat a null terminátort hozzáadó kód követi. További információ: Puffertúllépések elkerülése.

A Windows 10 2004-es verziójától kezdve (19041-es build) a printf függvénycsalád pontosan ábrázolható lebegőpontos számokat nyomtat az IEEE 754 kerekítési szabályainak megfelelően. A Windows korábbi verzióiban az "5" végződésű lebegőpontos számok mindig felfelé kerekülnek. Az IEEE 754 szerint a legközelebbi páros számjegyre kell kerekíteniük (más néven "Banker kerekítése"). Például mindkettőt printf("%1.0f", 1.5) , és printf("%1.0f", 2.5) 2-re kell kerekítenie. Korábban az 1,5 2-et, a 2,5-öt pedig 3-ra kerekítené. Ez a változás csak a pontosan ábrázolható számokat érinti. Például a 2.35 (amely a memóriában ábrázolva közelebb van a 2.35000000000008-hoz) továbbra is 2,4-re kerekít. A függvények által végzett kerekítés mostantól a lebegőpontos kerekítési fesetroundmódot is figyelembe követi. Korábban a kerekítés mindig a viselkedést választotta FE_TONEAREST . Ez a módosítás csak a Visual Studio 2019 16.2-es és újabb verziójával készült programokat érinti. Az örökölt lebegőpontos kerekítési viselkedés használatához csatolja a legacy_stdio_float_rounding.obj.

_snwprintf _snprintfa(z) ; a mutató argumentumai _snwprintf széles karakterű sztringek. A kódolási hibák _snwprintf észlelése eltérhet az észleléstől a következőben: _snprintf. _snwprintf, csakúgy, mint swprintfa kimenetet egy sztringbe írja a típus FILEcélhelye helyett.

Ezeknek a függvényeknek az _l utótagot tartalmazó verziói azonosak, azzal a kivételrel, hogy az aktuális szál területi beállítása helyett a megadott területi paramétert használják.

A C++-ban ezek a függvények sablontúlterhelésekkel rendelkeznek, amelyek meghívják az újabb, biztonságosabb megfelelőket. További információ: A sablon túlterhelésének biztonságossá tételéről.

Általános szöveges rutinleképezések

`Tchar.h` rutin	`_UNICODE` és `_MBCS` nincs definiálva	`_MBCS` Meghatározott	`_UNICODE` Meghatározott
`_sntprintf`	`_snprintf`	`_snprintf`	`_snwprintf`
`_sntprintf_l`	`_snprintf_l`	`_snprintf_l`	`_snwprintf_l`

Követelmények

Rutin	Kötelező fejléc
\, \, \	`<stdio.h>`
`_snwprintf`, `_snwprintf_l`	`<stdio.h>` vagy `<wchar.h>`

További kompatibilitási információkért lásd: Kompatibilitás.

példa

// 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 null! */
   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 null because _snprintf doesn't necessarily (if the string
       * fits without the terminal null, 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;
}

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

character count = 69

Lásd még

Stream I/O-
sprintf, _sprintf_l, swprintf, _swprintf_l__swprintf_l
fprintf, _fprintf_l, fwprintf_fwprintf_l
printf, _printf_l, wprintf_wprintf_l
scanf, _scanf_l, wscanf_wscanf_l
sscanf, _sscanf_l, swscanf_swscanf_l
vprintf funkciók

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-11-07