itoa, _itoa, ltoa, _ltoa, ultoa, _ultoa, _i64toa, _ui64toa, , _itow, _ltow, _ultow, , , _i64tow_ui64tow

Konverterar ett heltal till en sträng. Säkrare versioner av dessa funktioner är tillgängliga, se _itoa_s, _itow_s funktioner.

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

Parameterar

value
Tal som ska konverteras.

buffer
Buffert som innehåller resultatet av konverteringen.

radix
Den bas som ska användas för konverteringen av value, som måste ligga i intervallet 2–36.

size
Längden på bufferten i enheter av teckentypen. Den här parametern härleds från buffer argumentet i C++.

Returvärde

Var och en av dessa funktioner returnerar en pekare till buffer. Det går inte att returnera något fel.

Anmärkningar

Funktionerna _itoa, _ltoa, _ultoa, _i64toaoch _ui64toa konverterar siffrorna i det angivna value argumentet till en null-avslutad teckensträng och lagrar resultatet (upp till 33 tecken för _itoa, _ltoaoch _ultoa, och 65 för _i64toa och _ui64toa) i buffer. Om radix är lika med 10 och value är negativt är det första tecknet i den lagrade strängen minustecknet (-). Funktionerna _itow, _ltow, _ultow, _i64towoch _ui64tow är bredteckenversioner av _itoa, _ltoa, _ultoa, _i64toaoch _ui64toa, respektive .

På grund av risken för säkerhetsproblem orsakar dessa funktioner som standard utfasningsvarning C4996: Den här funktionen eller variabeln kan vara osäker. Överväg att använda safe_function i stället. Om du vill inaktivera utfasning använder du _CRT_SECURE_NO_WARNINGS. Vi rekommenderar att du ändrar källkoden så att den använder det safe_function som föreslås i varningsmeddelandet. De säkrare funktionerna skriver inte fler tecken än den angivna buffertstorleken. Mer information finns i _itoa_s, _itow_s functions.

Om du vill använda dessa funktioner utan utfasningsvarningen _CRT_SECURE_NO_WARNINGS definierar du makrot för processorn innan du inkluderar crt-huvuden. Du kan definiera det genom att lägga till /D_CRT_SECURE_NO_WARNINGS kompilatoralternativet i cl kommandot . Annars definierar du makrot i källfilerna. Om du använder förkompilerade rubriker definierar du makrot överst i den förkompilerade huvud inkludera filen ( pch.hstdafx.h i Visual Studio 2017 och tidigare). Om du vill definiera makrot i källkoden använder du ett #define direktiv innan du tar med någon CRT-rubrik, som i det här exemplet:

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>

I C++har dessa funktioner överlagringar av mallar som anropar deras säkrare motsvarigheter. För mer information, se Secure template overloads.

Som standard begränsas dessa funktioners globala tillstånd till programmet. Information om hur du ändrar det här beteendet finns i global status i CRT-.

POSIX-namnen itoa, ltoaoch ultoa finns som alias för _itoafunktionerna , _ltoaoch _ultoa . POSIX-namnen är inaktuella eftersom de inte följer de implementeringsspecifika globala funktionsnamnkonventionerna i ISO C. Som standard orsakar dessa funktioner utfasningsvarning C4996: POSIX-namnet för det här objektet är inaktuellt. Använd i stället ISO C- och C++-överensstämmande namn:new_name. Vi rekommenderar att du ändrar källkoden så att du använder de säkrare versionerna av dessa funktioner, _itoa_s, _ltoa_seller _ultoa_s. Mer information finns i _itoa_s, _itow_s functions.

För portabilitet för källkod kanske du föredrar att behålla POSIX-namnen i koden. Om du vill använda dessa funktioner utan utfasningsvarningen definierar du både makrona _CRT_NONSTDC_NO_WARNINGS och _CRT_SECURE_NO_WARNINGS förprocessorn innan du inkluderar crt-huvuden. Du kan definiera dem genom att lägga till kompilatoralternativen /D_CRT_SECURE_NO_WARNINGS och /D_CRT_NONSTDC_NO_WARNINGS i cl kommandot . Annars definierar du makrona i källfilerna. Om du använder förkompilerade rubriker definierar du makrona överst i den förkompilerade huvudresursen. Om du vill definiera makron i källkoden använder #define du direktiv innan du tar med någon CRT-rubrik, som i det här exemplet:

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

Makron för maximalt antal konverteringar

För att hjälpa dig att skapa säkra buffertar för konverteringar innehåller CRT några praktiska makron. Dessa makron definierar storleken på bufferten som krävs för att konvertera det längsta möjliga värdet för varje heltalstyp, inklusive null-avslut och teckentecken, för flera vanliga baser. För att säkerställa att konverteringsbufferten är tillräckligt stor för att ta emot konverteringar i basen som anges av radixanvänder du något av dessa definierade makron när du allokerar bufferten. Makrona hjälper dig att förhindra buffertöverkörningsfel när du konverterar integraltyper till strängar. Dessa makron definieras när du inkluderar antingen stdlib.h eller wchar.h i källan.

Om du vill använda något av dessa makron i en strängkonverteringsfunktion deklarerar du konverteringsbufferten av lämplig teckentyp och använder makrovärdet för heltalstypen och basen som buffertdimension. Den här tabellen visar de makron som är lämpliga för varje funktion för de angivna baserna:

I det här exemplet används ett konverteringsräkningsmakron för att definiera en buffert som är tillräckligt stor för att innehålla ett unsigned long long i bas 2:

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

Allmän textrutinmappning

Kravspecifikation

Dessa funktioner och makron är Microsoft-specifika. Mer kompatibilitetsinformation finns i Kompatibilitet.

Exempel

Det här exemplet visar användningen av några av heltalskonverteringsfunktionerna. Observera användningen av makrot _CRT_SECURE_NO_WARNINGS för att tysta varning 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)

Se även

Datakonvertering
_itoa_s, _itow_s funktioner