std::stoi, std::stol, std::stoll

int       stoi ( const std::string& str,
                 std::size_t* pos = nullptr, int base = 10 );

int       stoi ( const std::wstring& str,
                 std::size_t* pos = nullptr, int base = 10 );

long      stol ( const std::string& str,
                 std::size_t* pos = nullptr, int base = 10 );

long      stol ( const std::wstring& str,
                 std::size_t* pos = nullptr, int base = 10 );

long long stoll( const std::string& str,
                 std::size_t* pos = nullptr, int base = 10 );

long long stoll( const std::wstring& str,
                 std::size_t* pos = nullptr, int base = 10 );

Interpretiert einen vorzeichenbehafteten ganzzahligen Wert in der Zeichenkette str.

Sei ptr ein interner (für die Konvertierungsfunktionen) Zeiger vom Typ char* (1,3,5) oder wchar_t* (2,4,6), entsprechend.

Verwirft alle Leerraum-Zeichen (identifiziert durch Aufruf von std::isspace), bis das erste Nicht-Leerraum-Zeichen gefunden wird, nimmt dann so viele Zeichen wie möglich, um eine gültige Basis-n (wobei n=base) Ganzzahlendarstellung zu bilden, und konvertiert diese in einen ganzzahligen Wert. Die gültige Ganzzahlendarstellung besteht aus den folgenden Teilen:

• (optional) Plus- oder Minuszeichen
• (optional) Präfix (0) zur Angabe der oktalen Basis (gilt nur, wenn die Basis 8 oder 0 ist)
• (optional) Präfix (0x oder 0X) zur Angabe der hexadezimalen Basis (gilt nur, wenn die Basis 16 oder 0 ist)
• eine Folge von Ziffern

Die Menge der gültigen Werte für die Basis ist {0, 2, 3, ..., 36}. Die Menge der gültigen Ziffern für Ganzzahlen zur Basis 2 ist {0, 1}, für Ganzzahlen zur Basis 3 ist sie {0, 1, 2} und so weiter. Für Basen größer als 10 umfassen gültige Ziffern alphabetische Zeichen, beginnend mit Aa für die Ganzzahl zur Basis 11 bis zu Zz für die Ganzzahl zur Basis 36. Die Groß-/Kleinschreibung der Zeichen wird ignoriert.

Zusätzliche numerische Formate können von dem derzeit installierten C-Locale akzeptiert werden.

Wenn der Wert von base 0 ist, wird die numerische Basis automatisch erkannt: Wenn das Präfix 0 ist, ist die Basis oktal; wenn das Präfix 0x oder 0X ist, ist die Basis hexadezimal; andernfalls ist die Basis dezimal.

Wenn das Minuszeichen Teil der Eingabesequenz war, wird der aus der Ziffernfolge berechnete numerische Wert negiert, als ob unäres Minus im Ergebnistyp angewendet würde.

Wenn pos kein Nullzeiger ist, erhält ptr die Adresse des ersten nicht konvertierten Zeichens in str.c_str(), und der Index dieses Zeichens wird berechnet und in *pos gespeichert, was die Anzahl der Zeichen angibt, die von der Konvertierung verarbeitet wurden.

Parameter

Rückgabewert

Integer-Wert entsprechend dem Inhalt von str .

Exceptions

• std::invalid_argument falls keine Konvertierung durchgeführt werden konnte.
• std::out_of_range wenn der konvertierte Wert außerhalb des Bereichs des Ergebnistyps liegen würde oder wenn die zugrunde liegende Funktion ( std::strtol oder std::strtoll ) errno auf ERANGE setzt.

Beispiel

#include <iomanip>
#include <iostream>
#include <stdexcept>
#include <string>
#include <utility>
int main()
{
    const auto data =
    {
        "45",
        "+45",
        " -45",
        "3.14159",
        "31337 with words",
        "words and 2",
        "12345678901",
    };
    for (const std::string s : data)
    {
        std::size_t pos{};
        try
        {
            std::cout << "std::stoi(" << std::quoted(s) << "): ";
            const int i{std::stoi(s, &pos)};
            std::cout << i << "; pos: " << pos << '\n';
        }
        catch (std::invalid_argument const& ex)
        {
            std::cout << "std::invalid_argument::what(): " << ex.what() << '\n';
        }
        catch (std::out_of_range const& ex)
        {
            std::cout << "std::out_of_range::what(): " << ex.what() << '\n';
            const long long ll{std::stoll(s, &pos)};
            std::cout << "std::stoll(" << std::quoted(s) << "): " << ll
                      << "; pos: " << pos << '\n';
        }
    }
    std::cout << "\nCalling with different radixes:\n";
    for (const auto& [s, base] : {std::pair<const char*, int>
        {"11",  2}, {"22",  3}, {"33",  4}, {"77",  8},
        {"99", 10}, {"FF", 16}, {"jJ", 20}, {"Zz", 36}})
    {
        const int i{std::stoi(s, nullptr, base)};
        std::cout << "std::stoi(" << std::quoted(s)
                  << ", nullptr, " << base << "): " << i << '\n';
    }
}

std::stoi("45"): 45; pos: 2
std::stoi("+45"): 45; pos: 3
std::stoi(" -45"): -45; pos: 4
std::stoi("3.14159"): 3; pos: 1
std::stoi("31337 with words"): 31337; pos: 5
std::stoi("words and 2"): std::invalid_argument::what(): stoi
std::stoi("12345678901"): std::out_of_range::what(): stoi
std::stoll("12345678901"): 12345678901; pos: 11
Calling with different radixes:
std::stoi("11", nullptr, 2): 3
std::stoi("22", nullptr, 3): 8
std::stoi("33", nullptr, 4): 15
std::stoi("77", nullptr, 8): 63
std::stoi("99", nullptr, 10): 99
std::stoi("FF", nullptr, 16): 255
std::stoi("jJ", nullptr, 20): 399
std::stoi("Zz", nullptr, 36): 1295

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch