`sprintf`, `_sprintf_l`, `swprintf`, `_swprintf_l`, `__swprintf_l`

Artigo
05/02/2022
5 minutos para o fim da leitura

Grave os dados formatados em uma cadeia de caracteres. Versões mais seguras de algumas dessas funções estão disponíveis; consulte sprintf_s , _sprintf_s_lswprintf_s ,, _swprintf_s_l. As versões seguras do swprintf e _swprintf_l o usam o tamanho do buffer como um parâmetro.

Sintaxe

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_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

Parâmetros

buffer
Local de armazenamento para a saída

count
Número máximo de caracteres a armazenar a versão Unicode dessa função.

format
Cadeia de caracteres de controle de formato

argument
Argumentos opcionais

locale
A localidade a ser usada.

Para obter mais informações, consulte Especificações de formato.

Valor Retornado

O número de caracteres gravados ou-1 se ocorreu um erro. Se buffer ou format for um ponteiro nulo, o manipulador de parâmetro inválido será invocado, conforme descrito em Validação de parâmetro. Se a execução puder continuar, essas funções retornarão -1 e definirão errno como EINVAL.

sprintf retorna o número de bytes armazenados em buffer, sem contar o caractere nulo de terminação. swprintf retorna o número de caracteres largos armazenados em buffer, sem contar o caractere largo nulo de terminação.

Comentários

A função sprintf formata e armazena uma série de caracteres e valores em buffer. Cada argument (se houver) é convertido e gerado de acordo com a especificação de formato correspondente em format. O formato consiste em caracteres comuns e tem o mesmo formato e função que o argumento format para printf. Um caractere nulo é acrescentado após o último caractere escrito. Se ocorrer cópia entre cadeias de caracteres que se sobrepõem, o comportamento será indefinido.

Importante

Usando sprintf, aqui não há maneira de limitar o número de caracteres gravados, o que significa que o código que usa sprintf é suscetível a estouros de buffer. Considere usar a função _snprintf Related, que especifica um número máximo de caracteres para gravar buffer ou usar _scprintf para determinar o tamanho necessário do buffer. Verifique também se format não é uma cadeia de caracteres definida pelo usuário.

a partir do Windows 10 versão 2004 (build 19041), a printf família de funções imprime exatamente números de ponto flutuante reapresentáveis de acordo com as regras IEEE 754 para o arredondamento. nas versões anteriores do Windows, exatamente os números de ponto flutuante reapresentáveis que terminam em ' 5 ' sempre arredondam. O IEEE 754 declara que eles devem ser arredondados para o dígito par mais próximo (também conhecido como "arredondamento do banco"). Por exemplo, printf("%1.0f", 1.5) e printf("%1.0f", 2.5) deve ser arredondado para 2. Anteriormente, 1,5 seria arredondado para 2 e 2,5 seria arredondado para 3. Essa alteração afeta apenas números exatamente reapresentáveis. Por exemplo, 2,35 (que, quando representado na memória, está mais próximo de 2.35000000000000008) continua a arredondar até 2,4. O arredondamento feito por essas funções agora também respeita o modo de arredondamento de ponto flutuante definido por fesetround . Anteriormente, o arredondamento sempre escolheu FE_TONEAREST o comportamento. essa alteração afeta apenas os programas criados usando Visual Studio 2019 versão 16,2 e posterior. Para usar o comportamento de arredondamento de ponto flutuante herdado, vincule com ' legacy_stdio_float_rounding. obj '.

swprintf é uma versão de caractere largo de sprintf; os argumentos de ponteiro para swprintf são cadeias de caracteres largos. A detecção de erros de codificação no swprintf pode ser diferente de sprintf . swprintf e fwprintf se comportar de forma idêntica, exceto swprintf gravar a saída em uma cadeia de caracteres em vez de um destino do tipo FILE e swprintf exigir que o parâmetro de contagem especifique o número máximo de caracteres a serem gravados. As versões dessas funções com o _l sufixo são idênticas, exceto pelo fato de que usam o parâmetro de localidade passado em vez da localidade do thread atual.

swprintf está em conformidade com o padrão ISO C, que requer o segundo parâmetro, count, do tipo size_t. Para forçar o comportamento antigo não padrão, defina _CRT_NON_CONFORMING_SWPRINTFS. Em uma versão futura, o comportamento antigo pode ser removido, então o código deve ser alterado para usar o novo comportamento compatível.

No C++, essas funções têm sobrecargas de modelo que invocam os equivalentes mais novos e seguros dessas funções. Para obter mais informações, consulte Sobrecargas de modelo seguro.

Mapeamentos da rotina de texto genérico

`TCHAR.H` rotina	`_UNICODE`&`_MBCS` Não definido	`_MBCS` definido	`_UNICODE` definido
`_stprintf`	`sprintf`	`sprintf`	`_swprintf`
`_stprintf_l`	`_sprintf_l`	`_sprintf_l`	`__swprintf_l`

Requisitos

Rotina	Cabeçalho necessário
`sprintf`, `_sprintf_l`	`<stdio.h>`
`swprintf`, `_swprintf_l`	`<stdio.h>` ou `<wchar.h>`

Para obter mais informações sobre compatibilidade, consulte Compatibilidade.

Exemplo: usar `sprintf` para formatar dados

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

Exemplo: tratamento de código de erro

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

Confira também

E/S de fluxo
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 Funções

sprintf, _sprintf_l, swprintf, _swprintf_l, __swprintf_l