_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
| valeur | buffer | size | radix | Renvoie |
|---|---|---|---|---|
| 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)