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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::expected

Memberfunktionen

expected::expected

expected::~expected

expected::operator=

Observer

expected::operator->expected::operator*

expected::operator boolexpected::has_value

expected::value

expected::error

expected::value_or

expected::error_or

Monadische Operationen

expected::and_then

expected::or_else

expected::transform

expected::transform_error

Modifizierer

expected::emplace

expected::swap

Nicht-Member-Funktionen

operator==(std::expected)

swap(std::expected)

Hilfsklassen

unexpected

bad_expected_access

unexpect_tunexpect

 

Primäre Vorlage
constexpr expected& operator=( const expected& other );	(1)	(seit C++23)
constexpr expected& operator=( expected&& other )     noexcept(/* siehe unten */);	(2)	(seit C++23)
template< class U = std::remove_cv_t<T> > constexpr expected& operator=( U&& v );	(3)	(seit C++23)
template< class G > constexpr expected& operator=( const std::unexpected<G>& e );	(4)	(seit C++23)
template< class G > constexpr expected& operator=( std::unexpected<G>&& e );	(5)	(seit C++23)
void partielle Spezialisierung
constexpr expected& operator=( const expected& other );	(6)	(seit C++23)
constexpr expected& operator=( expected&& other )     noexcept(/* siehe unten */);	(7)	(seit C++23)
template< class G > constexpr expected& operator=( const std::unexpected<G>& e );	(8)	(seit C++23)
template< class G > constexpr expected& operator=( std::unexpected<G>&& e );	(9)	(seit C++23)
Hilfsfunktions-Template
template< class T, class U, class... Args > constexpr void reinit-expected( T& newval, U& oldval, Args&&... args )	(10)	(seit C++23) (nur Exposition*)

Weist einem bestehenden expected-Objekt einen neuen Wert zu.

Parameter

Sonstiges	-	ein weiteres expected-Objekt, dessen enthaltener Wert zugewiesen werden soll
v	-	Wert, der dem enthaltenen Wert zugewiesen werden soll
e	-	std::unexpected-Objekt, dessen enthaltener Wert zugewiesen werden soll
newval	-	der zu konstruierende enthaltene Wert
oldval	-	der zu zerstörende enthaltene Wert
args	-	die Argumente, die als Initialisierer von newval verwendet werden

Effekte

Zuweisungsoperatoren für die primäre Template

1,2) Weist den Zustand von other dem Objekt *this zu.

Wenn has_value() und rhs.has_value() unterschiedliche Werte haben (d. h. eines von *this und other enthält einen erwarteten Wert val und das andere einen unerwarteten Wert unex), wird die expositions-nur-Funktion reinit-expected aufgerufen, um den Zustand sicher zu aktualisieren.

1) Der enthaltene Wert wird wie folgt zugewiesen

Wert von  hat_wert()	Wert von other.has_value()
	true	false
true	val = *other;	reinit-expected     (unex, val, other.error());
false	reinit-expected     (val, unex, *other);	unex = other.error();

2) Der enthaltene Wert wird wie folgt zugewiesen

Wert von  hat_wert()	Wert von other.has_value()
	true	false
true	val = std::move(*other);	reinit-expected     (unex, val, std::move(other.error()));
false	reinit-expected     (val, unex,      std::move(*other));	unex = std::move(other.error());

Wenn keine Ausnahme ausgelöst wurde, wird ausgeführt has_val = other.has_value();.

3) Der erwartete Wert wird wie folgt zugewiesen

Wert von  hat_wert()	Äquivalent zu
true	val = std::forward<U>(v);
false	reinit-expected(val, unex, std::forward<U>(v)); has_val = false;

4,5) Der unerwartete Wert wird wie folgt zugewiesen

Überladung	Wert von  hat_wert()	Äquivalent zu
(4)	true	reinit-expected(val, unex, std::forward<const G&>(e.error())); has_val = false;
	false	unex = std::forward<const G&>(e.error());
(5)	true	reinit-expected(val, unex, std::forward<G>(e.error())); has_val = false;
	false	unex = std::forward<G>(e.error());

void Zuweisungsoperatoren für die partielle Spezialisierung

6) Der unerwartete Wert wird zugewiesen oder zerstört wie folgt

Wert von  hat_wert()	Wert von other.has_value()
	true	false
true	(keine Effekte)	std::construct_at     (std::addressof(unex), rhs.unex); has_val = false;
false	std::destroy_at(std::addressof(unex)); has_val = true;	unex = other.error();

7) Der unerwartete Wert wird zugewiesen oder zerstört wie folgt

Wert von  hat_wert()	Wert von other.has_value()
	true	false
true	(keine Effekte)	std::construct_at     (std::addressof(unex),      std::move(rhs.unex)); has_val = false;
false	std::destroy_at(std::addressof(unex)); has_val = true;	unex = std::move(other.error());

8,9) Der unerwartete Wert wird wie folgt zugewiesen

Überladung	Wert von  hat_wert()	Äquivalent zu
(8)	true	std::construct_at(std::addressof(unex),                   std::forward<const G&>(e.error())); has_val = false;
	false	unex = std::forward<const G&>(e.error());
(9)	true	std::construct_at(std::addressof(unex), std::forward<G>(e.error())); has_val = false;
	false	unex = std::forward<G>(e.error());

Hilfsfunktions-Template

Die expositions-nur-Funktion reinit-expected wird wie folgt "definiert"

template<class NewType, class OldType, class... Args>
constexpr void reinit-expected(NewType& new_val, OldType& old_val, Args&&... args)
{
    // Case 1: the construction of “new_val” is non-throwing:
    // “new_val” can be directly constructed after destroying “old_val”
    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)...);
    }
    // Case 2: the move construction of “new_val” is non-throwing:
    // constuct a temporary NewType object first
    // (“old_val” is left intact if an exception is thrown from this construction)
    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));
    }
    // Case 3: the construction of “new_val” is potentially-throwing:
    // a backup of “old_val” is required in order to recover from an exception
    else
    {
        OldType temp(std::move(old_val)); // may throw
        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;
        }
    }
}

Diese Funktions-Template wird aufgerufen, wenn die Zuweisung dazu führt, dass *this den alternativen Wert enthält (d. h. vom erwarteten Wert zum unerwarteten Wert oder vom unerwarteten Wert zum erwarteten Wert).

In diesem Fall muss der alte Wert oldval zerstört werden, bevor der neue Wert newval konstruiert wird. Die Konstruktion von newval kann jedoch eine Ausnahme auslösen. Um die starke Ausnahme-Sicherheitsgarantie zu bieten, muss der alte Wert wiederhergestellt werden, bevor die Ausnahme erneut ausgelöst wird, damit *this einen gültigen Zustand hat, während die Ausnahme behandelt wird.

Rückgabewert

1-9) *this

Constraints und zusätzliche Informationen

Zuweisungsoperatoren für die primäre Template

1) Diese Überladung ist als gelöscht definiert, es sei denn, alle folgenden Werte sind true

• std::is_copy_assignable_v<T>
• std::is_copy_constructible_v<T>
• std::is_copy_assignable_v<E>
• std::is_copy_constructible_v<E>
• std::is_nothrow_move_constructible_v<T> || std::is_nothrow_move_constructible_v<E>

2) Diese Überladung nimmt nur teil, wenn alle folgenden Werte true sind

• std::is_move_assignable_v<T>
• std::is_move_constructible_v<T>
• std::is_move_assignable_v<E>
• std::is_move_constructible_v<E>
• std::is_nothrow_move_constructible_v<T> || std::is_nothrow_move_constructible_v<E>

3) Diese Überladung nimmt nur an der Auflösung von Überladungen teil, wenn alle folgenden Bedingungen erfüllt sind

• std::is_same_v<expected, std::remove_cvref_t<U>> ist false.
• std::remove_cvref_t<U> ist keine Spezialisierung von std::unexpected.
• Alle folgenden Werte sind true
  • std::is_constructible_v<T, U>
  • std::is_assignable_v<T&, U>
  • std::is_nothrow_constructible_v<T, U> || std::is_nothrow_move_constructible_v<T> ||
    std::is_nothrow_move_constructible_v<E>

4) Diese Überladung nimmt nur teil, wenn alle folgenden Werte true sind

• std::is_constructible_v<E, const G&>
• std::is_assignable_v<E&, const G&>
• std::is_nothrow_constructible_v<E, const G&> || std::is_nothrow_move_constructible_v<T> ||
  std::is_nothrow_move_constructible_v<E>

5) Diese Überladung nimmt nur teil, wenn alle folgenden Werte true sind

• std::is_constructible_v<E, G>
• std::is_assignable_v<E&, G>
• std::is_nothrow_constructible_v<E, G> || std::is_nothrow_move_constructible_v<T> ||
  std::is_nothrow_move_constructible_v<E>

void Zuweisungsoperatoren für die partielle Spezialisierung

6) Diese Überladung ist als gelöscht definiert, es sei denn, std::is_copy_assignable_v<E> und std::is_copy_constructible_v<E> sind beide true.

7) Diese Überladung nimmt nur an der Overload Resolution teil, wenn std::is_move_constructible_v<E> und std::is_move_assignable_v<E> beide true sind.

8) Diese Überladung nimmt nur an der Overload Resolution teil, wenn std::is_constructible_v<E, const G&> und std::is_assignable_v<E&, const G&> beide true sind.

9) Diese Überladung nimmt nur an der Overload Resolution teil, wenn std::is_constructible_v<E, G> und std::is_assignable_v<E&, G> beide true sind.

Ausnahmen

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>)

Fehlerberichte

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

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

Siehe auch

emplace

konstruiert den erwarteten Wert in-place (public member function)