Namespaces
Variants

    std::optional<T>::transform

    Von de.cppreference.net
     
    C++
     
    Dienstprogrammbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Feature-Test-Makros der Bibliothek (C++20)
    Programm-Dienstprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreiseitiger 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 Dienstprogramme
    Relationsoperatoren (veraltet in C++20)
    Ganzzahlvergleichsfunktionen
    (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::optional
     
    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 Wert enthält, wird f mit dem enthaltenen Wert als Argument aufgerufen und ein std::optional zurückgegeben, der das Ergebnis dieses Aufrufs enthält; andernfalls wird ein leerer std::optional zurückgegeben.

    Der Typ des enthaltenen Werts im Ergebnis (im Folgenden mit U bezeichnet) muss ein Nicht-Array-Objekttyp sein und darf nicht std::in_place_t oder std::nullopt_t sein). Andernfalls ist das Programm fehlerhaft.

    1) Sei U gleich std::remove_cv_t<std::invoke_result_t<F, T&>>. Wenn *this einen Wert enthält, wird ein std::optional<U> zurückgegeben, dessen enthaltener Wert direkt-initialisiert aus std::invoke(std::forward<F>(f), **this) ist (im Gegensatz zu and_then(), das ein std::optional direkt zurückgeben muss). Andernfalls wird ein leerer std::optional<U> zurückgegeben.
    • Das Programm ist fehlerhaft, wenn die Variablendefinition U x(std::invoke(std::forward<F>(f), **this)); fehlerhaft ist.
    2) Gleich wie (1), außer dass U gleich std::remove_cv_t<std::invoke_result_t<F, const T&>> ist.
    3) Sei U gleich std::remove_cv_t<std::invoke_result_t<F, T>>. Wenn *this einen Wert enthält, wird ein std::optional<U> zurückgegeben, dessen enthaltener Wert direkt-initialisiert aus std::invoke(std::forward<F>(f), std::move(**this)) ist. Andernfalls wird ein leerer std::optional<U> zurückgegeben.
    • Das Programm ist fehlerhaft, wenn die Variablendefinition U x(std::invoke(std::forward<F>(f), std::move(**this))); fehlerhaft ist.
    4) Gleich wie (3), außer dass U gleich std::remove_cv_t<std::invoke_result_t<F, const T>> ist.

    Parameter

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

    Rückgabewert

    Ein std::optional , das das Ergebnis von f enthält, oder ein leeres std::optional , wie oben beschrieben.

    Hinweise

    Da transform direkt ein U -Objekt am Zielort konstruiert, anstatt es an einen Konstruktor zu übergeben, kann std:: is_move_constructible_v < U > false sein.

    Da das Aufrufbare f keinen Referenztyp zurückgeben kann, kann es kein Zeiger auf Datenelement sein.

    Einige Sprachen nennen diese Operation map .

    Feature-Test Makro Wert Std Feature
    __cpp_lib_optional 202110L (C++23) Monadische Operationen in std::optional

    Beispiel

    Diesen Code ausführen 
    #include <iostream>
#include <optional>
struct A { /* ... */ };
struct B { /* ... */ };
struct C { /* ... */ };
struct D { /* ... */ };
auto A_to_B(A) -> B { /* ... */ std::cout << "A => B \n"; return {}; }
auto B_to_C(B) -> C { /* ... */ std::cout << "B => C \n"; return {}; }
auto C_to_D(C) -> D { /* ... */ std::cout << "C => D \n"; return {}; }
void try_transform_A_to_D(std::optional<A> o_A)
{
    std::cout << (o_A ? "o_A has a value\n" : "o_A is empty\n");
    std::optional<D> o_D = o_A.transform(A_to_B)
                              .transform(B_to_C)
                              .transform(C_to_D);
    std::cout << (o_D ? "o_D has a value\n\n" : "o_D is empty\n\n");
};
int main()
{
    try_transform_A_to_D( A{} );
    try_transform_A_to_D( {} );
}

    Ausgabe: 

    o_A has a value
A => B
B => C
C => D
o_D has a value
o_A is empty
o_D is empty

    Siehe auch

    		gibt den enthaltenen Wert zurück, falls verfügbar, andernfalls einen anderen Wert
    (öffentliche Elementfunktion)
    (C++23)
    		gibt das Ergebnis der gegebenen Funktion auf den enthaltenen Wert zurück, falls vorhanden, oder ein leeres optional andernfalls
    (öffentliche Elementfunktion)
    (C++23)
    		gibt das optional selbst zurück, falls es einen Wert enthält, oder das Ergebnis der gegebenen Funktion andernfalls
    (öffentliche Elementfunktion)