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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bibliothek für Zeichenketten

Klassen

basic_string

basic_string_view (C++17)

char_traits

 

std::basic_string

Memberfunktionen basic_string::basic_string basic_string::~basic_string basic_string::operator= basic_string::assign basic_string::assign_range (C++23)   basic_string::get_allocator Elementzugriff basic_string::at basic_string::operator[] basic_string::front (DR*) basic_string::back (DR*) basic_string::data basic_string::c_str basic_string::operator  basic_string_view (C++17) Iteratoren basic_string::beginbasic_string::cbegin (C++11) basic_string::endbasic_string::cend (C++11) basic_string::rbeginbasic_string::crbegin (C++11) basic_string::rendbasic_string::crend (C++11) Suche basic_string::find basic_string::rfind basic_string::find_first_of basic_string::find_first_not_of basic_string::find_last_of basic_string::find_last_not_of

Modifizierer basic_string::clear basic_string::insert basic_string::insert_range (C++23) basic_string::erase basic_string::push_back basic_string::pop_back (DR*) basic_string::append basic_string::append_range (C++23) basic_string::operator+= basic_string::replace basic_string::replace_with_range (C++23) basic_string::copy basic_string::resize basic_string::resize_and_overwrite (C++23)  basic_string::swap Kapazität basic_string::empty basic_string::sizebasic_string::length basic_string::max_size basic_string::reserve basic_string::capacity basic_string::shrink_to_fit (DR*) Operationen basic_string::compare basic_string::starts_with (C++20) basic_string::ends_with (C++20) basic_string::contains (C++23) basic_string::substr

Konstanten basic_string::npos Nicht-Member-Funktionen operator+ swap(std::basic_string) erase(std::basic_string)erase_if(std::basic_string) (C++20)(C++20) I/O operator<<operator>> getline Vergleich operator==operator!=operator<operator>operator<=operator>=operator<=> (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)(C++20) Numerische Konvertierungen stoistolstoll (C++11)(C++11)(C++11) stoulstoull (C++11)(C++11)  stofstodstold (C++11)(C++11)(C++11) to_string (C++11) to_wstring (C++11) Literale operator""s (C++14) Hilfsklassen hash<std::basic_string> (C++11) Deduction guides (C++17)

 

Definiert in Header <string>
int       stoi ( const std::string& str,                  std::size_t* pos = nullptr, int base = 10 );	(1)	(seit C++11)
int       stoi ( const std::wstring& str,                  std::size_t* pos = nullptr, int base = 10 );	(2)	(seit C++11)
long      stol ( const std::string& str,                  std::size_t* pos = nullptr, int base = 10 );	(3)	(seit C++11)
long      stol ( const std::wstring& str,                  std::size_t* pos = nullptr, int base = 10 );	(4)	(seit C++11)
long long stoll( const std::string& str,                  std::size_t* pos = nullptr, int base = 10 );	(5)	(seit C++11)
long long stoll( const std::wstring& str,                  std::size_t* pos = nullptr, int base = 10 );	(6)	(seit C++11)

Interpretiert einen vorzeichenbehafteten Integer-Wert im String str.

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

1) Ruft std::strtol(str.c_str(), &ptr, base) auf.

2) Ruft std::wcstol(str.c_str(), &ptr, base) auf.

3) Ruft std::strtol(str.c_str(), &ptr, base) auf.

4) Ruft std::wcstol(str.c_str(), &ptr, base) auf.

5) Ruft std::strtoll(str.c_str(), &ptr, base) auf.

6) Ruft std::wcstoll(str.c_str(), &ptr, base) auf.

Verwirft alle Leerzeichen (wie durch Aufruf von std::isspace identifiziert), bis das erste Nicht-Leerzeichen gefunden wird. Anschließend werden so viele Zeichen wie möglich aufgenommen, um eine gültige *basis-n* (wobei n=base) Ganzzahl-Repräsentation zu bilden, und diese werden in einen Integer-Wert konvertiert. Der gültige Integer-Wert besteht aus folgenden Teilen:

• (optional) Vorzeichen (+ oder -)
• (optional) Präfix (0) zur Angabe der Oktalbasis (gilt nur, wenn die Basis 8 oder ​0​ ist)
• (optional) Präfix (0x oder 0X) zur Angabe der Hexadezimalbasis (gilt nur, wenn die Basis 16 oder ​0​ ist)
• eine Folge von Ziffern

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

Zusätzliche numerische Formate können von der aktuell 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 durch eine unäre Negation im Ergebnistyp.

Wenn pos kein Nullzeiger ist, dann erhält ptr eine 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

str	-	der zu konvertierende String
pos	-	Adresse eines Integers, um die Anzahl der verarbeiteten Zeichen zu speichern
base	-	die numerische Basis

Rückgabewert

Integer-Wert, der dem Inhalt von str entspricht.

Ausnahmen

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

Beispiel

Führen Sie diesen Code aus

#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';
    }
}

Mögliche Ausgabe

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.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 2009	C++11	std::out_of_range würde nicht geworfen werden, wenn std::strtol oder std::strtoll errno auf ERANGE setzt	wirft

Siehe auch

stoulstoull (C++11)(C++11)	konvertiert einen String in eine vorzeichenlose Ganzzahl (function)
stofstodstold (C++11)(C++11)(C++11)	konvertiert einen String in einen Gleitkommawert (function)
strtolstrtoll (C++11)	konvertiert einen Byte-String in einen Ganzzahlwert (Funktion)
strtoulstrtoull (C++11)	konvertiert einen Byte-String in einen vorzeichenlosen Ganzzahlwert (Funktion)
strtoimaxstrtouimax (C++11)(C++11)	konvertiert einen Byte-String in std::intmax_t oder std::uintmax_t (Funktion)
from_chars (C++17)	konvertiert eine Zeichensequenz in einen Ganzzahl- oder Gleitkommawert (Funktion)
atoiatolatoll (C++11)	konvertiert einen Byte-String in einen Ganzzahlwert (Funktion)
to_string (C++11)	konvertiert einen ganzzahligen oder Gleitkommawert in einen string (function)
to_wstring (C++11)	konvertiert einen ganzzahligen oder Gleitkommawert in einen wstring (function)