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

Interprète une valeur entière signée dans la chaîne str.

Soit ptr un pointeur interne (aux fonctions de conversion) de type char* (1,3,5) ou wchar_t* (2,4,6), selon le cas.

Ignore tous les caractères d'espacement (identifiés en appelant std::isspace) jusqu'à ce que le premier caractère non blanc soit trouvé, puis prend autant de caractères que possible pour former une représentation valide d'un nombre entier en base-n (où n=base) et les convertit en une valeur entière. La représentation valide d'un nombre entier se compose des parties suivantes :

• (optionnel) signe plus ou moins
• (optionnel) préfixe (0) indiquant la base octale (s'applique uniquement lorsque la base est 8 ou 0)
• (optionnel) préfixe (0x ou 0X) indiquant la base hexadécimale (s'applique uniquement lorsque la base est 16 ou 0)
• une séquence de chiffres

L'ensemble des valeurs valides pour la base est {0, 2, 3, ..., 36}. L'ensemble des chiffres valides pour les entiers en base-2 est {0, 1}, pour les entiers en base-3 est {0, 1, 2}, et ainsi de suite. Pour les bases supérieures à 10, les chiffres valides incluent les caractères alphabétiques, en commençant par Aa pour l'entier en base-11, jusqu'à Zz pour l'entier en base-36. La casse des caractères est ignorée.

Des formats numériques supplémentaires peuvent être acceptés par la locale C actuellement installée.

Si la valeur de base est 0, la base numérique est détectée automatiquement : si le préfixe est 0, la base est octale, si le préfixe est 0x ou 0X, la base est hexadécimale, sinon la base est décimale.

Si le signe moins faisait partie de la séquence d'entrée, la valeur numérique calculée à partir de la séquence de chiffres est niée comme par moins unaire dans le type résultat.

Si pos n'est pas un pointeur nul, alors ptr recevra l'adresse du premier caractère non converti dans str.c_str(), et l'index de ce caractère sera calculé et stocké dans *pos, donnant le nombre de caractères qui ont été traités par la conversion.

Paramètres

Valeur de retour

Valeur entière correspondant au contenu de str .

Exceptions

• std::invalid_argument si aucune conversion n'a pu être effectuée.
• std::out_of_range si la valeur convertie sortirait de la plage du type de résultat ou si la fonction sous-jacente ( std::strtol ou std::strtoll ) définit errno à ERANGE .

Exemple

#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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi