std::unexpected
| 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 avec std::unexpected comme argument unique, qui créent 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.
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
,
|
(5) | |
Construit un objet
std::unexpected
.
E
à partir de
std::
forward
<
Err
>
(
e
)
.
-
Cette surcharge participe à la résolution de surcharge seulement si
- std:: is_same_v < std:: remove_cvref_t < Err > , unexpected > est faux, et
- std:: is_same_v < std:: remove_cvref_t < Err > , std:: in_place_t > est faux, et
- std:: is_constructible_v < E, Err > est vrai.
E
à partir des arguments
std::
forward
<
Args
>
(
args
)
...
.
- Cette surcharge participe à la résolution de surcharge seulement si std:: is_constructible_v < E, Args... > est vrai.
E
à partir des arguments
il,
std::
forward
<
Args
>
(
args
)
...
.
- Cette surcharge participe à la résolution de surcharge seulement si std:: is_constructible_v < E, std:: initializer_list < U > & , Args... > est vrai.
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
;
|
||
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
#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) |