std::unerwartet
| Definiert in der Header-Datei <expected> |
||
| template< class E > class unerwartet; |
(seit C++23) | |
Die Klassenschablone std::unexpected repräsentiert einen unerwarteten Wert, der in std::expected gespeichert ist. Insbesondere hat std::expected Konstruktoren mit std::unexpected als einzigem Argument, welche ein expected Objekt erstellen, das einen unerwarteten Wert enthält.
Ein Programm ist schlecht geformt, wenn es eine unexpected-Instanz mit einem Nicht-Objekttyp, einem Array-Typ, einer Spezialisierung von std::unexpected oder einem cv-qualifizierten Typ instanziiert.
Inhalt |
[bearbeiten] Schablonenparameter
| E | - | der Typ des unerwarteten Wertes. Der Typ darf kein Array-Typ, kein Nicht-Objekttyp, keine Spezialisierung von std::unexpected oder ein cv-qualifizierter Typ sein. |
[bearbeiten] Member-Funktionen
konstruiert das unexpected Objekt(öffentliche Memberfunktion) | |
| (Destruktor) (implizit deklariert) |
zerstört das unexpected Objekt zusammen mit dem gespeicherten Wert(öffentliche Memberfunktion) |
| operator= (implizit deklariert) |
weist den gespeicherten Wert zu (öffentliche Memberfunktion) |
| greift auf den gespeicherten Wert zu (öffentliche Memberfunktion) | |
| tauscht den gespeicherten Wert (öffentliche Memberfunktion) |
[bearbeiten] Nicht-Member-Funktionen
| (C++23) |
vergleicht den gespeicherten Wert (function template) |
| (C++23) |
spezialisiert den Algorithmus std::swap (function template) |
std::unexpected::unerwartet
| constexpr unerwartet( const unerwartet& ) = default; |
(1) | |
| constexpr unerwartet( unerwartet&& ) = default; |
(2) | |
| template< class Err = E > constexpr explicit unerwartet( Err&& e ); |
(3) | |
| template< class... Args > constexpr explicit unerwartet( std::in_place_t, Args&&... args ); |
(4) | |
| template< class U, class... Args > constexpr explicit unerwartet( std::in_place_t, |
(5) | |
Konstruiert ein std::unexpected Objekt.
E aus std::forward<Err>(e).- Diese Überladung nimmt an der Überladungsauflösung teil, wenn
- std::is_same_v<std::remove_cvref_t<Err>, unerwartet> ist falsch, und
- std::is_same_v<std::remove_cvref_t<Err>, std::in_place_t> ist falsch, und
- std::is_constructible_v<E, Err> ist wahr.
E aus den Argumenten std::forward<Args>(args)....- Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_constructible_v<E, Args...> wahr ist.
E aus den Argumenten il, std::forward<Args>(args)....- Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_constructible_v<E, std::initializer_list<U>&, Args...> wahr ist.
Parameter
| e | - | Wert, mit dem der enthaltene Wert initialisiert werden soll |
| args... | - | Argumente, mit denen der enthaltene Wert initialisiert werden soll |
| il | - | Initialisierungsliste, mit der der enthaltene Wert initialisiert werden soll |
Ausnahmen
Wirft jede Ausnahme, die vom Konstruktor von E geworfen wird.
std::unexpected::error
| 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( unerwartet& other ) noexcept(std::is_nothrow_swappable_v<E>); |
||
Tauscht die gespeicherten Werte, als ob durch using std::swap; swap(error(), other.error());.
Das Programm ist schlecht geformt, wenn std::is_swappable_v<E> falsch ist.
operator==(std::unexpected)
| template< class E2 > friend constexpr bool operator==( unerwartet& x, std::unerwartet<E2>& y ); |
||
Vergleicht die gespeicherten Werte, als ob durch return x.error() == y.error().
Wenn der Ausdruck x.error() == e.error() nicht gut geformt ist, oder wenn sein Ergebnis nicht in bool konvertierbar ist, ist das Programm schlecht geformt.
Diese Funktion ist für die normale unqualifizierte oder qualifizierte Suche nicht sichtbar und kann nur durch Argument-abhängige Suche gefunden werden, wenn std::unexpected<E> eine zugeordnete Klasse der Argumente ist.
swap(std::unexpected)
| friend constexpr void swap( unerwartet& x, unerwartet& y ) noexcept(noexcept(x.swap(y))); |
||
Entspricht x.swap(y).
Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_swappable_v<E> wahr ist.
Diese Funktion ist für die normale unqualifizierte oder qualifizierte Suche nicht sichtbar und kann nur durch Argument-abhängige Suche gefunden werden, wenn std::unexpected<E> eine zugeordnete Klasse der Argumente ist.
[bearbeiten] Deduktions-Guides
| template< class E > unerwartet(E) -> unerwartet<E>; |
(seit C++23) | |
Der Deduktions-Guide wird für unexpected bereitgestellt, um die Deduktion aus dem Konstruktorargument zu ermöglichen.
[bearbeiten] Hinweise
Vor C++17 bezeichnete der Name std::unexpected die Funktion, die von der C++-Laufzeit aufgerufen wurde, wenn eine dynamische Ausnahmespezifikation verletzt wurde.
[bearbeiten] Beispiel
#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 contains an error value\n"; if (ex == std::unexpected(3)) std::cout << "The error value is equal to 3\n"; const auto e = unexpected_runtime_error(); e.and_then([](const auto& e) -> std::expected<int, error> { std::cout << "and_then: " << int(e); // not printed return {}; }) .or_else([](const auto& e) -> std::expected<int, error> { std::cout << "or_else: " << int(e); // prints this line return {}; }); }
Ausgabe
ex contains an error value The error value is equal to 3 or_else: 1
[bearbeiten] Siehe auch
konstruiert das expected-Objekt(öffentliche Mitgliedsfunktion) | |
| (C++23) |
vergleicht expected Objekte(function template) |
