itoa, _itoa, , ltoa, _ltoa, _ultoaultoa, _i64toa, , _ui64toa, _itow, , _ltow_ultow, , _i64tow_ui64tow
Konvertiert eine ganze Zahl in eine Zeichenfolge. Sicherere Versionen dieser Funktionen sind verfügbar, siehe _itoa_sFunktionen_itow_s.
Syntax
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 );
Parameter
value
Zu konvertierende Zahl.
buffer
Puffer, der das Ergebnis der Konvertierung enthält.
radix
Die Basis für die Konvertierung von value, die im Bereich von 2-36 liegen muss.
size
Länge des Puffers in Einheiten des Zeichentyps. Dieser Parameter wird aus dem buffer Argument in C++ abgeleitet.
Rückgabewert
Jede dieser Funktionen gibt einen Zeiger auf buffer zurück. Es gibt keine Fehlerrückgabe.
Hinweise
Mit _itoaden Funktionen , , _ultoa, _i64toaund _ui64toa Funktionen werden die Ziffern des angegebenen value Arguments in eine Zeichenfolge mit NULL-Endung konvertiert und das Ergebnis (bis zu 33 Zeichen für , _ltoaund , und _ultoa65 für _i64toa _itoaund ) in buffer._ui64toa_ltoa Wenn radix gleich 10 und value negativ ist, ist das erste Zeichen der gespeicherten Zeichenfolge das Minuszeichen (-). Die _itow, _ltow, _ultow, _i64tow, und _ui64tow Funktionen sind breitformatige Versionen von _itoa, _ltoa, , _i64toa_ultoa, und _ui64toa, bzw. .
Wichtig
Diese Funktionen können über das Ende eines Puffers schreiben, der zu klein ist. Um Pufferüberläufe zu verhindern, stellen Sie sicher, dass sie buffer groß genug ist, um die konvertierten Ziffern sowie das nachfolgende NULL-Zeichen und ein Zeichenzeichen zu enthalten. Missbrauch dieser Funktionen kann schwerwiegende Sicherheitsprobleme in Ihrem Code verursachen.
Aufgrund ihres Potenziellen für Sicherheitsprobleme verursachen diese Funktionen standardmäßig eine Veraltetkeitswarnung C4996: Diese Funktion oder Variable ist möglicherweise unsicher. Erwägen Sie stattdessen die Verwendung safe_function . Verwenden Sie _CRT_SECURE_NO_WARNINGSzum Deaktivieren der Deaktivierung . Es wird empfohlen, den Quellcode so zu ändern, dass er von safe_function der Warnmeldung vorgeschlagen wird. Die sichereren Funktionen schreiben nicht mehr Zeichen als die angegebene Puffergröße. Weitere Informationen finden Sie unter _itoa_s, _itow_s Funktionen.
Um diese Funktionen ohne Die Veraltetkeitswarnung zu verwenden, definieren Sie das _CRT_SECURE_NO_WARNINGS Präprozessormakro, bevor Sie CRT-Header einschließen. Sie können sie definieren, indem Sie dem cl Befehl die /D_CRT_SECURE_NO_WARNINGS Compileroption hinzufügen. Definieren Sie andernfalls das Makro in den Quelldateien. Wenn Sie vorkompilierte Kopfzeilen verwenden, definieren Sie das Makro oben im vorkompilierten Header mit der Datei pch.h (stdafx.h in Visual Studio 2017 und früher). Um das Makro in Ihrem Quellcode zu definieren, verwenden Sie eine #define Direktive, bevor Sie einen CRT-Header einschließen, wie in diesem Beispiel:
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>
In C++ verfügen diese Funktionen über Vorlagenüberladungen, die ihre sichereren Entsprechungen aufrufen. Weitere Informationen finden Sie unter Secure Template Overloads.
Standardmäßig ist der globale Zustand dieser Funktionen auf die Anwendung festgelegt. Wie Sie dieses Verhalten ändern, erfahren Sie unter Globaler Status in der CRT.
Die POSIX-Namen itoa, ltoaund ultoa existieren als Aliase für die _itoa, _ltoaund _ultoa Funktionen. Die POSIX-Namen sind veraltet, da sie nicht den implementierungsspezifischen globalen Funktionsnamenkonventionen von ISO C entsprechen. Standardmäßig verursachen diese Funktionen die Veraltetkeitswarnung C4996: Der POSIX-Name für dieses Element ist veraltet. Verwenden Sie stattdessen den ISO C- und C++-konformen Namen: new_name. Es wird empfohlen, den Quellcode so zu ändern, dass die sichereren Versionen dieser Funktionen, _itoa_s, , _ltoa_soder _ultoa_s. Weitere Informationen finden Sie unter _itoa_s, _itow_s Funktionen.
Für die Portabilität von Quellcode können Sie die POSIX-Namen in Ihrem Code beibehalten. Wenn Sie diese Funktionen ohne die Warnung "Veraltet" verwenden möchten, definieren Sie sowohl die Makros als _CRT_SECURE_NO_WARNINGS auch die _CRT_NONSTDC_NO_WARNINGS Vorprozessormakros, bevor Sie CRT-Header einschließen. Sie können sie definieren, indem Sie dem cl Befehl die /D_CRT_SECURE_NO_WARNINGS Optionen und /D_CRT_NONSTDC_NO_WARNINGS Compileroptionen hinzufügen. Definieren Sie andernfalls die Makros in Den Quelldateien. Wenn Sie vorkompilierte Kopfzeilen verwenden, definieren Sie die Makros oben in der vorkompilierten Kopfzeile. Um die Makros im Quellcode zu definieren, verwenden #define Sie Direktiven, bevor Sie einen CRT-Header einschließen, wie in diesem Beispiel:
#define _CRT_NONSTDC_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>
Maximale Konvertierungsanzahl von Makros
Damit Sie sichere Puffer für Konvertierungen erstellen können, enthält das CRT einige praktische Makros. Diese Makros definieren die Größe des Puffers, 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 allgemeine Basisen. Um sicherzustellen, dass der Konvertierungspuffer groß genug ist, um eine Konvertierung in der angegebenen Basis radixzu erhalten, verwenden Sie eines dieser definierten Makros, wenn Sie den Puffer zuweisen. Mithilfe der Makros können Sie Pufferüberlauffehler vermeiden, wenn Sie integrale Typen in Zeichenfolgen konvertieren. Diese Makros werden definiert, wenn Sie entweder "stdlib.h" oder "wchar.h" in Ihre Quelle einschließen.
Um eines dieser Makros in einer Zeichenfolgenkonvertierungsfunktion zu verwenden, deklarieren Sie den Konvertierungspuffer des entsprechenden Zeichentyps, und verwenden Sie den Makrowert für den ganzzahligen Typ und die Basis als Pufferdimension. In dieser Tabelle sind die Makros aufgeführt, die für jede Funktion für die aufgelisteten Basisen geeignet sind:
| Funktionen | Basis | Makros |
|---|---|---|
_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 diesem Beispiel wird ein Konvertierungsanzahlmakro verwendet, um einen Puffer zu definieren, der groß genug ist, um eine unsigned long long in Base 2 enthaltende Puffer zu definieren:
#include <wchar.h>
#include <iostream>
int main()
{
wchar_t buffer[_MAX_U64TOSTR_BASE2_COUNT];
std:wcout << _ui64tow(0xFFFFFFFFFFFFFFFFull, buffer, 2) << std::endl;
}
Mapping generischer Textroutinen
Tchar.h-Routine |
_UNICODE und _MBCS nicht definiert |
_MBCS definiert |
_UNICODE definiert |
|---|---|---|---|
_itot |
_itoa |
_itoa |
_itow |
_ltot |
_ltoa |
_ltoa |
_ltow |
_ultot |
_ultoa |
_ultoa |
_ultow |
_i64tot |
_i64toa |
_i64toa |
_i64tow |
_ui64tot |
_ui64toa |
_ui64toa |
_ui64tow |
Anforderungen
| Routine | Erforderlicher Header |
|---|---|
itoa, ltoaultoa |
<stdlib.h> |
_itoa, , _ltoa_ultoa, , _i64toa_ui64toa |
<stdlib.h> |
_itow, , _ltow_ultow, , _i64tow_ui64tow |
<stdlib.h> oder <wchar.h> |
Diese Funktionen und Makros sind microsoftspezifisch. Weitere Informationen zur Kompatibilität finden Sie unter Kompatibilität.
Beispiel
In diesem Beispiel wird die Verwendung einiger ganzzahliger Konvertierungsfunktionen veranschaulicht. Beachten Sie die Verwendung des _CRT_SECURE_NO_WARNINGS Makros zum Stillen der Warnung 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)