Compartir a través de

itoa, _itoa, ltoa, _ltoa, ultoa, _ultoa, _i64toa, _ui64toa, _itow, _ltow, _ultow, _i64tow, _ui64tow

  • Artículo

Convierte un entero en cadena. Hay versiones más seguras de estas funciones disponibles; consulte Funciones _itoa_s, _itow_s.

Sintaxis

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 que se va a convertir.

buffer
Búfer que contiene el resultado de la conversión.

radix
Base que se va a usar para la conversión de value, que debe estar en el intervalo de 2 a 36.

size
Longitud del búfer en unidades del tipo de carácter. Este parámetro se deduce del argumento buffer en C++.

Valor devuelto

Cada una de estas funciones devuelve un puntero a buffer. No se devuelve ningún error.

Comentarios

Las funciones _itoa, _ltoa, _ultoa, _i64toa y _ui64toa convierten los dígitos del argumento value dado en una cadena de caracteres terminada en un carácter nulo y almacenan el resultado (hasta 33 caracteres en el caso de _itoa, _ltoa y _ultoa; 65 para _i64toa y _ui64toa) en buffer. Si radix es igual a 10 y value es negativo, el primer carácter de la cadena almacenada es el signo menos (-). Las funciones _itow, _ltow, _ultow, _i64tow y _ui64tow son versiones con caracteres anchos de _itoa, _ltoa, _ultoa, _i64toa y _ui64toa, respectivamente.

Importante

Estas funciones pueden escribir más allá del final de un búfer demasiado pequeño. Para evitar saturaciones de búfer, asegúrese de que buffer es lo suficientemente grande como para contener los dígitos convertidos más el carácter NULO final y un carácter de signo. El uso incorrecto de estas funciones puede provocar problemas de seguridad graves en el código.

Debido a su potencial para crear problemas de seguridad, estas funciones provocan de forma predeterminada una advertencia de elemento en desuso C4996: Esta función o variable puede no ser segura. Considere la posibilidad de usar safe_function en su lugar. Para deshabilitar el desuso, utilice _CRT_SECURE_NO_WARNINGS. Se recomienda cambiar el código fuente para usar el elemento safe_function sugerido por el mensaje de advertencia. Las funciones más seguras no escriben más caracteres que el tamaño de búfer especificado. Para obtener más información, vea Funciones _itoa_s, _itow_s.

Para usar estas funciones sin la advertencia de elemento en desuso, defina la macro del preprocesador _CRT_SECURE_NO_WARNINGS antes de incluir los encabezados de CRT. Para definirlo, agregue la /D_CRT_SECURE_NO_WARNINGS opción del compilador al cl comando . De lo contrario, defina la macro en los archivos de código fuente. Si usa encabezados precompilados, defina la macro en la parte superior del archivo de inclusión de encabezado precompilado pch.h (stdafx.h en Visual Studio 2017 y versiones anteriores). Para definir la macro en el código fuente, use una directiva #define antes de incluir cualquier encabezado CRT, como en este ejemplo:

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>

En C++, estas funciones tienen sobrecargas de plantilla que invocan a sus homólogos más seguros. Para obtener más información, consulte Sobrecargas de plantillas seguras.

De forma predeterminada, el estado global de estas funciones se limita a la aplicación. Para cambiar este comportamiento, consulte Estado global en CRT.

Los nombres POSIX itoa, ltoa y ultoa existen como alias de las funciones _itoa, _ltoa y _ultoa. Los nombres POSIX están en desuso porque no siguen las convenciones de nombre de función global específicas de la implementación de ISO C. De forma predeterminada, estas funciones provocan una advertencia de desuso C4996: el nombre POSIX de este elemento está en desuso. En su lugar, use el nombre compatible con ISO C y C++:new_name Se recomienda cambiar el código fuente para usar las versiones más seguras de estas funciones, _itoa_s, _ltoa_s o _ultoa_s. Para obtener más información, vea Funciones _itoa_s, _itow_s.

Para la portabilidad del código fuente, es posible que prefiera conservar los nombres POSIX en el código. Para usar estas funciones sin la advertencia de elemento en desuso, defina las macros del preprocesador _CRT_NONSTDC_NO_WARNINGS y _CRT_SECURE_NO_WARNINGS antes de incluir los encabezados de CRT. Puede definirlos agregando las /D_CRT_SECURE_NO_WARNINGS opciones del compilador y /D_CRT_NONSTDC_NO_WARNINGS al cl comando . De lo contrario, defina las macros en los archivos de código fuente. Si usa encabezados precompilados, defina las macros en la parte superior del archivo de inclusión del encabezado precompilado. Para definir las macros en el código fuente, use directivas #define antes de incluir cualquier encabezado CRT, como en este ejemplo:

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

Número máximo de macros de recuento de conversiones

Para ayudarle a crear búferes seguros para las conversiones, la instancia de CRT incluye algunas macros convenientes. Estas macros definen el tamaño del búfer necesario para convertir el valor posible más largo de cada tipo entero, incluido el terminador nulo y el carácter de signo, para varias bases comunes. Para asegurarse de que el búfer de conversión sea lo suficientemente grande como para recibir cualquier conversión en la base especificada por radix, use una de estas macros definidas al asignar el búfer. Las macros ayudan a evitar errores de saturación del búfer al convertir tipos enteros en cadenas. Estas macros se definen al incluir stdlib.h o wchar.h en el origen.

Para usar una de estas macros en una función de conversión de cadenas, declare el búfer de conversión del tipo de carácter adecuado y use el valor de la macro para el tipo entero y la base como dimensión del búfer. En esta tabla se enumeran las macros adecuadas para cada función para las bases enumeradas:

Functions radix Macros
_itoa, _itow 16
10
8
2		 _MAX_ITOSTR_BASE16_COUNT
_MAX_ITOSTR_BASE10_COUNT
_MAX_ITOSTR_BASE8_COUNT
_MAX_ITOSTR_BASE2_COUNT
_ltoa, _ltow 16
10
8
2		 _MAX_LTOSTR_BASE16_COUNT
_MAX_LTOSTR_BASE10_COUNT
_MAX_LTOSTR_BASE8_COUNT
_MAX_LTOSTR_BASE2_COUNT
_ultoa, _ultow 16
10
8
2		 _MAX_ULTOSTR_BASE16_COUNT
_MAX_ULTOSTR_BASE10_COUNT
_MAX_ULTOSTR_BASE8_COUNT
_MAX_ULTOSTR_BASE2_COUNT
_i64toa, _i64tow 16
10
8
2		 _MAX_I64TOSTR_BASE16_COUNT
_MAX_I64TOSTR_BASE10_COUNT
_MAX_I64TOSTR_BASE8_COUNT
_MAX_I64TOSTR_BASE2_COUNT
_ui64toa, _ui64tow 16
10
8
2		 _MAX_U64TOSTR_BASE16_COUNT
_MAX_U64TOSTR_BASE10_COUNT
_MAX_U64TOSTR_BASE8_COUNT
_MAX_U64TOSTR_BASE2_COUNT

En este ejemplo se usa una macro de recuento de conversiones para definir un búfer lo suficientemente grande como para contener un elemento unsigned long long en la base 2:

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

Asignaciones de rutinas de texto genérico

Rutina Tchar.h _UNICODE y _MBCS no definidos _MBCS definido _UNICODE definido
_itot _itoa _itoa _itow
_ltot _ltoa _ltoa _ltow
_ultot _ultoa _ultoa _ultow
_i64tot _i64toa _i64toa _i64tow
_ui64tot _ui64toa _ui64toa _ui64tow

Requisitos

Routine Encabezado necesario
itoa, ltoa, ultoa <stdlib.h>
_itoa, _ltoa, _ultoa, _i64toa, _ui64toa <stdlib.h>
_itow, _ltow, _ultow, _i64tow, _ui64tow <stdlib.h> o <wchar.h>

Estas funciones y macros son específicas de Microsoft. Para obtener más información sobre compatibilidad, consulte Compatibilidad.

Ejemplo

En este ejemplo se muestra el uso de algunas de las funciones de conversión de enteros. Observe el uso de la macro _CRT_SECURE_NO_WARNINGS para silenciar la advertencia 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)

Consulte también

Conversión de datos
Funciones _itoa_s, _itow_s