std:: from_chars

Analiza la secuencia de caracteres [ first , last ) para un patrón descrito a continuación. Si ningún carácter coincide con el patrón o si el valor obtenido al analizar los caracteres coincidentes no es representable en el tipo de value , value permanece sin modificar; de lo contrario, los caracteres que coinciden con el patrón se interpretan como una representación textual de un valor aritmético, que se almacena en value .

Parámetros

Valor de retorno

En caso de éxito, retorna un valor de tipo std::from_chars_result tal que ptr apunta al primer carácter que no coincide con el patrón, o tiene el valor igual a last si todos los caracteres coinciden y ec está inicializado por defecto.

Si no hay coincidencia de patrón, retorna un valor de tipo std::from_chars_result tal que ptr es igual a first y ec es igual a std::errc::invalid_argument . value no se modifica.

Si el patrón fue coincidido, pero el valor analizado no está en el rango representable por el tipo de value , retorna un valor de tipo std::from_chars_result tal que ec es igual a std::errc::result_out_of_range y ptr apunta al primer carácter que no coincide con el patrón. value permanece sin modificar.

Excepciones

No lanza nada.

Notas

A diferencia de otras funciones de análisis en bibliotecas de C++ y C, std::from_chars es independiente de la configuración regional, no realiza asignaciones de memoria y no lanza excepciones. Solo se proporciona un pequeño subconjunto de políticas de análisis utilizadas por otras bibliotecas (como std::sscanf ). Esto está diseñado para permitir la implementación más rápida posible que sea útil en contextos comunes de alto rendimiento como el intercambio basado en texto ( JSON o XML ).

La garantía de que std::from_chars puede recuperar cada valor de punto flotante formateado por std::to_chars exactamente solo se proporciona si ambas funciones son de la misma implementación.

Un patrón que consiste en un signo sin dígitos siguientes se trata como un patrón que no coincidió con nada.

Ejemplo

#include <cassert>
#include <charconv>
#include <iomanip>
#include <iostream>
#include <optional>
#include <string_view>
#include <system_error>
int main()
{
    for (std::string_view const str : {"1234", "15 foo", "bar", " 42", "5000000000"})
    {
        std::cout << "String: " << std::quoted(str) << ". ";
        int result{};
        auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), result);
        if (ec == std::errc())
            std::cout << "Result: " << result << ", ptr -> " << std::quoted(ptr) << '\n';
        else if (ec == std::errc::invalid_argument)
            std::cout << "This is not a number.\n";
        else if (ec == std::errc::result_out_of_range)
            std::cout << "This number is larger than an int.\n";
    }
    // C++23's constexpr from_char demo / C++26's operator bool() demo:
    auto to_int = [](std::string_view s) -> std::optional<int>
    {
        int value{};
#if __cpp_lib_to_chars >= 202306L
        if (std::from_chars(s.data(), s.data() + s.size(), value))
#else
        if (std::from_chars(s.data(), s.data() + s.size(), value).ec == std::errc{})
#endif
            return value;
        else
            return std::nullopt;
    };
    assert(to_int("42") == 42);
    assert(to_int("foo") == std::nullopt);
#if __cpp_lib_constexpr_charconv and __cpp_lib_optional >= 202106
    static_assert(to_int("42") == 42);
    static_assert(to_int("foo") == std::nullopt);
#endif
}

String: "1234". Result: 1234, ptr -> ""
String: "15 foo". Result: 15, ptr -> " foo"
String: "bar". This is not a number.
String: " 42". This is not a number.
String: "5000000000". This number is larger than an int.

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