Partager via


_itoa_s, , _ltoa_s, _i64toa_s_ultoa_s, , _itow_s_i64tow_s_ltow_s_ultow_s_ui64toa_s_ui64tow_s

Convertit un entier en chaîne. Ces fonctions sont des versions des fonctions avec _itow des améliorations de _itoasécurité, comme décrit dans les fonctionnalités de sécurité du CRT.

Syntaxe

errno_t _itoa_s( int value, char * buffer, size_t size, int radix );
errno_t _ltoa_s( long value, char * buffer, size_t size, int radix );
errno_t _ultoa_s( unsigned long value, char * buffer, size_t size, int radix );
errno_t _i64toa_s( long long value, char *buffer,
   size_t size, int radix );
errno_t _ui64toa_s( unsigned long long value, char *buffer,
   size_t size, int radix );

errno_t _itow_s( int value, wchar_t *buffer,
   size_t size, int radix );
errno_t _ltow_s( long value, wchar_t *buffer,
   size_t size, int radix );
errno_t _ultow_s( unsigned long value, wchar_t *buffer,
   size_t size, int radix );
errno_t _i64tow_s( long long value, wchar_t *buffer,
   size_t size, int radix );
errno_t _ui64tow_s( unsigned long long value, wchar_t *buffer,
   size_t size, int radix
);

// These template functions are C++ only:
template <size_t size>
errno_t _itoa_s( int value, char (&buffer)[size], int radix );

template <size_t size>
errno_t _ltoa_s( long value, char (&buffer)[size], int radix );

template <size_t size>
errno_t _ultoa_s( unsigned long value, char (&buffer)[size], int radix );

template <size_t size>
errno_t _itow_s( int value, wchar_t (&buffer)[size], int radix );

template <size_t size>
errno_t _ltow_s( long value, wchar_t (&buffer)[size], int radix );

template <size_t size>
errno_t _ultow_s( unsigned long value, wchar_t (&buffer)[size], int radix );

Paramètres

value
Nombre à convertir.

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

size
Taille des buffer caractères ou des caractères larges.

radix
Base radix ou numérique à utiliser pour convertir value, qui doit se trouver dans la plage 2-36.

Valeur retournée

Zéro si l'opération a réussi ; code d'erreur en cas de échec. Si l’une des conditions suivantes s’applique, la fonction appelle un gestionnaire de paramètres non valide, comme décrit dans la validation des paramètres.

Conditions d’erreur

value buffer size radix Retour
n'importe laquelle NULL tous tous EINVAL
tous n'importe laquelle <=0 n'importe laquelle EINVAL
tous n'importe laquelle <= longueur de la chaîne de résultat requise n'importe laquelle EINVAL
tous tous n'importe laquelle radix< 2 ou radix> 36 EINVAL

Problèmes de sécurité

Ces fonctions peuvent générer une violation d’accès si buffer elle ne pointe pas vers la mémoire valide et n’est pas NULL, ou si la longueur de la mémoire tampon n’est pas suffisamment longue pour contenir la chaîne de résultat.

Notes

À l’exception des paramètres et de la valeur de retour, les familles de fonctions et _itow_s les _itoa_s familles de fonctions ont le même comportement que les versions et _itow moins sécurisées _itoa correspondantes.

En C++, l’utilisation de ces fonctions est simplifiée par les surcharges de modèle ; les surcharges peuvent déduire la longueur de la mémoire tampon automatiquement (ce qui évite d’avoir à spécifier un argument taille) et peuvent remplacer automatiquement les fonctions plus anciennes et non sécurisées par leurs équivalentes plus récentes et sécurisées. Pour plus d'informations, consultez Sécuriser les surcharges de modèle.

Les versions de bibliothèque de débogage de ces fonctions remplissent d’abord la mémoire tampon avec 0xFE. Pour désactiver ce comportement, utilisez _CrtSetDebugFillThreshold.

Le CRT inclut des macros pratiques pour définir la taille de la mémoire tampon requise pour convertir la valeur la plus longue possible de chaque type entier, y compris le point de fin null et le caractère de signe, pour plusieurs bases courantes. Pour plus d’informations, consultez les macros de nombre maximal de conversion.

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

Mappages de routines de texte générique

Routine Tchar.h _UNICODE et _MBCS non définis _MBCS défini _UNICODE défini
_itot_s _itoa_s _itoa_s _itow_s
_ltot_s _ltoa_s _ltoa_s _ltow_s
_ultot_s _ultoa_s _ultoa_s _ultow_s
_i64tot_s _i64toa_s _i64toa_s _i64tow_s
_ui64tot_s _ui64toa_s _ui64toa_s _ui64tow_s

Spécifications

Routine En-tête requis
_itoa_s, , _ltoa_s_ultoa_s, , _i64toa_s_ui64toa_s <stdlib.h>
_itow_s, , _ltow_s_ultow_s, , _i64tow_s_ui64tow_s <stdlib.h> ou <wchar.h>

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

Exemple

Cet exemple illustre l’utilisation de quelques-unes des fonctions de conversion entière. La _countof macro fonctionne uniquement pour déterminer la taille de la mémoire tampon lorsque la déclaration de tableau est visible par le compilateur, et non pour les paramètres qui ont détérioré les pointeurs.

// crt_itoa_s.c
// Compile by using: cl /W4 crt_itoa_s.c
#include <stdlib.h>     // for _itoa_s functions, _countof, count macro
#include <stdio.h>      // for printf
#include <string.h>     // for strnlen

int main( void )
{
    char buffer[_MAX_U64TOSTR_BASE2_COUNT];
    int r;
    for ( r = 10; r >= 2; --r )
    {
        _itoa_s( -1, buffer, _countof(buffer), r );
        printf( "base %d: %s (%d chars)\n",
            r, buffer, strnlen(buffer, _countof(buffer)) );
    }
    printf( "\n" );
    for ( r = 10; r >= 2; --r )
    {
        _i64toa_s( -1LL, buffer, _countof(buffer), r );
        printf( "base %d: %s (%d chars)\n",
            r, buffer, strnlen(buffer, _countof(buffer)) );
    }
    printf( "\n" );
    for ( r = 10; r >= 2; --r )
    {
        _ui64toa_s( 0xffffffffffffffffULL, buffer, _countof(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, fonctions _itow