Namespaces
Variants

std::optional<T>:: transform

From cppreference.net
C++
Utilities library
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, ruft es f mit dem enthaltenen Wert als Argument auf und gibt ein std::optional zurück, das das Ergebnis dieses Aufrufs enthält; andernfalls wird ein leeres std::optional zurückgegeben.

Der Typ des enthaltenen Werts im Ergebnis (bezeichnet durch U unten) 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 definiert als std:: remove_cv_t < std:: invoke_result_t < F, T & >> . Falls * this einen Wert enthält, gibt ein std:: optional < U > zurück, dessen enthaltener Wert durch Direktinitialisierung aus std:: invoke ( std:: forward < F > ( f ) , ** this ) erzeugt wird (im Gegensatz zu and_then() , das direkt ein std::optional zurückgeben muss). Andernfalls wird ein leeres 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 std:: remove_cv_t < std:: invoke_result_t < F, const T & >> ist.
3) Sei U definiert als std:: remove_cv_t < std:: invoke_result_t < F, T >> . Falls * this einen Wert enthält, wird ein std:: optional < U > zurückgegeben, dessen enthaltener Wert direkt-initialisiert wird aus std:: invoke ( std:: forward < F > ( f ) , std :: move ( ** this ) ) . Andernfalls wird ein leeres std:: optional < U > zurückgegeben.
Das Programm ist fehlerhaft, falls die Variablendefinition U x ( std:: invoke ( std:: forward < F > ( f ) , std :: move ( ** this ) ) ) ; fehlerhaft ist.
4) Gleich wie (3) , außer dass U std:: remove_cv_t < std:: invoke_result_t < F, const T >> ist.

Inhaltsverzeichnis

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)