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

Interpreta un valor entero con signo en la cadena str.

Sea ptr un puntero interno (para las funciones de conversión) de tipo char* (1,3,5) o wchar_t* (2,4,6), según corresponda.

Descarta cualquier carácter de espacio en blanco (identificado llamando a std::isspace) hasta que se encuentra el primer carácter que no sea espacio en blanco, luego toma tantos caracteres como sea posible para formar una representación válida de un número entero en base n (donde n=base) y los convierte a un valor entero. La representación válida del número entero consta de las siguientes partes:

• (opcional) signo más o menos
• (opcional) prefijo (0) que indica base octal (aplica solo cuando la base es 8 o 0)
• (opcional) prefijo (0x o 0X) que indica base hexadecimal (aplica solo cuando la base es 16 o 0)
• una secuencia de dígitos

El conjunto de valores válidos para la base es {0, 2, 3, ..., 36}. El conjunto de dígitos válidos para enteros en base 2 es {0, 1}, para enteros en base 3 es {0, 1, 2}, y así sucesivamente. Para bases mayores que 10, los dígitos válidos incluyen caracteres alfabéticos, comenzando desde Aa para enteros en base 11, hasta Zz para enteros en base 36. No se distingue entre mayúsculas y minúsculas.

La configuración regional C actualmente instalada puede aceptar formatos numéricos adicionales.

Si el valor de base es 0, la base numérica se detecta automáticamente: si el prefijo es 0, la base es octal; si el prefijo es 0x o 0X, la base es hexadecimal; de lo contrario, la base es decimal.

Si el signo menos formaba parte de la secuencia de entrada, el valor numérico calculado a partir de la secuencia de dígitos se niega como si se aplicara el menos unario en el tipo de resultado.

Si pos no es un puntero nulo, entonces ptr recibirá la dirección del primer carácter no convertido en str.c_str(), y el índice de ese carácter se calculará y almacenará en *pos, dando el número de caracteres que fueron procesados por la conversión.

Parámetros

Valor de retorno

Valor entero correspondiente al contenido de str .

Excepciones

• std::invalid_argument si no se pudo realizar ninguna conversión.
• std::out_of_range si el valor convertido caería fuera del rango del tipo de resultado o si la función subyacente ( std::strtol o std::strtoll ) establece errno a ERANGE .

Ejemplo

#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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también