Namespaces
Variants

std:: unexpected

From cppreference.net
C++
Utilities library
std::expected
Definiert im Header <expected>
template < class E >
class unexpected ;
(seit C++23)

Die Klassenvorlage std::unexpected repräsentiert einen unerwarteten Wert, der in std::expected gespeichert ist. Insbesondere besitzt std::expected Konstruktoren mit std::unexpected als einzigem Argument, die ein expected -Objekt erzeugen, das einen unerwarteten Wert enthält.

Ein Programm ist fehlerhaft, wenn es ein unexpected mit einem Nicht-Objekt-Typ, einem Array-Typ, einer Spezialisierung von std::unexpected oder einem CV-qualifizierten Typ instanziiert.

Inhaltsverzeichnis

Template-Parameter

E - der Typ des unerwarteten Werts. Der Typ darf kein Array-Typ, kein Nicht-Objekt-Typ, keine Spezialisierung von std::unexpected oder kein CV-qualifizierter Typ sein.

Memberfunktionen

konstruiert das unexpected Objekt
(öffentliche Elementfunktion)
(destructor)
(implizit deklariert)
zerstört das unexpected Objekt zusammen mit dem gespeicherten Wert
(öffentliche Elementfunktion)
operator=
(implizit deklariert)
weist den gespeicherten Wert zu
(öffentliche Elementfunktion)
greift auf den gespeicherten Wert zu
(öffentliche Elementfunktion)
tauscht den gespeicherten Wert
(öffentliche Elementfunktion)

Nicht-Member-Funktionen

(C++23)
vergleicht den gespeicherten Wert
(Funktions-Template)
(C++23)
spezialisiert den std::swap Algorithmus
(Funktions-Template)

std::unexpected:: unexpected

constexpr unexpected ( const unexpected & ) = default ;
(1)
constexpr unexpected ( unexpected && ) = default ;
(2)
template < class Err = E >
constexpr explicit unexpected ( Err && e ) ;
(3)
template < class ... Args >
constexpr explicit unexpected ( std:: in_place_t , Args && ... args ) ;
(4)
template < class U, class ... Args >

constexpr explicit unexpected ( std:: in_place_t ,

std:: initializer_list < U > il, Args && ... args ) ;
(5)

Konstruiert ein std::unexpected Objekt.

1,2) Kopier-/Verschiebekonstruktor. Kopiert bzw. verschiebt den gespeicherten Wert.
3) Konstruiert den gespeicherten Wert, als ob durch Direct-Initialisierung eines Werts vom Typ E aus std:: forward < Err > ( e ) .
4) Konstruiert den gespeicherten Wert, als ob durch Direct-Initialisierung eines Werts vom Typ E aus den Argumenten std:: forward < Args > ( args ) ... .
5) Konstruiert den gespeicherten Wert, als ob durch Direktinitialisierung eines Werts vom Typ E aus den Argumenten il, std:: forward < Args > ( args ) ... .

Parameter

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

Wirft jede Ausnahme, die vom Konstruktor von E geworfen wird.

std::unexpected:: error

constexpr const E & error ( ) const & noexcept ;

constexpr E & error ( ) & noexcept ;
constexpr const E && error ( ) const && noexcept ;

constexpr E && error ( ) && noexcept ;

Gibt eine Referenz auf den gespeicherten Wert zurück.

std::unexpected:: swap

constexpr void swap ( unexpected & other ) noexcept ( std:: is_nothrow_swappable_v < E > ) ;

Tauscht die gespeicherten Werte aus, als ob durch using std:: swap ; swap ( error ( ) , other. error ( ) ) ; .

Das Programm ist fehlerhaft, wenn std:: is_swappable_v < E > false ist.

operator== (std::unexpected)

template < class E2 >
friend constexpr bool operator == ( unexpected & x, std :: unexpected < E2 > & y ) ;

Vergleicht die gespeicherten Werte, als ob durch return x. error ( ) == y. error ( ) .

Wenn der Ausdruck x. error ( ) == e. error ( ) nicht wohlgeformt ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm fehlerhaft.

Diese Funktion ist für gewöhnliches unqualified oder qualified lookup nicht sichtbar und kann nur durch argument-dependent lookup gefunden werden, wenn std::unexpected<E> eine assoziierte Klasse der Argumente ist.

swap (std::unexpected)

friend constexpr void
swap ( unexpected & x, unexpected & y ) noexcept ( noexcept ( x. swap ( y ) ) ) ;

Entspricht x. swap ( y ) .

Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_swappable_v < E > true ist.

Diese Funktion ist für gewöhnliche unqualified oder qualified lookup nicht sichtbar und kann nur durch argument-dependent lookup gefunden werden, wenn std::unexpected<E> eine assoziierte Klasse der Argumente ist.

Deduktionsanleitungen

template < class E >
unexpected ( E ) - > unexpected < E > ;
(seit C++23)

Der Deduction Guide wird für unexpected bereitgestellt, um die Ableitung aus dem Konstruktorargument zu ermöglichen.

Hinweise

Vor C++17 bezeichnete der Name std::unexpected die Funktion, die von der C++-Laufzeitumgebung aufgerufen wurde, wenn eine dynamische Ausnahmespezifikation verletzt wurde.

Beispiel

Diesen Code ausführen 
#include <expected>
#include <iostream>
enum class error
{
    compile_time_error,
    runtime_error
};
[[nodiscard]] auto unexpected_runtime_error() -> std::expected<int, error>
{
    return std::unexpected(error::runtime_error);
}
int main()
{
    std::expected<double, int> ex = std::unexpected(3);
    if (!ex)
        std::cout << "ex enthält einen Fehlerwert\n";
    if (ex == std::unexpected(3))
        std::cout << "Der Fehlerwert ist gleich 3\n";
    const auto e = unexpected_runtime_error();
    e.and_then([](const auto& e) -> std::expected<int, error>
    {
        std::cout << "and_then: " << int(e); // nicht ausgegeben
        return {};
    })
    .or_else([](const auto& e) -> std::expected<int, error>
    {
        std::cout << "or_else: " << int(e); // gibt diese Zeile aus
        return {};
    });
}

Ausgabe: 

ex enthält einen Fehlerwert
Der Fehlerwert ist gleich 3
or_else: 1

Siehe auch

konstruiert das expected Objekt
(öffentliche Elementfunktion)
gibt den erwarteten Wert zurück
(öffentliche Elementfunktion)
tauscht die Inhalte aus
(öffentliche Elementfunktion)
(C++23)
spezialisiert den std::swap Algorithmus
(Funktion)
(C++23)
vergleicht expected Objekte
(Funktions-Template)