Freigeben über

_itoa_s, _ltoa_s, , _i64toa_s_ultoa_s, _ui64toa_s, _itow_s, _ltow_s, , , _ultow_s, , _i64tow_s_ui64tow_s

  • Artikel

Konvertiert eine ganze Zahl in eine Zeichenfolge. Diese Funktionen sind Versionen der _itoaFunktionen mit _itow Sicherheitsverbesserungen, wie in den Sicherheitsfeatures im CRT beschrieben.

Syntax

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

Parameter

value
Zu konvertierende Zahl.

buffer
Ausgabepuffer, der das Ergebnis der Konvertierung enthält.

size
Größe von buffer Zeichen oder breiten Zeichen.

radix
Die zu konvertierende valueradix- oder numerische Basis, die im Bereich 2-36 liegen muss.

Rückgabewert

Null, wenn erfolgreich, ein Fehlercode, wenn ein Fehler auftritt. Wenn eine der folgenden Bedingungen zutrifft, ruft die Funktion einen ungültigen Parameterhandler auf, wie in der Parameterüberprüfung beschrieben.

Fehlerbedingungen

value Puffer size Basis Return
any NULL Beliebig Beliebig EINVAL
Beliebig any <=0 any EINVAL
Beliebig any <= Länge der erforderlichen Ergebniszeichenfolge any EINVAL
Beliebig Beliebig any radix< 2 oder radix> 36 EINVAL

Sicherheitsprobleme

Diese Funktionen können eine Zugriffsverletzung generieren, wenn buffer sie nicht auf den gültigen Speicher verweist und nicht NULL, oder wenn die Länge des Puffers nicht lang genug ist, um die Ergebniszeichenfolge aufzunehmen.

Hinweise

Mit Ausnahme der Parameter und des Rückgabewerts weisen die _itoa_s Familien und _itow_s Funktionsfamilien das gleiche Verhalten wie die entsprechenden weniger sicheren _itoa Versionen auf _itow .

In C++ wird die Verwendung dieser Funktionen durch Vorlagenüberladungen vereinfacht; die Überladungen können automatisch Rückschlüsse auf die Pufferlänge ziehen (wodurch kein Größenargument mehr angegeben werden muss), und sie können automatisch die älteren, nicht sicheren Funktionen durch ihre neueren, sicheren Entsprechungen ersetzen. Weitere Informationen finden Sie unter Secure Template Overloads.

Die Debugbibliotheksversionen dieser Funktionen füllen zuerst den Puffer mit 0xFE. Verwenden Sie _CrtSetDebugFillThresholdzum Deaktivieren dieses Verhaltens .

Das CRT enthält praktische Makros, um die Größe des Puffers zu definieren, der erforderlich ist, um den längsten möglichen Wert jedes ganzzahligen Typs zu konvertieren, einschließlich des Null-Endzeichens und des Zeichenzeichens für mehrere gängige Basisen. Weitere Informationen finden Sie unter "Maximale Konvertierungsanzahl"-Makros.

Standardmäßig gilt der globale Zustand dieser Funktion für die Anwendung. Wie Sie dieses Verhalten ändern, erfahren Sie unter Globaler Status in der CRT.

Mapping generischer Textroutinen

Tchar.h-Routine _UNICODE und _MBCS nicht definiert _MBCS definiert _UNICODE definiert
_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

Anforderungen

Routine Erforderlicher Header
_itoa_s, , _ltoa_s_ultoa_s, , _i64toa_s_ui64toa_s <stdlib.h>
_itow_s, , _ltow_s_ultow_s, , _i64tow_s_ui64tow_s <stdlib.h> oder <wchar.h>

Diese Funktionen sind microsoftspezifisch. Weitere Informationen zur Kompatibilität finden Sie unter Kompatibilität.

Beispiel

In diesem Beispiel wird die Verwendung einiger ganzzahliger Konvertierungsfunktionen veranschaulicht. Das _countof Makro funktioniert nur, um die Puffergröße zu bestimmen, wenn die Arraydeklaration für den Compiler sichtbar ist, und nicht für Parameter, die auf Zeiger verfallen sind.

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

Siehe auch

Datenkonvertierung
_itoa, _itow Funktionen