Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Hilfsbibliothek
    Sprachunterstützung
    Typunterstützung (grundlegende Typen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programmhilfsmittel
    Funktionen mit variabler Argumentanzahl
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstü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 Hilfsmittel
    Relationale Operatoren (veraltet in C++20)
     
    std::expected
     
    constexpr expected();
    		(1) (seit C++23) 
    constexpr expected( const expected& other );
    		(2) (seit C++23) 
    constexpr expected( expected&& other ) noexcept(/* see below */);
    		(3) (seit C++23) 
    template< class U, class G >
constexpr explicit(/* see below */) expected( const expected<U, G>& other );
    		(4) (seit C++23) 
    template< class U, class G >
constexpr explicit(/* see below */) expected( expected<U, G>&& other );
    		(5) (seit C++23) 
    template< class U = std::remove_cv_t<T> >
constexpr explicit(!std::is_convertible_v<U, T>) expected( U&& v );
    		(6) (seit C++23)
    (T ist nicht cv void)    		 
    template< class G >
constexpr explicit(!std::is_convertible_v<const G&, E>)
    expected( const std::unexpected<G>& e );
    		(7) (seit C++23) 
    template< class G >
constexpr explicit(!std::is_convertible_v<G, E>)
    expected( std::unexpected<G>&& e );
    		(8) (seit C++23) 
    template< class... Args >
constexpr explicit expected( std::in_place_t, Args&&... args );
    		(9) (seit C++23)
    (T ist nicht cv void) 
    template< class U, class... Args >
constexpr explicit expected( std::in_place_t,
                             std::initializer_list<U> il, Args&&... args );
    		(10) (seit C++23)
    (T ist nicht cv void) 
    constexpr explicit expected( std::in_place_t ) noexcept;
    		(11) (seit C++23)
    (T ist cv void) 
    template< class... Args >
constexpr explicit expected( std::unexpect_t, Args&&... args );
    		(12) (seit C++23) 
    template< class U, class... Args >
constexpr explicit expected( std::unexpect_t,
                             std::initializer_list<U> il, Args&&... args );
    		(13) (seit C++23)

    Erzeugt ein neues expected-Objekt.

    1) Standardkonstruktor. Falls T nicht (möglicherweise cv-qualifiziert) void ist, erzeugt er ein Objekt, das einen erwarteten Wert enthält, welcher wertinitialisiert wird.
    Nach der Erzeugung gibt has_value() true zurück.
    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn T (möglicherweise cv-qualifiziert) void ist oder std::is_default_constructible_v<T> true ist.
    2) Kopierkonstruktor. Falls other.has_value() false ist, enthält das neue Objekt einen unerwarteten Wert, der direkt-initialisiert von other.error() wird. Andernfalls, falls T nicht (möglicherweise cv-qualifiziert) void ist, enthält das neue Objekt einen erwarteten Wert, der direkt-initialisiert von *other wird.
    Nach der Erzeugung ist has_value() gleich other.has_value().
    Dieser Konstruktor ist als gelöscht definiert, es sei denn,
    • entweder T ist (möglicherweise cv-qualifiziert) void, oder std::is_copy_constructible_v<T> ist true, und
    • std::is_copy_constructible_v<E> ist true.
    Dieser Konstruktor ist trivial, wenn
    • entweder T ist (möglicherweise cv-qualifiziert) void, oder std::is_trivially_copy_constructible_v<T> ist true, und
    • std::is_trivially_copy_constructible_v<E> ist true.
    3) Verschiebekonstruktor. Falls other.has_value() false ist, enthält das neue Objekt einen unerwarteten Wert, der direkt-initialisiert von std::move(other.error()) wird. Andernfalls, falls T nicht (möglicherweise cv-qualifiziert) void ist, enthält das neue Objekt einen erwarteten Wert, der direkt-initialisiert von std::move(*other) wird.
    Nach der Erzeugung ist has_value() gleich other.has_value().
    Dieser Konstruktor nimmt nur an der Überladungsauflösung teil, wenn
    • entweder T ist (möglicherweise cv-qualifiziert) void, oder std::is_move_constructible_v<T> ist true, und
    • std::is_move_constructible_v<E> ist true.
    Dieser Konstruktor ist trivial, wenn
    • std::is_trivially_move_constructible_v<T> true ist, und
    • std::is_trivially_move_constructible_v<E> ist true.
    4,5) Sei
    • UF std::add_lvalue_reference_t<const U> für (4) und U für (5), und
    • GF sei const G& für (4) und G für (5).
    Falls other.has_value() false ist, enthält das neue Objekt einen unerwarteten Wert, der direkt-initialisiert von std::forward<GF>(other.error()) wird. Andernfalls, falls T nicht (möglicherweise cv-qualifiziert) void ist, enthält das neue Objekt einen erwarteten Wert, der direkt-initialisiert von std::forward<UF>(*other) wird.
    Nach der Erzeugung ist has_value() gleich other.has_value().
    Jeder dieser Konstruktoren nimmt nicht an der Überladungsauflösung teil, es sei denn, die folgenden Bedingungen sind jeweils erfüllt:
    • Entweder
      • T ist (möglicherweise cv-qualifiziert) void, und std::is_void_v<U> ist true, oder
      • std::is_constructible_v<T, UF> ist true.
    • std::is_constructible_v<E, GF> ist true.
    • Falls T nicht (möglicherweise cv-qualifiziert) bool ist, ist T nicht konstruierbar oder konvertierbar aus einem beliebigen Ausdruck vom Typ (möglicherweise const) std::expected<U, G>, d.h. die folgenden 8 Werte sind alle false:
      • std::is_constructible_v<T, std::expected<U, G>&
      • std::is_constructible_v<T, std::expected<U, G>
      • std::is_constructible_v<T, const std::expected<U, G>&
      • std::is_constructible_v<T, const std::expected<U, G>
      • std::is_convertible_v<std::expected<U, G>&, T>
      • std::is_convertible_v<std::expected<U, G>, T>
      • std::is_convertible_v<const std::expected<U, G>&, T>
      • std::is_convertible_v<const std::expected<U, G>, T>
    • std::unexpected<E> ist nicht konstruierbar aus einem beliebigen Ausdruck vom Typ (möglicherweise const) std::expected<U, G>, d.h. die folgenden 4 Werte sind alle false:
      • std::is_constructible_v<std::unexpected<E>, std::expected<U, G>&
      • std::is_constructible_v<std::unexpected<E>, std::expected<U, G>
      • std::is_constructible_v<std::unexpected<E>, const std::expected<U, G>&
      • std::is_constructible_v<std::unexpected<E>, const std::expected<U, G>
    Diese Konstruktoren sind explicit, wenn std::is_convertible_v<UF, T> oder std::is_convertible_v<GF, E> false ist.
    6) Erzeugt ein Objekt, das einen erwarteten Wert enthält, initialisiert als ob ein Objekt vom Typ mit dem Ausdruck Tdirekt-initialisiertstd::forward<U>(v) (aber nicht direkt-list-initialisiert) würde.
    Nach der Erzeugung gibt has_value() true zurück.
    Dieser Konstruktor nimmt nicht an der Überladungsauflösung teil, es sei denn, die folgenden Bedingungen sind erfüllt:
    • T ist nicht (möglicherweise cv-qualifiziert) void.
    • std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> ist false.
    • std::is_same_v<expected, std::remove_cvref_t<U>> ist false.
    • std::is_constructible_v<T, U> ist true.
    • std::remove_cvref_t<U> ist keine Spezialisierung von std::unexpected.
    • Falls T (möglicherweise cv-qualifiziert) bool ist, ist std::remove_cvref_t<U> keine Spezialisierung von std::expected.
    7,8) Sei GF const G& für (7) und G für (8). Erzeugt ein Objekt, das einen unerwarteten Wert enthält, der direkt-initialisiert von std::forward<GF>(e.error()) wird.
    Nach der Erzeugung gibt has_value() false zurück.
    Diese Überladungen nehmen nur an der Überladungsauflösung teil, wenn std::is_constructible_v<E, GF> true ist.
    9) Erzeugt ein Objekt, das einen erwarteten Wert enthält, der direkt-initialisiert von den Argumenten std::forward<Args>(args)... wird.
    Nach der Erzeugung gibt has_value() true zurück.
    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_constructible_v<T, Args...> true ist.
    10) Erzeugt ein Objekt, das einen erwarteten Wert enthält, der direkt-initialisiert von den Argumenten il, std::forward<Args>(args)... wird.
    Nach der Erzeugung gibt has_value() true zurück.
    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_constructible_v<T, std::initializer_list<U>&, Args...> true ist.
    11) Erzeugt ein Objekt, sodass nach der Erzeugung has_value() true zurückgibt.
    12) Erzeugt ein Objekt, das einen unerwarteten Wert enthält, der direkt-initialisiert von den Argumenten std::forward<Args>(args)... wird.
    Nach der Erzeugung gibt has_value() false zurück.
    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_constructible_v<E, Args...> true ist.
    13) Erzeugt ein Objekt, das einen unerwarteten Wert enthält, der direkt-initialisiert von den Argumenten il, std::forward<Args>(args)... wird.
    Nach der Erzeugung gibt has_value() false zurück.
    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_constructible_v<E, std::initializer_list<U>&, Args...> true ist.

    Parameter

    other - ein weiteres expected Objekt, dessen enthaltene Werte kopiert werden
    e - std::unexpected Objekt, dessen enthaltene Werte kopiert werden
    v - Wert, mit dem der enthaltene Wert initialisiert wird
    args - Argumente, mit denen der enthaltene Wert initialisiert wird
    il - Initialisierungsliste, mit der der enthaltene Wert initialisiert wird

    Exceptions

    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 Korrigiertes Verhalten
    LWG 3886 C++23 das Standard-Template-Argument von overload ( 6 ) war T geändert zu std:: remove_cv_t < T >

    Siehe auch

    (C++23)
    		dargestellt als ein unerwarteter Wert
    (Klassen-Template)
    (C++17)
    		In-Place-Konstruktions-Tag
    (Tag)
    (C++23)
    		In-Place-Konstruktions-Tag für unerwartete Werte in expected
    (Tag)