Namespaces
Variants

std::optional<T>:: transform

From cppreference.net
C++
Utilities library
std::optional
template < class F >
constexpr auto transform ( F && f ) & ;
(1) (depuis C++23)
template < class F >
constexpr auto transform ( F && f ) const & ;
(2) (depuis C++23)
template < class F >
constexpr auto transform ( F && f ) && ;
(3) (depuis C++23)
template < class F >
constexpr auto transform ( F && f ) const && ;
(4) (depuis C++23)

Si * this contient une valeur, invoque f avec la valeur contenue comme argument, et retourne un std::optional qui contient le résultat de cette invocation ; sinon, retourne un std::optional vide.

Le type de valeur contenue dans le résultat (désigné par U ci-dessous) doit être un type objet non-tableau, et ne doit pas être std::in_place_t ou std::nullopt_t ). Sinon, le programme est mal formé.

1) Soit U défini comme std:: remove_cv_t < std:: invoke_result_t < F, T & >> . Si * this contient une valeur, retourne un std:: optional < U > dont la valeur contenue est initialisée directement à partir de std:: invoke ( std:: forward < F > ( f ) , ** this ) (contrairement à and_then() , qui doit retourner un std::optional directement). Sinon, retourne un std:: optional < U > vide.
Le programme est mal formé si la définition de variable U x ( std:: invoke ( std:: forward < F > ( f ) , ** this ) ) ; est mal formée.
2) Identique à (1) , sauf que U est std:: remove_cv_t < std:: invoke_result_t < F, const T & >> .
3) Soit U défini comme std:: remove_cv_t < std:: invoke_result_t < F, T >> . Si * this contient une valeur, retourne un std:: optional < U > dont la valeur contenue est initialisée directement par std:: invoke ( std:: forward < F > ( f ) , std :: move ( ** this ) ) . Sinon, retourne un std:: optional < U > vide.
Le programme est mal formé si la définition de variable U x ( std:: invoke ( std:: forward < F > ( f ) , std :: move ( ** this ) ) ) ; est mal formée.
4) Identique à (3) , sauf que U est std:: remove_cv_t < std:: invoke_result_t < F, const T >> .

Table des matières

Paramètres

f - une fonction appropriée ou Callable objet dont la signature d'appel retourne un type non-référence

Valeur de retour

Un std::optional contenant le résultat de f ou un std::optional vide, comme décrit ci-dessus.

Notes

Parce que transform construit directement un objet U à l'emplacement approprié, plutôt que de le passer à un constructeur, std:: is_move_constructible_v < U > peut être false .

Comme l'appelable f ne peut pas retourner un type référence, il ne peut pas être un pointeur vers membre de données .

Certains langages appellent cette opération map .

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_optional 202110L (C++23) Opérations monadiques dans std::optional

Exemple

Exécuter ce code 
#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( {} );
}

Sortie : 

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

Voir aussi

renvoie la valeur contenue si disponible, une autre valeur sinon
(fonction membre publique)
(C++23)
renvoie le résultat de la fonction donnée sur la valeur contenue si elle existe, ou un optional vide sinon
(fonction membre publique)
(C++23)
renvoie le optional lui-même s'il contient une valeur, ou le résultat de la fonction donnée sinon
(fonction membre publique)