Namespaces
Variants

    std::optional<T>::transform

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Libre et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support langage
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostic
    Bibliothèque de gestion mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et heure
    Bibliothèque d'entrée/sortie
    Bibliothèque du système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque d'utilitaires
    Support langage
    Support des types (types de base, RTTI)
    Macros de test de fonctionnalités de la bibliothèque (C++20)
    Utilitaires de programme
    Fonctions variadiques
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Support des coroutines (C++20)
    Support des contrats (C++26)
    Comparaison à trois voies
    (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)

    Utilitaires généraux
    Opérateurs relationnels (déprécié en C++20)
     
    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 renvoie un std::optional qui contient le résultat de cette invocation ; sinon, renvoie un std::optional vide.

    Le type de la valeur contenue dans le résultat (noté U ci-dessous) doit être un type d'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 égal à std::remove_cv_t<std::invoke_result_t<F, T&>>. Si *this contient une valeur, renvoie 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 renvoyer un std::optional directement). Sinon, renvoie 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 égal à std::remove_cv_t<std::invoke_result_t<F, T>>. Si *this contient une valeur, renvoie un std::optional<U> dont la valeur contenue est initialisée-directement à partir de std::invoke(std::forward<F>(f), std::move(**this)). Sinon, renvoie 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>>.

    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)