itoa
ltoa
, _itoa
, _ltoa
, ultoa
, _ultoa
, _i64toa
, _ui64toa
_itow
, , _ltow
_ultow
, , _i64tow
_ui64tow
Converte un intero in una stringa. Sono disponibili versioni più sicure di queste funzioni, vedere _itoa_s
, _itow_s
funzioni.
Sintassi
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 );
Parametri
value
Numero da convertire.
buffer
Buffer che contiene il risultato della conversione.
radix
Base da usare per la conversione di value
, che deve essere compreso nell'intervallo da 2 a 36.
size
Lunghezza del buffer in unità del tipo di carattere. Questo parametro viene dedotto dall'argomento buffer
in C++.
Valore restituito
Ognuna di queste funzioni restituisce un puntatore a buffer
. Non viene restituito alcun errore.
Osservazioni:
Le _itoa
funzioni , _ultoa
_ltoa
, _i64toa
, e _ui64toa
converte le cifre dell'argomento specificato value
in una stringa di caratteri con terminazione Null e archivia il risultato (fino a 33 caratteri per _itoa
, _ltoa
e _ultoa
e 65 per _i64toa
e _ui64toa
) in buffer
. Se radix
è uguale a 10 e value
è negativo, il primo carattere della stringa archiviata è il segno meno (-). Le _itow
funzioni , _ultow
_ltow
, _i64tow
, e _ui64tow
sono rispettivamente versioni a caratteri wide di _itoa
, , _ultoa
_ltoa
_i64toa
, e ._ui64toa
Importante
Queste funzioni possono scrivere oltre la fine di un buffer troppo piccolo. Per evitare sovraccarichi del buffer, assicurarsi che buffer
sia sufficientemente grande da contenere le cifre convertite, oltre al carattere null finale e a un carattere di segno. L'uso improprio di queste funzioni può causare gravi problemi di sicurezza nel codice.
A causa del potenziale di problemi di sicurezza, per impostazione predefinita, queste funzioni causano un avviso di deprecazione C4996: questa funzione o variabile potrebbe non essere sicura. Prendere invece in considerazione l'uso safe_function
di . Per disabilitare la deprecazione, usare _CRT_SECURE_NO_WARNINGS
. È consigliabile modificare il codice sorgente in modo da usare il safe_function
suggerito dal messaggio di avviso. Le funzioni più sicure non scrivono più caratteri rispetto alle dimensioni del buffer specificate. Per altre informazioni, vedere _itoa_s
, _itow_s
funzioni.
Per usare queste funzioni senza l'avviso di deprecazione, definire la _CRT_SECURE_NO_WARNINGS
macro del preprocessore prima di includere eventuali intestazioni CRT. È possibile definirlo aggiungendo l'opzione del /D_CRT_SECURE_NO_WARNINGS
cl
compilatore al comando . In caso contrario, definire la macro nei file di origine. Se si usano intestazioni precompilate, definire la macro nella parte superiore del file di inclusione dell'intestazione precompilata ( pch.h
stdafx.h
in Visual Studio 2017 e versioni precedenti). Per definire la macro nel codice sorgente, usare una #define
direttiva prima di includere qualsiasi intestazione CRT, come nell'esempio seguente:
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>
In C++, queste funzioni hanno overload di modelli che richiamano le controparti più sicure. Per altre informazioni, vedere Proteggere gli overload dei modelli.
Per impostazione predefinita, lo stato globale di queste funzioni è limitato all'applicazione. Per modificare questo comportamento, vedere Stato globale in CRT.
I nomi itoa
POSIX , ltoa
e ultoa
esistono come alias per le _itoa
funzioni , _ltoa
e _ultoa
. I nomi POSIX sono deprecati perché non seguono le convenzioni di nome della funzione globale specifiche dell'implementazione di ISO C. Per impostazione predefinita, queste funzioni causano un avviso di deprecazione C4996: il nome POSIX per questo elemento è deprecato. Usare invece il nome conforme a ISO C e C++: new_name
. È consigliabile modificare il codice sorgente per usare le versioni più sicure di queste funzioni, _itoa_s
, _ltoa_s
o _ultoa_s
. Per altre informazioni, vedere _itoa_s
, _itow_s
funzioni.
Per la portabilità del codice sorgente, è preferibile conservare i nomi POSIX nel codice. Per usare queste funzioni senza l'avviso di deprecazione, definire sia le macro del _CRT_NONSTDC_NO_WARNINGS
_CRT_SECURE_NO_WARNINGS
preprocessore sia prima di includere eventuali intestazioni CRT. È possibile definirli aggiungendo le opzioni del /D_CRT_SECURE_NO_WARNINGS
compilatore e /D_CRT_NONSTDC_NO_WARNINGS
al cl
comando . In caso contrario, definire le macro nei file di origine. Se si utilizzano intestazioni precompilate, definire le macro nella parte superiore del file di inclusione dell'intestazione precompilata. Per definire le macro nel codice sorgente, usare #define
le direttive prima di includere qualsiasi intestazione CRT, come in questo esempio:
#define _CRT_NONSTDC_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>
Numero massimo di macro per il conteggio delle conversioni
Per semplificare la creazione di buffer sicuri per le conversioni, CRT include alcune macro utili. Queste macro definiscono le dimensioni del buffer necessario per convertire il valore più lungo possibile di ogni tipo integer, incluso il carattere di terminazione Null e il carattere di segno, per diverse basi comuni. Per assicurarsi che il buffer di conversione sia sufficientemente grande da ricevere qualsiasi conversione nella base specificata da radix
, usare una di queste macro definite quando si alloca il buffer. Le macro consentono di evitare errori di sovraccarico del buffer quando si converte tipi integrali in stringhe. Queste macro vengono definite quando si include stdlib.h o wchar.h nell'origine.
Per utilizzare una di queste macro in una funzione di conversione di stringhe, dichiarare il buffer di conversione del tipo di carattere appropriato e utilizzare il valore macro per il tipo integer e la base come dimensione buffer. Questa tabella elenca le macro appropriate per ogni funzione per le basi elencate:
Funzioni | radix | Macro |
---|---|---|
_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 |
In questo esempio viene utilizzata una macro di conteggio delle conversioni per definire un buffer sufficientemente grande da contenere un oggetto unsigned long long
in base 2:
#include <wchar.h>
#include <iostream>
int main()
{
wchar_t buffer[_MAX_U64TOSTR_BASE2_COUNT];
std:wcout << _ui64tow(0xFFFFFFFFFFFFFFFFull, buffer, 2) << std::endl;
}
Mapping di routine di testo generico
Tchar.h routine |
_UNICODE e _MBCS non definito |
_MBCS definito |
_UNICODE definito |
---|---|---|---|
_itot |
_itoa |
_itoa |
_itow |
_ltot |
_ltoa |
_ltoa |
_ltow |
_ultot |
_ultoa |
_ultoa |
_ultow |
_i64tot |
_i64toa |
_i64toa |
_i64tow |
_ui64tot |
_ui64toa |
_ui64toa |
_ui64tow |
Requisiti
Ciclo | Intestazione obbligatoria |
---|---|
itoa , ltoa , ultoa |
<stdlib.h> |
_itoa , _ltoa , _ultoa , _i64toa _ui64toa |
<stdlib.h> |
_itow , _ltow , _ultow , _i64tow _ui64tow |
<stdlib.h> oppure <wchar.h> |
Queste funzioni e macro sono specifiche di Microsoft. Per altre informazioni sulla compatibilità, vedere Compatibility (Compatibilità).
Esempio
In questo esempio viene illustrato l'uso di alcune delle funzioni di conversione integer. Si noti l'uso della _CRT_SECURE_NO_WARNINGS
macro per disattivare l'avviso 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)