Namespaces
Variants

    std::expected

    Von de.cppreference.net
     
    C++
     
    Hilfsmittelbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programmhilfsmittel
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreivektorsvergleich
    (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
    Relationsoperatoren (deprecated in C++20)
    Integer-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::expected
     
    Definiert im Header <expected> 
    template< class T, class E >
class expected;
    		(1) (seit C++23) 
    template< class T, class E >
    requires std::is_void_v<T>
class expected<T, E>;
    		(2) (seit C++23)

    Die Klassenvorlage std::expected bietet eine Möglichkeit, einen von zwei Werten darzustellen: einen erwarteten Wert vom Typ T, oder einen unerwarteten Wert vom Typ E. expected ist niemals wertlos.

    1) Die Hauptvorlage. Enthält den erwarteten oder unerwarteten Wert in eigenem Speicher, der innerhalb von dem expected-Objekt verschachtelt ist.
    2) Die void-Partialspezialisierung. Stellt einen erwarteten void-Wert dar oder enthält einen unerwarteten Wert. Wenn sie einen unerwarteten Wert enthält, ist er innerhalb des expected-Objekts verschachtelt.

    Ein Programm ist fehlerhaft, wenn es ein expected mit einem Referenztyp, einem Funktionstyp oder einer Spezialisierung von std::unexpected instanziiert. Außerdem darf T nicht std::in_place_t oder std::unexpect_t sein.

    Template-Parameter

    T - der Typ des erwarteten Werts. Der Typ muss entweder (möglicherweise cv-qualifiziert) void sein oder die Destructible -Anforderungen erfüllen (insbesondere sind Array- und Referenztypen nicht erlaubt).
    E - der Typ des unerwarteten Werts. Der Typ muss die Destructible -Anforderungen erfüllen und muss ein gültiges Template-Argument für std::unexpected sein (insbesondere sind Arrays, Nicht-Objekt-Typen und cv-qualifizierte Typen nicht erlaubt).

    Verschachtelte Typen

    Typ Definition
    value_type T
    error_type E
    unexpected_type std::unexpected<E>

    Member-Templates

    Vorlage Definition
    rebind < U > std :: expected < U, error_type >

    Datenmitglieder

    Mitglied Beschreibung
    bool has_val ob das expected Objekt aktuell den erwarteten Wert repräsentiert
    ( Nur zur Veranschaulichung dienendes Mitgliedsobjekt* )
    T val (nur Haupttemplate) der erwartete Wert
    ( Nur zur Veranschaulichung dienendes Varianten-Mitgliedsobjekt* )
    E unex der unerwartete Wert
    ( Nur zur Veranschaulichung dienendes Varianten-Mitgliedsobjekt* )

    Memberfunktionen

    		konstruiert das expected Objekt
    (öffentliche Elementfunktion)
    		zerstört das expected Objekt zusammen mit seinem enthaltenen Wert
    (öffentliche Elementfunktion)
    		weist Inhalte zu
    (öffentliche Elementfunktion)
    Beobachter
    		greift auf den erwarteten Wert zu
    (öffentliche Elementfunktion)
    		prüft, ob das Objekt einen erwarteten Wert enthält
    (öffentliche Elementfunktion)
    		gibt den erwarteten Wert zurück
    (öffentliche Elementfunktion)
    		gibt den unerwarteten Wert zurück
    (öffentliche Elementfunktion)
    		gibt den erwarteten Wert zurück, falls vorhanden, andernfalls einen anderen Wert
    (öffentliche Elementfunktion)
    		gibt den unerwarteten Wert zurück, falls vorhanden, andernfalls einen anderen Wert
    (öffentliche Elementfunktion)
    Monadische Operationen
    		gibt das Ergebnis der gegebenen Funktion auf den erwarteten Wert zurück, falls vorhanden; andernfalls gibt es das expected selbst zurück
    (öffentliche Elementfunktion)
    		gibt ein expected zurück, das den transformierten erwarteten Wert enthält, falls vorhanden; andernfalls gibt es das expected selbst zurück
    (öffentliche Elementfunktion)
    		gibt das expected selbst zurück, falls es einen erwarteten Wert enthält; andernfalls gibt es das Ergebnis der gegebenen Funktion auf den unerwarteten Wert zurück
    (öffentliche Elementfunktion)
    		gibt das expected selbst zurück, falls es einen erwarteten Wert enthält; andernfalls gibt es ein expected zurück, das den transformierten unerwarteten Wert enthält
    (öffentliche Elementfunktion)
    Modifikatoren
    		konstruiert den erwarteten Wert direkt
    (öffentliche Elementfunktion)
    		tauscht die Inhalte aus
    (öffentliche Elementfunktion)

    Nicht-Member-Funktionen

    (C++23)
    		vergleicht expected -Objekte
    (Funktionsschablone)
    (C++23)
    		spezialisiert den std::swap -Algorithmus
    (Funktion)

    Hilfsklassen

    (C++23)
    		dargestellt als ein unerwarteter Wert
    (Klassentemplate)
    (C++23)
    		Exception, die geprüften Zugriff auf ein expected anzeigt, das einen unerwarteten Wert enthält
    (Klassentemplate)
    (C++23)
    		In-place-Konstruktions-Tag für unerwarteten Wert in expected
    (Tag)

    Hinweise

    Typen mit der gleichen Funktionalität werden Result in Rust und Either in Haskell genannt.

    Feature-Test Makro Wert Std Funktion
    __cpp_lib_expected 202202L (C++23) Klassentemplate std::expected und zugehörige Hilfsklassen
    202211L (C++23) Monadische Funktionen für std::expected

    Beispiel

    Diesen Code ausführen 
    #include <cmath>
#include <expected>
#include <iomanip>
#include <iostream>
#include <string_view>
enum class parse_error
{
    invalid_input,
    overflow
};
auto parse_number(std::string_view& str) -> std::expected<double, parse_error>
{
    const char* begin = str.data();
    char* end;
    double retval = std::strtod(begin, &end);
    if (begin == end)
        return std::unexpected(parse_error::invalid_input);
    else if (std::isinf(retval))
        return std::unexpected(parse_error::overflow);
    str.remove_prefix(end - begin);
    return retval;
}
int main()
{
    auto process = [](std::string_view str)
    {
        std::cout << "str: " << std::quoted(str) << ", ";
        if (const auto num = parse_number(str); num.has_value())
            std::cout << "value: " << *num << '\n';
            // Wenn num keinen Wert hätte, würde das Dereferenzieren von num
            // zu undefiniertem Verhalten führen, und
            // num.value() würde std::bad_expected_access werfen.
            // num.value_or(123) verwendet den angegebenen Standardwert 123.
        else if (num.error() == parse_error::invalid_input)
            std::cout << "error: invalid input\n";
        else if (num.error() == parse_error::overflow)
            std::cout << "error: overflow\n";
        else
            std::cout << "unexpected!\n"; // oder std::unreachable() aufrufen;
    };
    for (auto src : {"42", "42abc", "meow", "inf"})
        process(src);
}

    Ausgabe: 

    str: "42", value: 42
str: "42abc", value: 42
str: "meow", error: invalid input
str: "inf", error: overflow

    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 4141 C++23 die Anforderung der Speicher-
    reservierung war verwirrend     		das enthaltene Objekt muss
    innerhalb des expected -Objekts
    geschachtelt sein

    Referenzen

    • C++23-Standard (ISO/IEC 14882:2024):
    • 22.8 Expected-Objekte [expected]

    Siehe auch

    (C++17)
    		Eine typsichere diskriminierte Union
    (Klassentemplate)
    (C++17)
    		Ein Wrapper, der möglicherweise ein Objekt enthält
    (Klassentemplate)