Partilhar via

sprintf, _sprintf_l, swprintf, _swprintf, _swprintf_l, __swprintf_l

Gravar dados formatados em uma cadeia de caracteres. Estão disponíveis versões mais seguras de algumas destas funções; ver sprintf_s, _sprintf_s_l, , _swprintf_s_lswprintf_s. As versões seguras de swprintf e _swprintf_l tomam o tamanho do buffer como 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(
   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

Parâmetros

buffer
Local de armazenamento para saída

count
Número máximo de caracteres para armazenar na versão Unicode desta 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 Sintaxe da especificação de formato.

Valor de retorno

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

sprintf Retorna o número de bytes armazenados no buffer, sem contar o caractere nulo de encerramento. swprintf Retorna o número de caracteres largos armazenados no buffer, sem contar o caractere de largura nulo de terminação.

Observações

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

Importante

Usando sprintfo , não há como limitar o número de caracteres gravados, o que significa que o uso de código sprintf é suscetível a saturações de buffer. Considere usar a função snprintfrelacionada , que especifica um número máximo de caracteres para gravar ou bufferusar _scprintf para determinar o tamanho necessário de um buffer. Além disso, certifique-se de que format não é uma cadeia de caracteres definida pelo usuário.

A partir do Windows 10 versão 2004 (build 19041), a família de funções imprime printf números de ponto flutuante exatamente representáveis de acordo com as regras IEEE 754 para arredondamento. Em versões anteriores do Windows, números de ponto flutuante exatamente representáveis terminando em '5' sempre arredondavam para cima. IEEE 754 afirma que eles devem arredondar para o dígito par mais próximo (também conhecido como "Arredondamento do Banqueiro"). Por exemplo, ambos printf("%1.0f", 1.5) e printf("%1.0f", 2.5) deve arredondar para 2. Anteriormente, 1,5 arredondava para 2 e 2,5 arredondava para 3. Esta alteração afeta apenas números exatamente representáveis. Por exemplo, 2.35 (que, quando representado na memória, está mais próximo de 2.35000000000000008) continua a arredondar para 2.4. O arredondamento feito por essas funções agora também respeita o modo de arredondamento de ponto flutuante definido pela fesetround. Anteriormente, o arredondamento sempre escolhia o FE_TONEAREST comportamento. Essa alteração afeta apenas os programas criados usando o Visual Studio 2019 versão 16.2 e posterior. Para usar o comportamento de arredondamento de ponto flutuante herdado, vincule-se a legacy_stdio_float_rounding.obj.

swprintfé uma versão de caracteres largos de ; os argumentos de ponteiro para sprintf são cadeias de swprintfcaracteres largos. A deteção de erros de codificação pode swprintf diferir de sprintf. swprintf e fwprintf se comportam de forma idêntica, exceto swprintf grava a saída em uma cadeia de caracteres em vez de em um destino do tipo FILE, e swprintf requer que o count parâmetro especifique o número máximo de caracteres a serem gravados. As versões dessas funções com o sufixo _l são idênticas, exceto que usam o parâmetro locale passado em vez da localidade thread atual.

Antes da assinatura para swprintf ser padronizada, uma versão era fornecida em uma biblioteca de tempo de execução mais antiga do Microsoft C que não usava o parâmetro de contagem de caracteres. A versão mais antiga ainda está disponível na biblioteca de tempo de execução do Microsoft C, mas foi preterida e foi renomeada _swprintf(). Para o código que foi escrito em relação à assinatura mais antiga, defina _CRT_NON_CONFORMING_SWPRINTFS, que mapeia chamadas para swprintf_swprintf. Em uma versão futura, o comportamento antigo pode ser removido, portanto, o código deve ser alterado para usar o novo comportamento conforme.

Em C++, essas funções têm sobrecargas de modelo que invocam as contrapartes mais recentes e seguras dessas funções. Para obter mais informações, consulte Sobrecargas de modelo seguro.

Mapeamentos de rotina de texto genérico

TCHAR.H rotina _UNICODE e _MBCS não definidos _MBCS definido _UNICODE definido
_stprintf sprintf sprintf _swprintf
_stprintf_l _sprintf_l _sprintf_l __swprintf_l

Requerimentos

Rotina Cabeçalho obrigatório
sprintf, _sprintf_l <stdio.h>
swprintf, _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

Ver também

de 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

  • Last updated on