Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Dienstprogrammbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Dienstprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreivektorenvergleich
    (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 Dienstprogramme
    Relationale Operatoren (veraltet 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
     
    Primäre Vorlage
    		 
    template< class F >
constexpr auto transform_error( F&& f ) &;
    		(1) (seit C++23) 
    template< class F >
constexpr auto transform_error( F&& f ) const&;
    		(2) (seit C++23) 
    template< class F >
constexpr auto transform_error( F&& f ) &&;
    		(3) (seit C++23) 
    template< class F >
constexpr auto transform_error( F&& f ) const&&;
    		(4) (seit C++23)
    void partielle Spezialisierung
    		 
    template< class F >
constexpr auto transform_error( F&& f ) &;
    		(5) (seit C++23) 
    template< class F >
constexpr auto transform_error( F&& f ) const&;
    		(6) (seit C++23) 
    template< class F >
constexpr auto transform_error( F&& f ) &&;
    		(7) (seit C++23) 
    template< class F >
constexpr auto transform_error( F&& f ) const&&;
    		(8) (seit C++23)

    Wenn *this einen unerwarteten Wert enthält, ruft f mit dem unerwarteten Wert von *this als Argument auf und gibt ein std::expected-Objekt zurück, das einen unerwarteten Wert enthält, der mit dem Ergebnis von f initialisiert wird. Andernfalls wird ein std::expected-Objekt zurückgegeben, das einen erwarteten Wert darstellt.

    1-4) Der erwartete Wert wird mit dem erwarteten Wert val von *this initialisiert.

    Gegeben sei der Typ G als:

    1,2) std::remove_cv_t<std::invoke_result_t<F, decltype(error())>>
    3,4) std::remove_cv_t<std::invoke_result_t<F, decltype(std::move(error()))>>
    5,6) std::remove_cv_t<std::invoke_result_t<F, decltype(error())>>
    7,8) std::remove_cv_t<std::invoke_result_t<F, decltype(std::move(error()))>>

    Wenn eine der folgenden Bedingungen erfüllt ist, ist das Programm fehlerhaft:

    • G ist kein gültiges Vorlagenargument für std::unexpected.
    • Die folgende entsprechende Deklaration ist fehlerhaft:
    1,2) G g(std::invoke(std::forward<F>(f), error()));
    3,4) G g(std::invoke(std::forward<F>(f), std::move(error()));
    5,6) G g(std::invoke(std::forward<F>(f), error()));
    7,8) G g(std::invoke(std::forward<F>(f), std::move(error()));


    1,2) Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_constructible_v<T, decltype((val))> ist true.
    3,4) Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_constructible_v<T, decltype(std::move(val))> ist true.

    Parameter

    f - eine geeignete Funktion oder Callable Objekt, dessen Aufrufsignatur einen Nicht-Referenztyp zurückgibt

    Rückgabewert

    Gegebener Ausdruck expr als:

    1,2) std:: invoke ( std:: forward < F > ( f ) , Fehler ( ) )
    3,4) std:: invoke ( std:: forward < F > ( f ) , std :: move ( error ( ) ) )
    5,6) std:: invoke ( std:: forward < F > ( f ) , Fehler ( ) )
    7,8) std:: invoke ( std:: forward < F > ( f ) , std :: move ( error ( ) ) )

    Die Rückgabewerte sind wie folgt definiert:

    Überladung Wert von has_value()
    true false
    ( 1,2 ) std:: expected < T, G > ( std:: in_place , val ) std:: expected < T, G >
    ( std:: unexpect , expr )
    ( 3,4 ) std:: expected < T, G > ( std:: in_place , std :: move ( val ) )
    ( 5,6 ) std:: expected < T, G > ( )
    ( 7,8 )

    Anmerkungen

    Feature-Test-Makro Wert Norm Funktion
    __cpp_lib_expected 202211L (C++23) Monadische Funktionen für std::expected

    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 Korrektes Verhalten
    LWG 3938 C++23 der erwartete Wert wurde durch value ( ) [1] erhalten geändert zu ** this
    LWG 3973 C++23 der erwartete Wert wurde durch ** this [2] erhalten geändert zu val
    1. ↑ value() erfordert, dass E kopierkonstruierbar ist (siehe LWG-Issue 3843 ), während operator* dies nicht tut.
    2. ↑ ** this kann argumentabhängige Namenssuche auslösen.

    Siehe auch

    		gibt das expected selbst zurück, falls es einen erwarteten Wert enthält; andernfalls gibt es das Ergebnis der gegebenen Funktion für den unerwarteten Wert zurück
    (öffentliche Elementfunktion)
    		gibt ein expected zurück, das den transformierten erwarteten Wert enthält, falls dieser existiert; andernfalls gibt es das expected selbst zurück
    (öffentliche Elementfunktion)