std::optional<T>::operator=

optional& operator=( std::nullopt_t ) noexcept;	(1)	(depuis C++17) (constexpr depuis C++20)
constexpr optional& operator=( const optional& other );	(2)	(depuis C++17)
constexpr optional& operator=( optional&& other ) noexcept(/* see below */);	(3)	(depuis C++17)
template< class U = std::remove_cv_t<T> > optional& operator=( U&& value );	(4)	(depuis C++17) (constexpr depuis C++20)
template< class U > optional& operator=( const optional<U>& other );	(5)	(depuis C++17) (constexpr depuis C++20)
template< class U > optional& operator=( optional<U>&& other );	(6)	(depuis C++17) (constexpr depuis C++20)

Remplace le contenu de *this par le contenu de other.

1) Si *this contient une valeur avant l'appel, la valeur contenue est détruite en appelant son destructeur comme par value().T::~T(). *this ne contient pas de valeur après cet appel.

2,3) Assigne l'état de other.

Si *this et other ne contiennent ni l'un ni l'autre une valeur, la fonction n'a aucun effet.
Si *this contient une valeur, mais pas other, alors la valeur contenue est détruite en appelant son destructeur. *this ne contient pas de valeur après l'appel.
Si other contient une valeur, alors selon que *this contient une valeur ou non, la valeur contenue est soit directement initialisée soit assignée à partir de *other (2) ou de std::move(*other) (3). Notez qu'un optional déplacé contient toujours une valeur.
La surcharge (2) est supprimée lorsque std::is_copy_constructible_v<T> ou std::is_copy_assignable_v<T> est false. Elle est triviale si std::is_trivially_copy_constructible_v<T>, std::is_trivially_copy_assignable_v<T> et std::is_trivially_destructible_v<T> sont tous true.
La surcharge (3) ne participe pas à la résolution de surcharge lorsque std::is_move_constructible_v<T> ou std::is_move_assignable_v<T> est false. Elle est triviale si std::is_trivially_move_constructible_v<T>, std::is_trivially_move_assignable_v<T> et std::is_trivially_destructible_v<T> sont tous true.

4) Assignation par transfert parfait : selon si *this contient une valeur avant l'appel, la valeur contenue est soit directement initialisée à partir de std::forward(value) soit assignée à partir de std::forward(value). La fonction ne participe pas à la résolution de surcharge à moins que std::decay_t(jusqu'à C++20)std::remove_cvref_t(depuis C++20) ne soit pas std::optional<T>, que std::is_constructible_v<T, U> soit true, que std::is_assignable_v<T&, U> soit true, et qu'au moins une des conditions suivantes soit vraie :

T n'est pas un type scalaire ;
std::decay_t n'est pas T.

5,6) Assigne l'état de other.

Si *this et other ne contiennent ni l'un ni l'autre une valeur, la fonction n'a aucun effet.
Si *this contient une valeur, mais pas other, alors la valeur contenue est détruite en appelant son destructeur. *this ne contient pas de valeur après l'appel.
Si other contient une valeur, alors selon que *this contient une valeur ou non, la valeur contenue est soit directement initialisée soit assignée à partir de *other (5) ou de std::move(*other) (6). Notez qu'un optional déplacé contient toujours une valeur.
Ces surcharges ne participent pas à la résolution de surcharge à moins que les conditions suivantes soient remplies :
- T n'est pas constructible, convertible ou assignable à partir d'une expression de type (éventuellement const) std::optional, c'est-à-dire que les 12 traits de type suivants sont tous false :
 - std::is_constructible_v<T, std::optional&>
 - std::is_constructible_v<T, const std::optional&>
 - std::is_constructible_v<T, std::optional&&>
 - std::is_constructible_v<T, const std::optional&&>
 - std::is_convertible_v<std::optional&, T>
 - std::is_convertible_v<const std::optional&, T>
 - std::is_convertible_v<std::optional&&, T>
 - std::is_convertible_v<const std::optional&&, T>
 - std::is_assignable_v<T&, std::optional&>
 - std::is_assignable_v<T&, const std::optional&>
 - std::is_assignable_v<T&, std::optional&&>
 - std::is_assignable_v<T&, const std::optional&&>
- Pour la surcharge (5), std::is_constructible_v<T, const U&> et std::is_assignable_v<T&, const U&> sont tous deux true.
- Pour la surcharge (6), std::is_constructible_v<T, U> et std::is_assignable_v<T&, U> sont tous deux true.

Paramètres

other	-	autre objet `optional` dont la valeur contenue doit être assignée
value	-	valeur à assigner à la valeur contenue

Valeur de retour

* this

Exceptions

2-6) Lance toute exception levée par le constructeur ou l'opérateur d'affectation de

. Si une exception est levée, l'état d'initialisation de * this (et de other dans le cas de ( 2-5 ) ) reste inchangé, c'est-à-dire que si l'objet contenait une valeur, il contient toujours une valeur, et vice versa. Le contenu de value et les valeurs contenues de * this et other dépendent des garanties de sécurité face aux exceptions de l'opération à l'origine de l'exception (constructeur de copie, affectation de déplacement, etc.).

3) Possède la spécification

noexcept suivante :

noexcept ( std:: is_nothrow_move_assignable_v < T > &&
std:: is_nothrow_move_constructible_v < T > )

Notes

Un objet optionnel op peut être transformé en un optionnel vide avec à la fois op = { } ; et op = nullopt ; . La première expression construit un objet optional vide avec { } et l'assigne à op .

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
`__cpp_lib_optional`	`202106L`	(C++20) (DR20)	Entièrement constexpr ( 1 ) , ( 4-6 )

Exemple

Exécuter ce code

#include <iostream>
#include <optional>
int main()
{
    std::optional<const char*> s1 = "abc", s2; // constructeur
    s2 = s1; // assignation
    s1 = "def"; // assignation avec décroissance (U = char[4], T = const char*)
    std::cout << *s2 << ' ' << *s1 << '\n';
}

Sortie :

abc def

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	Appliqué à	Comportement publié	Comportement corrigé
LWG 3886	C++17	l'argument template par défaut de la surcharge ( 6 ) était `T`	modifié en std:: remove_cv_t < T >
P0602R4	C++17	l'opérateur d'affectation par copie/déplacement peut ne pas être trivial même si les opérations sous-jacentes sont triviales	requis pour propager la trivialité
P2231R1	C++20	les surcharges ( 1,4-6 ) n'étaient pas constexpr	rendues constexpr

Voir aussi

emplace

construit la valeur contenue en place
(fonction membre publique)

Support du compilateur
Libre et hébergé
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 diagnostics
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 heure
Bibliothèque d'entrée/sortie
Bibliothèque du 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
optional::optional
optional::~optional
optional::operator=
Observateurs
optional::operator->optional::operator*
optional::operator booloptional::has_value
optional::value
optional::value_or
Itérateurs
optional::begin (C++26)
optional::end (C++26)
Opérations monadiques
optional::and_then (C++23)
optional::transform (C++23)
optional::or_else (C++23)
Modificateurs
optional::emplace
optional::swap
optional::reset
Fonctions non membres
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)
make_optional
swap(std::optional)
Guides de déduction
Classes auxiliaires
hash<std::optional>
nullopt_t
in_place_t
bad_optional_access
Objets auxiliaires
nullopt
in_place

fr.cppreference.net

Namespaces

Variants