Namespaces
Variants

std::optional<T>:: operator=

From cppreference.net
C++
Utilities library
std::optional
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 ( /* voir ci-dessous */ ) ;
(3) (depuis C++17)
template < class U >
optional & operator = ( const optional < U > & other ) ;
(4) (depuis C++17)
(constexpr depuis C++20)
template < class U >
optional & operator = ( optional < U > && other ) ;
(5) (depuis C++17)
(constexpr depuis C++20)
template < class U = std:: remove_cv_t < T > >
optional & operator = ( U && value ) ;
(6) (depuis C++17)
(constexpr depuis C++20)

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

1) Si * this contient une valeur, appelle val  - > T :: ~T ( ) pour détruire la valeur contenue ; sinon, aucun effet. * this ne contient pas de valeur après cet appel.
2-5) Assigne l'état de other . has_value() renvoie other. has_value ( ) après cet appel.
Effet * this contient une valeur * this ne contient pas de valeur
other contient une valeur
  • pour les surcharges (2,4) , assigne * other à la valeur contenue
  • pour les surcharges (3,5) , assigne std :: move ( * other ) à la valeur contenue
  • pour les surcharges (2,4) , initialise directement (non-liste) la valeur contenue avec * other
  • pour les surcharges (3,5) , initialise directement (non-liste) la valeur contenue avec std :: move ( * other )
other ne contient pas de valeur détruit la valeur contenue en appelant val  - > T :: ~T ( ) aucun effet
2) Si std:: is_copy_constructible_v < T > ou std:: is_copy_assignable_v < T > est false , l'opérateur d'affectation est défini comme supprimé.
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 , l'opérateur d'affectation est trivial.
3) Cette surcharge participe à la résolution de surcharge seulement si std:: is_move_constructible_v < T > et std:: is_move_assignable_v < T > sont tous deux true .
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 , l'opérateur d'affectation est trivial.
4,5) These overloads participate in overload resolution only if all following conditions are satisfied:
6) Si * this contient une valeur, assigne std:: forward < U > ( value ) à la valeur contenue ; sinon initialise directement (non par liste) la valeur contenue avec std:: forward < U > ( value ) . * this contient une valeur après cet appel.
Cette surcharge participe à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :
  1. ↑ En d'autres termes, T n'est pas constructible, convertible ou assignable à partir de toute expression de type (éventuellement qualifié const) std:: optional < U >

Table des matières

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 T . 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

construit la valeur contenue en place
(fonction membre publique)