itoa, _itoa, ltoa, _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 _itoafunzioni , _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, _ltoae _ultoae 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 _itowfunzioni , _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_WARNINGScl 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.hstdafx.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 itoaPOSIX , ltoae ultoa esistono come alias per le _itoafunzioni , _ltoae _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_so _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)

Vedi anche

Conversione dei dati
_itoa_s, _itow_s funzioni