_itoa_s, _ltoa_s, , _ultoa_s, _i64toa_s, _itow_s_ui64toa_s, _ltow_s, _ultow_s_i64tow_s,_ui64tow_s

Converte um inteiro em uma cadeia de caracteres. Essas funções são versões do , funções com aprimoramentos de segurança,_itoa_itow conforme descrito em Recursos de segurança no CRT.

Sintaxe

errno_t _itoa_s( int value, char * buffer, size_t size, int radix );
errno_t _ltoa_s( long value, char * buffer, size_t size, int radix );
errno_t _ultoa_s( unsigned long value, char * buffer, size_t size, int radix );
errno_t _i64toa_s( long long value, char *buffer,
   size_t size, int radix );
errno_t _ui64toa_s( unsigned long long value, char *buffer,
   size_t size, int radix );

errno_t _itow_s( int value, wchar_t *buffer,
   size_t size, int radix );
errno_t _ltow_s( long value, wchar_t *buffer,
   size_t size, int radix );
errno_t _ultow_s( unsigned long value, wchar_t *buffer,
   size_t size, int radix );
errno_t _i64tow_s( long long value, wchar_t *buffer,
   size_t size, int radix );
errno_t _ui64tow_s( unsigned long long value, wchar_t *buffer,
   size_t size, int radix
);

// These template functions are C++ only:
template <size_t size>
errno_t _itoa_s( int value, char (&buffer)[size], int radix );

template <size_t size>
errno_t _ltoa_s( long value, char (&buffer)[size], int radix );

template <size_t size>
errno_t _ultoa_s( unsigned long value, char (&buffer)[size], int radix );

template <size_t size>
errno_t _itow_s( int value, wchar_t (&buffer)[size], int radix );

template <size_t size>
errno_t _ltow_s( long value, wchar_t (&buffer)[size], int radix );

template <size_t size>
errno_t _ultow_s( unsigned long value, wchar_t (&buffer)[size], int radix );

Parâmetros

value
Número a converter.

buffer
Buffer de saída que contém o resultado da conversão.

size
Tamanho de buffer em caracteres ou caracteres largos.

radix
O radix ou base numérica a ser usada para converter value, que deve estar na faixa de 2-36.

Valor de retorno

Zero se for bem-sucedido; um código de erro em caso de falha. Se qualquer uma das seguintes condições se aplicar, a função invocará um manipulador de parâmetros inválido, conforme descrito em Validação de parâmetros.

Condições de erro

Problemas de segurança

Essas funções podem gerar uma violação de acesso se buffer não apontar para a memória válida e não NULLfor , ou se o comprimento do buffer não for longo o suficiente para manter a cadeia de caracteres de resultado.

Observações

Exceto para os parâmetros e o valor de retorno, as _itoa_s famílias de funções e _itow_s têm o mesmo comportamento que as versões e menos seguras _itoa_itow correspondentes.

Em C++, o uso dessas funções é simplificado por sobrecargas de modelo; As sobrecargas podem inferir o comprimento do buffer automaticamente (eliminando a necessidade de especificar um argumento de tamanho) e podem substituir automaticamente funções mais antigas e não seguras por suas contrapartes mais novas e seguras. Para obter mais informações, consulte Sobrecargas de modelo seguro.

As versões da biblioteca de depuração dessas funções primeiro preenchem o buffer com 0xFE. Para desativar esse comportamento, use _CrtSetDebugFillThreshold.

O CRT inclui macros convenientes para definir o tamanho do buffer necessário para converter o maior valor possível de cada tipo inteiro, incluindo o terminador nulo e o caractere de sinal, para várias bases comuns. Para obter informações, consulte Macros de contagem máxima de conversão.

Por padrão, o estado global dessa função tem como escopo o aplicativo. Para alterar esse comportamento, consulte Estado global na CRT.

Mapeamentos de rotina de texto genérico

Requerimentos

Essas funções são específicas da Microsoft. Para obter mais informações sobre compatibilidade, consulte Compatibilidade.

Exemplo

Este exemplo demonstra o uso de algumas das funções de conversão de inteiros. A _countof macro só funciona para determinar o tamanho do buffer quando a declaração de matriz é visível para o compilador, e não para parâmetros que deterioraram para ponteiros.

// crt_itoa_s.c
// Compile by using: cl /W4 crt_itoa_s.c
#include <stdlib.h>     // for _itoa_s functions, _countof, count macro
#include <stdio.h>      // for printf
#include <string.h>     // for strnlen

int main( void )
{
    char buffer[_MAX_U64TOSTR_BASE2_COUNT];
    int r;
    for ( r = 10; r >= 2; --r )
    {
        _itoa_s( -1, buffer, _countof(buffer), r );
        printf( "base %d: %s (%d chars)\n",
            r, buffer, strnlen(buffer, _countof(buffer)) );
    }
    printf( "\n" );
    for ( r = 10; r >= 2; --r )
    {
        _i64toa_s( -1LL, buffer, _countof(buffer), r );
        printf( "base %d: %s (%d chars)\n",
            r, buffer, strnlen(buffer, _countof(buffer)) );
    }
    printf( "\n" );
    for ( r = 10; r >= 2; --r )
    {
        _ui64toa_s( 0xffffffffffffffffULL, buffer, _countof(buffer), r );
        printf( "base %d: %s (%d chars)\n",
            r, buffer, strnlen(buffer, _countof(buffer)) );
    }
}

base 10: -1 (2 chars)
base 9: 12068657453 (11 chars)
base 8: 37777777777 (11 chars)
base 7: 211301422353 (12 chars)
base 6: 1550104015503 (13 chars)
base 5: 32244002423140 (14 chars)
base 4: 3333333333333333 (16 chars)
base 3: 102002022201221111210 (21 chars)
base 2: 11111111111111111111111111111111 (32 chars)

base 10: -1 (2 chars)
base 9: 145808576354216723756 (21 chars)
base 8: 1777777777777777777777 (22 chars)
base 7: 45012021522523134134601 (23 chars)
base 6: 3520522010102100444244423 (25 chars)
base 5: 2214220303114400424121122430 (28 chars)
base 4: 33333333333333333333333333333333 (32 chars)
base 3: 11112220022122120101211020120210210211220 (41 chars)
base 2: 1111111111111111111111111111111111111111111111111111111111111111 (64 chars)

base 10: 18446744073709551615 (20 chars)
base 9: 145808576354216723756 (21 chars)
base 8: 1777777777777777777777 (22 chars)
base 7: 45012021522523134134601 (23 chars)
base 6: 3520522010102100444244423 (25 chars)
base 5: 2214220303114400424121122430 (28 chars)
base 4: 33333333333333333333333333333333 (32 chars)
base 3: 11112220022122120101211020120210210211220 (41 chars)
base 2: 1111111111111111111111111111111111111111111111111111111111111111 (64 chars)

Ver também

Conversão de dados
_itoa, _itow funções