Namespaces
Variants

std:: unexpected

From cppreference.net
C++
Utilities library
std::expected
Défini dans l'en-tête <expected>
template < class E >
class unexpected ;
(depuis C++23)

Le modèle de classe std::unexpected représente une valeur inattendue stockée dans std::expected . En particulier, std::expected possède des constructeurs prenant std::unexpected comme unique argument, ce qui crée un objet expected contenant une valeur inattendue.

Un programme est mal formé s'il instancie un unexpected avec un type non-objet, un type tableau, une spécialisation de std::unexpected , ou un type qualifié cv.

Table des matières

Paramètres du modèle

E - le type de la valeur inattendue. Le type ne doit pas être un type tableau, un type non-objet, une spécialisation de std::unexpected , ou un type avec qualificatifs cv.

Fonctions membres

construit l'objet unexpected
(fonction membre publique)
(destructeur)
(déclaré implicitement)
détruit l'objet unexpected ainsi que la valeur stockée
(fonction membre publique)
operator=
(déclaré implicitement)
assigne la valeur stockée
(fonction membre publique)
accède à la valeur stockée
(fonction membre publique)
échange la valeur stockée
(fonction membre publique)

Fonctions non membres

(C++23)
compare la valeur stockée
(modèle de fonction)
(C++23)
spécialise l'algorithme std::swap
(modèle de fonction)

std::unexpected:: unexpected

constexpr unexpected ( const unexpected & ) = default ;
(1)
constexpr unexpected ( unexpected && ) = default ;
(2)
template < class Err = E >
constexpr explicit unexpected ( Err && e ) ;
(3)
template < class ... Args >
constexpr explicit unexpected ( std:: in_place_t , Args && ... args ) ;
(4)
template < class U, class ... Args >

constexpr explicit unexpected ( std:: in_place_t ,

std:: initializer_list < U > il, Args && ... args ) ;
(5)

Construit un objet std::unexpected .

1,2) Constructeur de copie/déplacement. Copie ou déplace la valeur stockée, respectivement.
3) Construit la valeur stockée, comme en initialisant directement une valeur de type E à partir de std:: forward < Err > ( e ) .
4) Construit la valeur stockée, comme si en initialisant directement une valeur de type E à partir des arguments std:: forward < Args > ( args ) ... .
5) Construit la valeur stockée, comme si en initialisant directement une valeur de type E à partir des arguments il, std:: forward < Args > ( args ) ... .

Paramètres

e - valeur avec laquelle initialiser la valeur contenue
args... - arguments avec lesquels initialiser la valeur contenue
il - liste d'initialisation avec laquelle initialiser la valeur contenue

Exceptions

Lance toute exception levée par le constructeur de E .

std::unexpected:: error

constexpr const E & error ( ) const & noexcept ;

constexpr E & error ( ) & noexcept ;
constexpr const E && error ( ) const && noexcept ;

constexpr E && error ( ) && noexcept ;

Retourne une référence à la valeur stockée.

std::unexpected:: swap

constexpr void swap ( unexpected & other ) noexcept ( std:: is_nothrow_swappable_v < E > ) ;

Échange les valeurs stockées, comme par using std:: swap ; swap ( error ( ) , other. error ( ) ) ; .

Le programme est mal formé si std:: is_swappable_v < E > est faux.

operator== (std::unexpected)

template < class E2 >
friend constexpr bool operator == ( unexpected & x, std :: unexpected < E2 > & y ) ;

Compare les valeurs stockées, comme par return x. error ( ) == y. error ( ) .

Si l'expression x. error ( ) == e. error ( ) n'est pas bien formée, ou si son résultat n'est pas convertible en bool , le programme est mal formé.

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

swap (std::unexpected)

friend constexpr void
swap ( unexpected & x, unexpected & y ) noexcept ( noexcept ( x. swap ( y ) ) ) ;

Équivalent à x. swap ( y ) .

Cette surcharge participe à la résolution de surcharge seulement si std:: is_swappable_v < E > est vrai.

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

Guides de déduction

template < class E >
unexpected ( E ) - > unexpected < E > ;
(depuis C++23)

Le guide de déduction est fourni pour unexpected afin de permettre la déduction à partir de l'argument du constructeur.

Notes

Avant C++17, le nom std::unexpected désignait la fonction appelée par l'environnement d'exécution C++ lorsqu'une spécification d'exception dynamique était violée.

Exemple

Exécuter ce code 
#include <expected>
#include <iostream>
enum class error
{
    compile_time_error,
    runtime_error
};
[[nodiscard]] auto unexpected_runtime_error() -> std::expected<int, error>
{
    return std::unexpected(error::runtime_error);
}
int main()
{
    std::expected<double, int> ex = std::unexpected(3);
    if (!ex)
        std::cout << "ex contient une valeur d'erreur\n";
    if (ex == std::unexpected(3))
        std::cout << "La valeur d'erreur est égale à 3\n";
    const auto e = unexpected_runtime_error();
    e.and_then([](const auto& e) -> std::expected<int, error>
    {
        std::cout << "and_then: " << int(e); // non affiché
        return {};
    })
    .or_else([](const auto& e) -> std::expected<int, error>
    {
        std::cout << "or_else: " << int(e); // affiche cette ligne
        return {};
    });
}

Sortie : 

ex contient une valeur d'erreur
La valeur d'erreur est égale à 3
or_else: 1

Voir aussi

construit l'objet expected
(fonction membre publique)
retourne la valeur attendue
(fonction membre publique)
échange le contenu
(fonction membre publique)
(C++23)
spécialise l'algorithme std::swap
(fonction)
(C++23)
compare les objets expected
(modèle de fonction)