std::expected<T,E>::expected

constexpr expected();	(1)	(depuis C++23)
constexpr expected( const expected& other );	(2)	(depuis C++23)
constexpr expected( expected&& other ) noexcept(/* see below */);	(3)	(depuis C++23)
template< class U, class G > constexpr explicit(/* see below */) expected( const expected<U, G>& other );	(4)	(depuis C++23)
template< class U, class G > constexpr explicit(/* see below */) expected( expected<U, G>&& other );	(5)	(depuis C++23)
template< class U = std::remove_cv_t<T> > constexpr explicit(!std::is_convertible_v<U, T>) expected( U&& v );	(6)	(depuis C++23) (T n'est pas cv void)
template< class G > constexpr explicit(!std::is_convertible_v<const G&, E>) expected( const std::unexpected<G>& e );	(7)	(depuis C++23)
template< class G > constexpr explicit(!std::is_convertible_v<G, E>) expected( std::unexpected<G>&& e );	(8)	(depuis C++23)
template< class... Args > constexpr explicit expected( std::in_place_t, Args&&... args );	(9)	(depuis C++23) (T n'est pas cv void)
template< class U, class... Args > constexpr explicit expected( std::in_place_t, std::initializer_list<U> il, Args&&... args );	(10)	(depuis C++23) (T n'est pas cv void)
constexpr explicit expected( std::in_place_t ) noexcept;	(11)	(depuis C++23) (T est cv void)
template< class... Args > constexpr explicit expected( std::unexpect_t, Args&&... args );	(12)	(depuis C++23)
template< class U, class... Args > constexpr explicit expected( std::unexpect_t, std::initializer_list<U> il, Args&&... args );	(13)	(depuis C++23)

Construit un nouvel objet expected.

1) Constructeur par défaut. Si T n'est pas (éventuellement qualifié cv) void, construit un objet qui contient une valeur attendue, qui est initialisée par valeur.

Après construction, has_value() renvoie true.

Cette surcharge participe à la résolution de surcharge uniquement si T est (éventuellement qualifié cv) void ou std::is_default_constructible_v<T> est true.

2) Constructeur de copie. Si other.has_value() est false, le nouvel objet contient une valeur inattendue, qui est initialisée directement à partir de other.error(). Sinon, si T n'est pas (éventuellement qualifié cv) void, le nouvel objet contient une valeur attendue, qui est initialisée directement à partir de *other.

Après construction, has_value() est égal à other.has_value().

Ce constructeur est défini comme supprimé sauf si

soit T est (éventuellement qualifié cv) void, soit std::is_copy_constructible_v<T> est true, et
std::is_copy_constructible_v<E> est true.

Ce constructeur est trivial si

soit T est (éventuellement qualifié cv) void, soit std::is_trivially_copy_constructible_v<T> est true, et
std::is_trivially_copy_constructible_v<E> est true.

3) Constructeur de déplacement. Si other.has_value() est false, le nouvel objet contient une valeur inattendue, qui est initialisée directement à partir de std::move(other.error()). Sinon, si T n'est pas (éventuellement qualifié cv) void, le nouvel objet contient une valeur attendue, qui est initialisée directement à partir de std::move(*other).

Après construction, has_value() est égal à other.has_value().

Ce constructeur participe à la résolution de surcharge uniquement si

soit T est (éventuellement qualifié cv) void, soit std::is_move_constructible_v<T> est true, et
std::is_move_constructible_v<E> est true.

Ce constructeur est trivial si

std::is_trivially_move_constructible_v<T> est true, et
std::is_trivially_move_constructible_v<E> est true.

4,5) Soient

UF soit std::add_lvalue_reference_t<const U> pour (4) et U pour (5), et
GF soit const G& pour (4) et G pour (5).

Si other.has_value() est false, le nouvel objet contient une valeur inattendue, qui est initialisée directement à partir de std::forward<GF>(other.error()). Sinon, si T n'est pas (éventuellement qualifié cv) void, le nouvel objet contient une valeur attendue, qui est initialisée directement à partir de std::forward<UF>(*other).

Après construction, has_value() est égal à other.has_value().

Chacun de ces constructeurs ne participe pas à la résolution de surcharge sauf si les conditions suivantes sont respectivement remplies :

Soit
- T est (éventuellement qualifié cv) void, et std::is_void_v est true, ou
- std::is_constructible_v<T, UF> est true.
std::is_constructible_v<E, GF> est true.
Si T n'est pas (éventuellement qualifié cv) bool, T n'est pas constructible ou convertible à partir d'une expression de type (éventuellement const) std::expected<U, G>, c'est-à-dire que les 8 valeurs suivantes sont toutes false :
- std::is_constructible_v<T, std::expected<U, G>&
- std::is_constructible_v<T, std::expected<U, G>
- std::is_constructible_v<T, const std::expected<U, G>&
- std::is_constructible_v<T, const std::expected<U, G>
- std::is_convertible_v<std::expected<U, G>&, T>
- std::is_convertible_v<std::expected<U, G>, T>
- std::is_convertible_v<const std::expected<U, G>&, T>
- std::is_convertible_v<const std::expected<U, G>, T>
std::unexpected<E> n'est pas constructible à partir d'une expression de type (éventuellement const) std::expected<U, G>, c'est-à-dire que les 4 valeurs suivantes sont toutes false :
- std::is_constructible_v<std::unexpected<E>, std::expected<U, G>&
- std::is_constructible_v<std::unexpected<E>, std::expected<U, G>
- std::is_constructible_v<std::unexpected<E>, const std::expected<U, G>&
- std::is_constructible_v<std::unexpected<E>, const std::expected<U, G>

Ces constructeurs sont explicit si std::is_convertible_v<UF, T> ou std::is_convertible_v<GF, E> est false.

6) Construit un objet qui contient une valeur attendue, initialisée comme si initialisant directement (mais pas par initialisation de liste directe) un objet de type T avec l'expression std::forward(v).

Après construction, has_value() renvoie true.

Ce constructeur ne participe pas à la résolution de surcharge sauf si les conditions suivantes sont remplies :

T n'est pas (éventuellement qualifié cv) void.
std::is_same_v<std::remove_cvref_t, std::in_place_t> est false.
std::is_same_v<expected, std::remove_cvref_t> est false.
std::is_constructible_v<T, U> est true.
std::remove_cvref_t n'est pas une spécialisation de std::unexpected.
Si T est (éventuellement qualifié cv) bool, std::remove_cvref_t n'est pas une spécialisation de std::expected.

7,8) Soit GF soit const G& pour (7) et G pour (8). Construit un objet qui contient une valeur inattendue, qui est initialisée directement à partir de std::forward<GF>(e.error()).

Après construction, has_value() renvoie false.

Ces surcharges participent à la résolution de surcharge uniquement si std::is_constructible_v<E, GF> est true.

9) Construit un objet qui contient une valeur attendue, qui est initialisée directement à partir des arguments std::forward<Args>(args)....

Après construction, has_value() renvoie true.

Cette surcharge participe à la résolution de surcharge uniquement si std::is_constructible_v<T, Args...> est true.

10) Construit un objet qui contient une valeur attendue, qui est initialisée directement à partir des arguments il, std::forward<Args>(args)....

Après construction, has_value() renvoie true.

Cette surcharge participe à la résolution de surcharge uniquement si std::is_constructible_v<T, std::initializer_list&, Args...> est true.

11) Construit un objet tel qu'après construction, has_value() renvoie true.

12) Construit un objet qui contient une valeur inattendue, qui est initialisée directement à partir des arguments std::forward<Args>(args)....

Après construction, has_value() renvoie false.

Cette surcharge participe à la résolution de surcharge uniquement si std::is_constructible_v<E, Args...> est true.

13) Construit un objet qui contient une valeur inattendue, qui est initialisée directement à partir des arguments il, std::forward<Args>(args)....

Après construction, has_value() renvoie false.

Cette surcharge participe à la résolution de surcharge uniquement si std::is_constructible_v<E, std::initializer_list&, Args...> est true.

Paramètres

other	-	autre objet `expected` dont la valeur contenue est copiée
e	-	`std::unexpected` objet dont la valeur contenue est copiée
v	-	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

Exemple

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Applicable à	Comportement publié	Comportement corrigé
LWG 3886	C++23	l'argument template par défaut de la surcharge ( 6 ) était `T`	modifié en std:: remove_cv_t < T >

Voir aussi

unexpected (C++23)	représenté comme une valeur inattendue (modèle de classe)
in_place in_place_type in_place_index in_place_t in_place_type_t in_place_index_t (C++17)	étiquette de construction en place (étiquette)
unexpect unexpect_t (C++23)	étiquette de construction en place pour la valeur inattendue dans `expected` (étiquette)

Support du compilateur
Fichiers autonomes et hébergés
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support linguistique
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostic
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et d'heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

Fonctions membres
expected::expected
expected::~expected
expected::operator=
Observateurs
expected::operator->expected::operator*
expected::operator boolexpected::has_value
expected::value
expected::error
expected::value_or
expected::error_or
Opérations monadiques
expected::and_then
expected::or_else
expected::transform
expected::transform_error
Modificateurs
expected::emplace
expected::swap
Fonctions non membres
operator==(std::expected)
swap(std::expected)
Classes auxiliaires
unexpected
bad_expected_access
unexpect_tunexpect

fr.cppreference.net

Namespaces

Variants

std::expected<T,E>::expected

Sommaire

Paramètres

Exceptions

Exemple

Rapports de défauts

Voir aussi