Namespaces
Variants

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

    Aus de.cppreference.net
     
    C++
     
    Hilfsmittelbibliothek
    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)
    Integer-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Tausch 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
     
    template< class F >
constexpr auto transform( F&& f ) &;
    		(1) (seit C++23) 
    template< class F >
constexpr auto transform( F&& f ) const&;
    		(2) (seit C++23) 
    template< class F >
constexpr auto transform( F&& f ) &&;
    		(3) (seit C++23) 
    template< class F >
constexpr auto transform( F&& f ) const&&;
    		(4) (seit C++23)

    Wenn *this einen erwarteten Wert enthält, ruft f auf und gibt ein std::expected-Objekt zurück, das sein Ergebnis enthält; andernfalls wird ein std::expected-Objekt zurückgegeben, das eine Kopie von error() enthält.

    Wenn T nicht (möglicherweise cv-qualifiziert) void ist, wird der enthaltene Wert (operator*()) als Argument an f übergeben; andernfalls nimmt f kein Argument entgegen.

    Sei U:

    • wenn T nicht (möglicherweise cv-qualifiziert) void ist:
      • für Überladungen (1-2), std::remove_cv_t<std::invoke_result_t<F, decltype(operator*())>>;
      • für Überladungen (3-4), std::remove_cv_t<std::invoke_result_t<F, decltype(std::move(operator*()))>>;
    • andernfalls (T ist möglicherweise cv-qualifiziert void), std::remove_cv_t<std::invoke_result_t<F>>.

    U muss ein gültiger Werttyp für std::expected sein. Eine Variable vom Typ U muss aus dem Ergebnis des Aufrufs konstruierbar sein (muss aber nicht verschiebungskonstruierbar sein). Der Rückgabetyp ist std::expected<U, E>.

    1-2) Diese Überladungen nehmen nur an der Überladungsauflösung teil, wenn std::is_constructible_v<E, decltype(error())> true ist.
    3-4) Diese Überladungen nehmen nur an der Überladungsauflösung teil, wenn std::is_constructible_v<E, decltype(std::move(error()))> true ist.

    Formal führen diese Funktionen die folgenden Schritte aus:

    • Wenn *this einen erwarteten Wert val enthält:
    1. Rufe f auf, wie durch
      • std::invoke(std::forward<F>(f), val) für Überladungen (1,2), wenn std::is_void_v<T> false ist;
      • std::invoke(std::forward<F>(f), std::move(val)) für Überladungen (3,4), wenn std::is_void_v<T> false ist;
      • std::invoke(std::forward<F>(f)) wenn std::is_void_v<T> true ist.
    2. Dann:
      • wenn std::is_void_v<U> false ist, wird ein std::expected-Objekt zurückgegeben, das einen erwarteten Wert enthält, direkt-initialisiert aus dem Ergebnis des Aufrufs;
      • andernfalls wird std::expected<U, E>() zurückgegeben.
    • Andernfalls (*this enthält einen Fehlerwert) wird std::expected<U, E>(std::unexpect, error()) zurückgegeben.

    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 ) , val )
    3,4) std:: invoke ( std:: forward < F > ( f ) ,std :: move ( val ) )
    5-8) std:: invoke ( std:: forward < F > ( f ) )

    Die Rückgabewerte sind wie folgt definiert:

    Überladung Wert von has_value()
    true false
    ( 1,2 ) std:: expected < U, E > ( std:: unexpect , error ( ) )
    ( 3,4 ) std:: expected < U, E >
    ( std:: unexpect , std :: move ( error ( ) ) )
    ( 5,6 ) std:: expected < U, E > ( std:: unexpect , error ( ) )
    ( 7,8 ) std:: expected < U, E >
    ( std:: unexpect , std :: move ( error ( ) ) )

    Anmerkungen

    Feature-Test-Makro Wert Norm Merkmal
    __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 argument-dependent lookup auslösen.

    Siehe auch

    		gibt das expected selbst zurück, wenn es einen erwarteten Wert enthält; andernfalls gibt es ein expected zurück, das den transformierten unerwarteten Wert enthält
    (öffentliche Mitgliedsfunktion)