itoa, _itoa, ltoa, _ltoa, , _ultoaultoa, _i64toa, _ui64toa_itow_ltow_ultow_i64tow_ui64tow
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 plantilla 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:
| Funciones | 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)