itoa, _itoa, , ltoa, , _ltoaultoa_ultoa_i64toa_ui64toa_itow_ltow_ultow_i64tow_ui64tow

Converte um inteiro em uma cadeia de caracteres. Versões mais seguras dessas funções estão disponíveis, consulte _itoa_s, _itow_s funções.

Sintaxe

char * _itoa( int value, char *buffer, int radix );
char * _ltoa( long value, char *buffer, int radix );
char * _ultoa( unsigned long value, char *buffer, int radix );
char * _i64toa( long long value, char *buffer, int radix );
char * _ui64toa( unsigned long long value, char *buffer, int radix );

wchar_t * _itow( int value, wchar_t *buffer, int radix );
wchar_t * _ltow( long value, wchar_t *buffer, int radix );
wchar_t * _ultow( unsigned long value, wchar_t *buffer, int radix );
wchar_t * _i64tow( long long value, wchar_t *buffer, int radix );
wchar_t * _ui64tow( unsigned long long value, wchar_t *buffer, int radix );

// These POSIX versions of the functions have deprecated names:
char * itoa( int value, char *buffer, int radix );
char * ltoa( long value, char *buffer, int radix );
char * ultoa( unsigned long value, char *buffer, int radix );

// The following template functions are C++ only:
template <size_t size>
char *_itoa( int value, char (&buffer)[size], int radix );

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

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

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

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

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

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

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

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

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

Parâmetros

value
Número a converter.

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

radix
A base a ser usada para a conversão de , que deve estar na faixa de value2-36.

size
Comprimento do buffer em unidades do tipo de caractere. Este parâmetro é inferido a partir do buffer argumento em C++.

Valor de retorno

Cada uma dessas funções retorna um ponteiro para buffer. Não há retorno de erro.

Observações

As _itoafunções , _ltoa, _ultoa, _i64toa, e convertem _ui64toa os dígitos do argumento dado value em uma cadeia de caracteres terminada em nulo e armazenam o resultado (até 33 caracteres para _itoa, _ltoa, e _ultoa, e 65 para _i64toa e _ui64toa) em buffer. Se radix for igual a 10 e for negativo, o primeiro caractere value da cadeia de caracteres armazenada será o sinal de subtração (-). As _itowfunções , _ltow, _ultow, _i64tow, e são _ui64tow versões de caracteres largos de _itoa, _ltoa, _ultoa, _i64toa, e _ui64toa, respectivamente.

Devido ao seu potencial para problemas de segurança, por padrão, essas funções causam aviso de descontinuação C4996: Esta função ou variável pode não ser segura. Considere usar safe_function em vez disso. Para desativar a preterição, use _CRT_SECURE_NO_WARNINGS. Recomendamos que você altere seu código-fonte para usar o sugerido safe_function pela mensagem de aviso. As funções mais seguras não gravam mais caracteres do que o tamanho do buffer especificado. Para obter mais informações, consulte _itoa_s, _itow_s funções.

Para usar essas funções sem o aviso de descontinuação, defina a macro do _CRT_SECURE_NO_WARNINGS pré-processador antes de incluir qualquer cabeçalho CRT. Você pode defini-lo adicionando a opção do /D_CRT_SECURE_NO_WARNINGS compilador ao cl comando. Caso contrário, defina a macro em seus arquivos de origem. Se você usar cabeçalhos pré-compilados, defina a macro na parte superior do arquivo pch.h de inclusão de cabeçalho pré-compilado (stdafx.h no Visual Studio 2017 e anteriores). Para definir a macro em seu código-fonte, use uma #define diretiva antes de incluir qualquer cabeçalho CRT, como neste exemplo:

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>

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

Por padrão, o estado global dessas funções tem como escopo o aplicativo. Para alterar esse comportamento, consulte estado global noCRT .

Os nomes itoaPOSIX , ltoae ultoa existem como aliases para o _itoa, _ltoae _ultoa funções. Os nomes POSIX são preteridos porque não seguem as convenções de nome de função global específicas da implementação da ISO C. Por padrão, essas funções causam aviso de preterição C4996: O nome POSIX para este item foi preterido. Em vez disso, use o nome compatível com ISO C e C++:new_name. Recomendamos que você altere seu código-fonte para usar as versões mais seguras dessas funções, _itoa_s, _ltoa_s, ou _ultoa_s. Para obter mais informações, consulte _itoa_s, _itow_s funções.

Para portabilidade do código-fonte, você pode preferir manter os nomes POSIX em seu código. Para usar essas funções sem o aviso de descontinuação, defina as macros e _CRT_NONSTDC_NO_WARNINGS o _CRT_SECURE_NO_WARNINGS pré-processador antes de incluir quaisquer cabeçalhos CRT. Você pode defini-los adicionando as opções e /D_CRT_SECURE_NO_WARNINGS compilador /D_CRT_NONSTDC_NO_WARNINGS ao cl comando. Caso contrário, defina as macros em seus arquivos de origem. Se você usar cabeçalhos pré-compilados, defina as macros na parte superior do arquivo de inclusão de cabeçalho pré-compilado. Para definir as macros em seu código-fonte, use #define diretivas antes de incluir qualquer cabeçalho CRT, como neste exemplo:

#define _CRT_NONSTDC_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>

Macros de contagem máxima de conversão

Para ajudá-lo a criar buffers seguros para conversões, o CRT inclui algumas macros convenientes. Essas macros definem 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 garantir que o buffer de conversão seja grande o suficiente para receber qualquer conversão na base especificada pelo radix, use uma dessas macros definidas ao alocar o buffer. As macros ajudam a evitar erros de saturação de buffer ao converter tipos integrais em cadeias de caracteres. Essas macros são definidas quando você inclui stdlib.h ou wchar.h em sua fonte.

Para usar uma dessas macros em uma função de conversão de cadeia de caracteres, declare seu buffer de conversão do tipo de caractere apropriado e use o valor da macro para o tipo inteiro e a base como a dimensão do buffer. Esta tabela lista as macros apropriadas para cada função para as bases listadas:

Este exemplo usa uma macro de contagem de conversões para definir um buffer grande o suficiente para conter um unsigned long long na base 2:

#include <wchar.h>
#include <iostream>
int main()
{
    wchar_t buffer[_MAX_U64TOSTR_BASE2_COUNT];
    std::wcout << _ui64tow(0xFFFFFFFFFFFFFFFFull, buffer, 2) << std::endl;
}

Mapeamentos de rotina de texto genérico

Requerimentos

Essas funções e macros 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. Observe o _CRT_SECURE_NO_WARNINGS uso da macro para silenciar o aviso C4996.

// crt_itoa.c
// Compile by using: cl /W4 crt_itoa.c
// This program makes use of the _itoa functions
// in various examples.

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>      // for printf
#include <string.h>     // for strnlen
#include <stdlib.h>     // for _countof, _itoa fns, _MAX_COUNT macros

int main(void)
{
    char buffer[_MAX_U64TOSTR_BASE2_COUNT];
    int r;

    for (r = 10; r >= 2; --r)
    {
        _itoa(-1, buffer, r);
        printf("base %d: %s (%d chars)\n", r, buffer,
            strnlen(buffer, _countof(buffer)));
    }
    printf("\n");

    for (r = 10; r >= 2; --r)
    {
        _i64toa(-1LL, buffer, r);
        printf("base %d: %s (%d chars)\n", r, buffer,
            strnlen(buffer, _countof(buffer)));
    }
    printf("\n");

    for (r = 10; r >= 2; --r)
    {
        _ui64toa(0xffffffffffffffffULL, 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_s, _itow_s funções