itoa, , _itoa, _ltoaltoa, ultoa, _ultoa, _i64toa_ui64toa_itow_ltow_ultow_i64tow_ui64tow

Convertit un entier en chaîne. Des versions plus sécurisées de ces fonctions sont disponibles, consultez _itoa_s, _itow_s fonctions.

Syntaxe

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 );

Paramètres

value
Nombre à convertir.

buffer
Mémoire tampon qui contient le résultat de la conversion.

radix
Base à utiliser pour la conversion de value, qui doit se trouver dans la plage 2-36.

size
Longueur de la mémoire tampon en unités du type de caractère. Ce paramètre est déduit de l’argument buffer en C++.

Valeur retournée

Chacune de ces fonctions retourne un pointeur désignant buffer. Il n’existe aucun retour d’erreur.

Notes

Les _itoafonctions , , _i64toa_ui64toa _ultoa_ltoaet les fonctions convertissent les chiffres de l’argument donné value en chaîne de caractères terminée par null et stockent le résultat (jusqu’à 33 caractères pour _itoa, _ltoaet , et _ultoa65 pour _i64toa et _ui64toa) in .buffer Si radix la valeur est égale à 10 et value est négative, le premier caractère de la chaîne stockée est le signe moins (-). Les _itowfonctions , _ultow_i64tow_ltowet _ui64tow les fonctions sont des versions à caractères larges de _itoa, _ultoa_ltoa, , _i64toa, et _ui64toa, respectivement.

En raison de leur potentiel pour les problèmes de sécurité, par défaut, ces fonctions entraînent l’avertissement de dépréciation C4996 : cette fonction ou cette variable peut être dangereuse. Envisagez plutôt d’utiliser safe_function . Pour désactiver la dépréciation, utilisez _CRT_SECURE_NO_WARNINGS. Nous vous recommandons de modifier votre code source pour utiliser le safe_function message d’avertissement suggéré par le message d’avertissement. Les fonctions plus sécurisées n’écrivent pas plus de caractères que la taille de mémoire tampon spécifiée. Pour plus d’informations, consultez _itoa_s, _itow_s fonctions.

Pour utiliser ces fonctions sans avertissement de dépréciation, définissez la _CRT_SECURE_NO_WARNINGS macro de préprocesseur avant d’inclure les en-têtes CRT. Vous pouvez le définir en ajoutant l’option du /D_CRT_SECURE_NO_WARNINGS compilateur à la cl commande. Sinon, définissez la macro dans vos fichiers sources. Si vous utilisez des en-têtes précompilés, définissez la macro en haut du fichier include précompilé ( pch.hstdafx.h dans Visual Studio 2017 et versions antérieures). Pour définir la macro dans votre code source, utilisez une #define directive avant d’inclure un en-tête CRT, comme dans cet exemple :

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>

En C++, ces fonctions ont des surcharges de modèle qui appellent leurs équivalents plus sûrs. Pour plus d'informations, consultez Sécuriser les surcharges de modèle.

Par défaut, l’état global de ces fonctions est limité à l’application. Pour modifier ce comportement, consultez État global dans le CRT.

Les noms itoaPOSIX, ltoaet ultoa existent en tant qu’alias pour les fonctions et _ultoa _ltoales _itoafonctions. Les noms POSIX sont déconseillés, car ils ne suivent pas les conventions de nom de fonction globale spécifiques à l’implémentation de la norme ISO C. Par défaut, ces fonctions entraînent l’avertissement de dépréciation C4996 : le nom POSIX de cet élément est déconseillé. Utilisez plutôt le nom conforme ISO C et C++ : new_name. Nous vous recommandons de modifier votre code source pour utiliser les versions plus sûres de ces fonctions, _itoa_sou _ltoa_s_ultoa_s. Pour plus d’informations, consultez _itoa_s, _itow_s fonctions.

Pour la portabilité du code source, vous pouvez préférer conserver les noms POSIX dans votre code. Pour utiliser ces fonctions sans avertissement de dépréciation, définissez à la fois les macros et _CRT_SECURE_NO_WARNINGS les _CRT_NONSTDC_NO_WARNINGS macros de préprocesseur avant d’inclure les en-têtes CRT. Vous pouvez les définir en ajoutant les /D_CRT_SECURE_NO_WARNINGS options du compilateur à /D_CRT_NONSTDC_NO_WARNINGS la cl commande. Sinon, définissez les macros dans vos fichiers sources. Si vous utilisez des en-têtes précompilés, définissez les macros en haut du fichier include de l’en-tête précompilé. Pour définir les macros dans votre code source, utilisez #define des directives avant d’inclure n’importe quel en-tête CRT, comme dans cet exemple :

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

Nombre maximal de macros de nombre de conversion

Pour vous aider à créer des mémoires tampons sécurisées pour les conversions, le CRT inclut des macros pratiques. Ces macros définissent la taille de la mémoire tampon requise pour convertir la valeur la plus longue possible de chaque type entier, y compris le caractère de fin null et le caractère de signe, pour plusieurs bases courantes. Pour vous assurer que votre mémoire tampon de conversion est suffisamment grande pour recevoir une conversion dans la base spécifiée par radix, utilisez l’une de ces macros définies lorsque vous allouez la mémoire tampon. Les macros vous aident à empêcher les erreurs de dépassement de mémoire tampon lorsque vous convertissez des types intégraux en chaînes. Ces macros sont définies lorsque vous incluez stdlib.h ou wchar.h dans votre source.

Pour utiliser l’une de ces macros dans une fonction de conversion de chaîne, déclarez votre mémoire tampon de conversion du type de caractère approprié et utilisez la valeur de macro pour le type entier et la base comme dimension de mémoire tampon. Ce tableau répertorie les macros appropriées pour chaque fonction pour les bases répertoriées :

Cet exemple utilise une macro de nombre de conversion pour définir une mémoire tampon suffisamment grande pour contenir une unsigned long long macro en base 2 :

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

Mappages de routines de texte générique

Spécifications

Ces fonctions et macros sont spécifiques à Microsoft. Pour plus d’informations sur la compatibilité, consultez Compatibility.

Exemple

Cet exemple illustre l’utilisation de certaines des fonctions de conversion d’entiers. Notez l’utilisation de la _CRT_SECURE_NO_WARNINGS macro pour silence l’avertissement 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)

Voir aussi

Conversion de données
_itoa_s, fonctions _itow_s