Namespaces
Variants

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

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Indépendant 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 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
     
    Bibliothèque d'utilitaires
    Support linguistique
    Support des types (types de base, RTTI)
    Macros de test de fonctionnalités de la bibliothèque (C++20)
    Utilitaires de programme
    Fonctions variadiques
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Support des coroutines (C++20)
    Support des contrats (C++26)
    Comparaison à trois voies
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilitaires généraux
    Opérateurs relationnels (déprécié en C++20)
     
    std::expected
     
    constexpr expected& operator=( const expected& other );
    		(1) (depuis C++23) 
    constexpr expected& operator=( expected&& other ) noexcept(/*see below*/);
    		(2) (depuis C++23) 
    template< class U = std::remove_cv_t<T> >
constexpr expected& operator=( U&& v );
    		(3) (depuis C++23)
    (T n'est pas cv void)    		 
    template< class G >
constexpr expected& operator=( const unexpected<G>& other );
    		(4) (depuis C++23) 
    template< class G >
constexpr expected& operator=( unexpected<G>&& other );
    		(5) (depuis C++23)

    Assigne une nouvelle valeur à un objet expected existant.

    1,2) Assigne l'état de other.
    • Si this->has_value() est égal à other.has_value(), assigne la valeur contenue dans other. Ne fait rien si T est (éventuellement qualifié cv) void et que other.has_value() est true.
    • Sinon, détruit la valeur actuellement contenue (ne fait rien si this->has_value() est true et que T est (éventuellement qualifié cv) void), et fait en sorte que *this contienne une copie de la valeur contenue dans other.
    Si other.has_value() est true et que T est (éventuellement qualifié cv) void, ne construit pas la nouvelle valeur. Sinon, la nouvelle valeur est construite par copie (1) ou par déplacement (2) à partir de *other ou other.error(), selon le cas. Si une exception est levée, l'ancienne valeur est conservée ; *this ne devient pas sans valeur.

    Si aucune exception n'a été levée, après l'affectation, has_value() est égal à other.has_value().

    • La surcharge (1) est définie comme supprimée sauf si
      • soit T est (éventuellement qualifié cv) void ou std::is_copy_assignable_v<T> est true, et
      • soit T est (éventuellement qualifié cv) void ou std::is_copy_constructible_v<T> est true, et
      • std::is_copy_assignable_v<E> est true, et
      • std::is_copy_constructible_v<E> est true, et
      • au moins une des conditions suivantes est true :
        • T est (éventuellement qualifié cv) void
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>
    • La surcharge (2) participe à la résolution de surcharge uniquement si
      • soit T est (éventuellement qualifié cv) void ou std::is_move_assignable_v<T> est true, et
      • soit T est (éventuellement qualifié cv) void ou std::is_move_constructible_v<T> est true, et
      • std::is_move_assignable_v<E> est true, et
      • std::is_move_constructible_v<E> est true, et
      • au moins une des conditions suivantes est true :
        • T est (éventuellement qualifié cv) void
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>
    3) Assigne à partir d'une valeur attendue.
    • Si this->has_value() est true, équivaut à **this = std::forward<U>(v).
    • Sinon, détruit la valeur contenue dans *this, et fait en sorte que *this contienne une valeur initialisée à partir de std::forward<U>(v). Si une exception est levée, l'ancienne valeur est conservée ; *this ne devient pas sans valeur.

    Si aucune exception n'a été levée, après l'affectation, this->has_value() est true.

    • Cette surcharge participe à la résolution de surcharge uniquement si
      • std::is_same_v<expected, std::remove_cvref_t<U>> est false, et
      • std::remove_cvref_t<U> n'est pas une spécialisation de std::unexpected, et
      • std::is_constructible_v<T, U> est true, et
      • std::is_assignable_v<T&, U> est true, et
      • au moins une des conditions suivantes est true :
        • std::is_nothrow_constructible_v<T, U>
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>
    4,5) Assigne à partir d'une valeur inattendue.

    Soit GF const G& pour la surcharge (4), et G pour la surcharge (5).

    • Si this->has_value() est true, détruit la valeur contenue dans *this (ne fait rien si T est (éventuellement qualifié cv) void), et fait en sorte que *this contienne une valeur initialisée à partir de std::forward<GF>(e.error()). Si une exception est levée, l'ancienne valeur est conservée ; *this ne devient pas sans valeur.
    • Sinon, équivaut à this->error() = std::forward<GF>(e.error()).

    Si aucune exception n'a été levée, après l'affectation, this->has_value() est false.

    • Cette surcharge participe à la résolution de surcharge uniquement si
      • std::is_constructible_v<E, GF> est true, et
      • std::is_assignable_v<E&, GF> est true, et
      • au moins une des conditions suivantes est true :
        • T est (éventuellement qualifié cv) void
        • std::is_nothrow_constructible_v<E, GF>
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>


    Dans tous les cas, si T n'est pas (éventuellement qualifié cv) void, la destruction de l'ancienne valeur et la construction de la nouvelle valeur sont effectuées comme par la fonction d'exposition suivante reinit_expected. 

    template<class NewType, class OldType, class... Args>
constexpr void reinit_expected(NewType& new_val, OldType& old_val, Args&&... args)
{
    if constexpr (std::is_nothrow_constructible_v<NewType, Args...>)
    {
        std::destroy_at(std::addressof(old_val));
        std::construct_at(std::addressof(new_val), std::forward<Args>(args)...);
    }
    else if constexpr (std::is_nothrow_move_constructible_v<NewType>)
    {
        NewType temp(std::forward<Args>(args)...); // may throw
        std::destroy_at(std::addressof(old_val));
        std::construct_at(std::addressof(new_val), std::move(temp));
    }
    else
    {
        OldType temp(std::move(old_val));
        std::destroy_at(std::addressof(old_val));
        try
        {
            std::construct_at(std::addressof(new_val), std::forward<Args>(args)...); // may throw
        }
        catch (...)
        {
            std::construct_at(std::addressof(old_val), std::move(temp));
            throw;
        }
    }
}

    Paramètres

    other - autre objet expected dont la valeur contenue doit être assignée
    v - valeur à assigner à la valeur contenue
    e - std::unexpected objet dont la valeur contenue doit être assignée
    newval - la valeur contenue à construire
    oldval - la valeur contenue à détruire
    args - les arguments utilisés comme initialiseurs de newval

    Valeur de retour

    1-9) * this

    Exceptions

    2)
    noexcept spécification :
    noexcept (

    std:: is_nothrow_move_constructible_v < T > && std:: is_nothrow_move_assignable_v < T > &&

    std:: is_nothrow_move_constructible_v < E > && std:: is_nothrow_move_assignable_v < E > )
    7)
    noexcept spécification :
    noexcept ( std:: is_nothrow_move_constructible_v < E > && std:: is_nothrow_move_assignable_v < E > )

    Exemple

    Cette section est incomplète
    Raison : aucun 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 ( 3 ) était T modifié en std:: remove_cv_t < T >
    LWG 4025 C++23 la surcharge ( 7 ) était définie comme supprimée si E n'est
    pas constructible par déplacement ou pas assignable par déplacement     		elle ne participe pas à la
    résolution de surcharge dans ce cas

    Voir aussi

    		construit la valeur attendue en place
    (fonction membre publique)