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

Weist einem bestehenden expected -Objekt einen neuen Wert zu.

Parameter

Effekte

Primäre Template-Zuweisungsoperatoren

void Partielle Spezialisierungs-Zuweisungsoperatoren

Hilfsfunktionsvorlage

Die nur zur Darstellung dienende Funktionsvorlage 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)
{
    // Fall 1: Die Konstruktion von „new_val“ ist nicht-werfend:
    // „new_val“ kann direkt nach der Zerstörung von „old_val“ konstruiert werden
    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)...);
    }
    // Fall 2: Die Move-Konstruktion von „new_val“ ist nicht-werfend:
    // Konstruiere zuerst ein temporäres NewType-Objekt
    // („old_val“ bleibt unverändert, falls eine Exception von dieser Konstruktion geworfen wird)
    else if constexpr (std::is_nothrow_move_constructible_v<NewType>)
    {
        NewType temp(std::forward<Args>(args)...); // kann werfen
        std::destroy_at(std::addressof(old_val));
        std::construct_at(std::addressof(new_val), std::move(temp));
    }
    // Fall 3: Die Konstruktion von „new_val“ ist potenziell-werfend:
    // Eine Sicherungskopie von „old_val“ ist erforderlich, um von einer Exception zu regenerieren
    else
    {
        OldType temp(std::move(old_val)); // kann werfen
        std::destroy_at(std::addressof(old_val));
        try
        {
            std::construct_at(std::addressof(new_val),
                              std::forward<Args>(args)...); // kann werfen
        }
        catch (...)
        {
            std::construct_at(std::addressof(old_val), std::move(temp));
            throw;
        }
    }
}

Diese Funktionsvorlage wird aufgerufen, wenn die Zuweisung bewirken wird, 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. Allerdings könnte die Konstruktion von newval eine Exception werfen. Um die starke Exception-Sicherheitsgarantie zu gewährleisten, muss der alte Wert vor dem erneuten Werfen der Exception wiederhergestellt werden, damit * this einen gültigen Zustand hat, während die Exception behandelt wird.

Rückgabewert

Einschränkungen und ergänzende Informationen

Primäre Template-Zuweisungsoperatoren

void Partielle Spezialisierungs-Zuweisungsoperatoren

Exceptions

Beispiel

Fehlerberichte

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

Siehe auch