Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Dienstprogrammbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Dienstprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Drei-Wege-Vergleich
    (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)

    Allgemeine Dienstprogramme
    Relationale Operatoren (veraltet in C++20)
    Ganzzahlvergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabeltypen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::expected
     
    constexpr expected& operator=( const expected& other );
    		(1) (seit C++23) 
    constexpr expected& operator=( expected&& other ) noexcept(/*see below*/);
    		(2) (seit C++23) 
    template< class U = std::remove_cv_t<T> >
constexpr expected& operator=( U&& v );
    		(3) (seit C++23)
    (T ist nicht cv void)    		 
    template< class G >
constexpr expected& operator=( const unexpected<G>& other );
    		(4) (seit C++23) 
    template< class G >
constexpr expected& operator=( unexpected<G>&& other );
    		(5) (seit C++23)

    Weist einem vorhandenen expected-Objekt einen neuen Wert zu.

    1,2) Weist den Zustand von other zu.
    • Wenn this->has_value() gleich other.has_value() ist, wird der in other enthaltene Wert zugewiesen. Tut nichts, wenn T (möglicherweise cv-qualifiziert) void ist und other.has_value() true ist.
    • Andernfalls wird der aktuell enthaltene Wert zerstört (tut nichts, wenn this->has_value() true ist und T (möglicherweise cv-qualifiziert) void ist), und *this erhält eine Kopie des in other enthaltenen Werts.
    Wenn other.has_value() true ist und T (möglicherweise cv-qualifiziert) void ist, wird der neue Wert nicht konstruiert. Andernfalls wird der neue Wert kopierkonstruiert (1) oder verschiebungskonstruiert (2) von *other oder other.error(), je nachdem. Wenn eine Ausnahme ausgelöst wird, bleibt der alte Wert erhalten; *this wird nicht wertlos.

    Wenn keine Ausnahme ausgelöst wurde, ist nach der Zuweisung has_value() gleich other.has_value().

    • Überladung (1) ist als gelöscht definiert, sofern nicht
      • entweder T (möglicherweise cv-qualifiziert) void ist oder std::is_copy_assignable_v<T> true ist, und
      • entweder T (möglicherweise cv-qualifiziert) void ist oder std::is_copy_constructible_v<T> true ist, und
      • std::is_copy_assignable_v<E> true ist, und
      • std::is_copy_constructible_v<E> true ist, und
      • mindestens eine der folgenden Bedingungen true ist:
        • T ist (möglicherweise cv-qualifiziert) void
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>
    • Überladung (2) nimmt nur an der Überladungsauflösung teil, wenn
      • entweder T (möglicherweise cv-qualifiziert) void ist oder std::is_move_assignable_v<T> true ist, und
      • entweder T (möglicherweise cv-qualifiziert) void ist oder std::is_move_constructible_v<T> true ist, und
      • std::is_move_assignable_v<E> true ist, und
      • std::is_move_constructible_v<E> true ist, und
      • mindestens eine der folgenden Bedingungen true ist:
        • T ist (möglicherweise cv-qualifiziert) void
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>
    3) Weist vom erwarteten Wert zu.
    • Wenn this->has_value() true ist, äquivalent zu **this = std::forward<U>(v).
    • Andernfalls zerstört den in *this enthaltenen Wert und lässt *this einen mit std::forward<U>(v) initialisierten Wert enthalten. Wenn eine Ausnahme ausgelöst wird, bleibt der alte Wert erhalten; *this wird nicht wertlos.

    Wenn keine Ausnahme ausgelöst wurde, ist nach der Zuweisung this->has_value() true.

    • Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn
      • std::is_same_v<expected, std::remove_cvref_t<U>> false ist, und
      • std::remove_cvref_t<U> keine Spezialisierung von std::unexpected ist, und
      • std::is_constructible_v<T, U> true ist, und
      • std::is_assignable_v<T&, U> true ist, und
      • mindestens eine der folgenden Bedingungen true ist:
        • std::is_nothrow_constructible_v<T, U>
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>
    4,5) Weist vom unerwarteten Wert zu.

    Sei GF const G& für Überladung (4) und G für Überladung (5).

    • Wenn this->has_value() true ist, zerstört den in *this enthaltenen Wert (tut nichts, wenn T (möglicherweise cv-qualifiziert) void ist) und lässt *this einen mit std::forward<GF>(e.error()) initialisierten Wert enthalten. Wenn eine Ausnahme ausgelöst wird, bleibt der alte Wert erhalten; *this wird nicht wertlos.
    • Andernfalls äquivalent zu this->error() = std::forward<GF>(e.error()).

    Wenn keine Ausnahme ausgelöst wurde, ist nach der Zuweisung this->has_value() false.

    • Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn
      • std::is_constructible_v<E, GF> true ist, und
      • std::is_assignable_v<E&, GF> true ist, und
      • mindestens eine der folgenden Bedingungen true ist:
        • T ist (möglicherweise cv-qualifiziert) void
        • std::is_nothrow_constructible_v<E, GF>
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>


    In allen Fällen, wenn T nicht (möglicherweise cv-qualifiziert) void ist, werden die Zerstörung des alten Werts und die Konstruktion des neuen Werts wie durch die folgende, nur zur Darstellung dienende Funktion reinit_expected durchgeführt. 

    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;
        }
    }
}

    Parameter

    other - ein weiteres expected -Objekt, dessen enthaltene Werte zugewiesen werden sollen
    v - Wert, der dem enthaltenen Wert zugewiesen werden soll
    e - std::unexpected -Objekt, dessen enthaltene Werte zugewiesen werden sollen
    newval - der zu konstruierende enthaltene Wert
    oldval - der zu zerstörende enthaltene Wert
    args - die als Initialisierer für newval verwendeten Argumente

    Rückgabewert

    1-9) * this

    Exceptions

    2)
    noexcept Spezifikation:
    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 Spezifikation:
    noexcept ( std:: is_nothrow_move_constructible_v < E > && std:: is_nothrow_move_assignable_v < E > )

    Beispiel

    Dieser Abschnitt ist unvollständig
    Grund: Kein Beispiel

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 3886 C++23 das Standard-Template-Argument von Überladung ( 3 ) war T geändert zu std:: remove_cv_t < T >
    LWG 4025 C++23 Überladung ( 7 ) war als gelöscht definiert, wenn E nicht
    move-konstruierbar oder nicht move-zuweisbar ist     		sie nimmt in diesem Fall nicht an der
    Überladungsauflösung teil

    Siehe auch

    		Konstruiert den erwarteten Wert direkt vor Ort
    (öffentliche Mitgliedsfunktion)