Namespaces
Variants

std:: from_chars_result

From cppreference.net
C++
Text processing library
Défini dans l'en-tête <charconv>
struct from_chars_result ;
(depuis C++17)

std::from_chars_result est le type de retour de std::from_chars . Il n'a pas de classes de base et ne possède que les membres suivants.

Table des matières

Membres de données

Nombre du membre Définition
ptr
un pointeur de type const char *
(objet membre public)
ec
un code d'erreur de type std::errc
(objet membre public)

Fonctions membres et amies

operator== (std::from_chars_result)

friend bool operator == ( const from_chars_result & ,
const from_chars_result & ) = default ;
(depuis C++20)

Compare les deux arguments en utilisant les comparaisons par défaut (qui utilise operator == pour comparer respectivement ptr et ec ).

Cette fonction n'est pas visible pour la recherche non qualifiée ou qualifiée ordinaire, et ne peut être trouvée que par la recherche dépendante des arguments lorsque std::from_chars_result est une classe associée des arguments.

L'opérateur != est synthétisé à partir de operator== .

operator bool

constexpr explicit operator bool ( ) const noexcept ;
(depuis C++26)

Vérifie si la conversion a réussi. Retourne ec == std:: errc { } .

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_to_chars 201611L (C++17) Conversions élémentaires de chaînes ( std::to_chars , std::from_chars )
202306L (C++26) Test de réussite ou d'échec des fonctions <charconv>

Exemple

Exécuter ce code 
#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 << "Ceci n'est pas un nombre.\n";
        else if (ec == std::errc::result_out_of_range)
            std::cout << "Ce nombre est plus grand qu'un int.\n";
    }
    // Démonstration de from_char constexpr de C++23 / Démonstration de operator bool() de C++26 :
    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
}

Sortie : 

String: "1234". Result: 1234, ptr -> ""
String: "15 foo". Result: 15, ptr -> " foo"
String: "bar". Ceci n'est pas un nombre.
String: " 42". Ceci n'est pas un nombre.
String: "5000000000". Ce nombre est plus grand qu'un int.

Voir aussi

(C++17)
convertit une séquence de caractères en une valeur entière ou à virgule flottante
(fonction)