Lambda expressions (since C++11)

Construit une closure (un objet fonction anonyme capable de capturer les variables dans la portée).

Syntaxe

Expressions lambda sans liste de paramètres de modèle explicite (éventuellement non génériques)

Expressions lambda avec une liste de paramètres de modèle explicite (toujours générique) (depuis C++20)

Explication

Une variable __func__ est implicitement définie au début du corps , avec une sémantique comme décrite ici .

Type de fermeture

L'expression lambda est une expression prvalue d'un type de classe non-union non-agrégat unique et sans nom, appelé type de fermeture , qui est déclaré (aux fins de ADL ) dans la plus petite portée de bloc, de classe ou d'espace de noms qui contient l'expression lambda.

Le type de fermeture possède les membres suivants, ils ne peuvent pas être explicitement instanciés , explicitement spécialisés , ou (depuis C++14) nommés dans une déclaration friend :

// generic lambda, operator() is a template with two parameters
auto glambda = [](auto a, auto&& b) { return a < b; };
bool b = glambda(3, 3.14); // OK
// generic lambda, operator() is a template with one parameter
auto vglambda = [](auto printer)
{
    return [=](auto&&... ts) // generic lambda, ts is a parameter pack
    { 
        printer(std::forward<decltype(ts)>(ts)...);
        // nullary lambda (takes no parameters):
        return [=] { printer(ts...); };
    };
};
auto p = vglambda([](auto v1, auto v2, auto v3)
{
    std::cout << v1 << v2 << v3;
});
auto q = p(1, 'a', 3.14); // outputs 1a3.14
q();                      // outputs 1a3.14

// generic lambda, operator() is a template with two parameters
auto glambda = []<class T>(T a, auto&& b) { return a < b; };
// generic lambda, operator() is a template with one parameter pack
auto f = []<typename... Ts>(Ts&&... ts)
{
    return foo(std::forward<Ts>(ts)...);
};

struct X
{
    int x, y;
    int operator()(int);
    void f()
    {
        // le contexte de la lambda suivante est la fonction membre X::f
        [=]() -> int
        {
            return operator()(this->x + y); // X::operator()(this->x + (*this).y)
                                            // this a le type X*
        };
    }
};

1. ↑ Bien que la déduction du type de retour des fonctions soit introduite en C++14, sa règle est disponible pour la déduction du type de retour des lambda en C++11.

void f1(int (*)(int)) {}
void f2(char (*)(int)) {}
void h(int (*)(int)) {}  // #1
void h(char (*)(int)) {} // #2
auto glambda = [](auto a) { return a; };
f1(glambda); // OK
f2(glambda); // erreur : non convertible
h(glambda);  // OK : appelle #1 car #2 n'est pas convertible
int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK

auto Fwd = [](int(*fp)(int), auto a) { return fp(a); };
auto C = [](auto a) { return a; };
static_assert(Fwd(C, 3) == 3);  // OK
auto NC = [](auto a) { static int s; return a; };
static_assert(Fwd(NC, 3) == 3); // error: no specialization can be
                                // constexpr because of static s

Capture de lambda

Les captures définissent les variables externes accessibles depuis le corps de la fonction lambda. Sa syntaxe est définie comme suit :

La syntaxe de capture est définie comme suit :

Si le capture-default est & , les captures simples suivantes ne doivent pas commencer par & .

struct S2 { void f(int i); };
void S2::f(int i)
{
    [&] {};          // OK : capture par référence par défaut
    [&, i] {};       // OK : capture par référence, sauf i qui est capturé par copie
    [&, &i] {};      // Erreur : capture par référence lorsque la capture par référence est le défaut
    [&, this] {};    // OK, équivalent à [&]
    [&, this, i] {}; // OK, équivalent à [&, i]
}

Si la capture-par-défaut est = , les captures simples suivantes doivent commencer par & ou être *this (depuis C++17) ou this (depuis C++20) .

struct S2 { void f(int i); };
void S2::f(int i)
{
    [=] {};        // OK : capture par défaut par copie
    [=, &i] {};    // OK : capture par copie, sauf i capturé par référence
    [=, *this] {}; // jusqu'à C++17 : Erreur : syntaxe invalide
                   // depuis C++17 : OK : capture l'objet S2 englobant par copie
    [=, this] {};  // jusqu'à C++20 : Erreur : this lorsque = est la valeur par défaut
                   // depuis C++20 : OK, identique à [=]
}

Toute capture ne peut apparaître qu'une seule fois, et son nom doit être différent de tout nom de paramètre :

struct S2 { void f(int i); };
void S2::f(int i)
{
    [i, i] {};        // Erreur : i répété
    [this, *this] {}; // Erreur : "this" répété (C++17)
    [i] (int i) {};   // Erreur : paramètre et capture ont le même nom
}

Une expression lambda peut utiliser une variable sans la capturer si la variable

• est une variable non locale ou possède une durée de stockage statique ou thread_local (auquel cas la variable ne peut pas être capturée), ou
• est une référence qui a été initialisée avec une expression constante .

Une expression lambda peut lire la valeur d'une variable sans la capturer si la variable

• a un type intégral ou énumération const non volatile et a été initialisé avec une expression constante , ou
• est constexpr et n'a pas de membres mutable.

L'objet actuel ( * this ) peut être capturé implicitement si un défaut de capture est présent. S'il est capturé implicitement, il est toujours capturé par référence, même si le défaut de capture est = . La capture implicite de * this lorsque le défaut de capture est = est dépréciée. (depuis C++20)

Seules les expressions lambda satisfaisant l'une des conditions suivantes peuvent avoir une capture-default ou une capture sans initialiseurs :

• Sa portée la plus interne englobante est une portée de bloc .
• Il apparaît dans un initialiseur de membre par défaut , et sa portée la plus interne englobante est la portée de classe correspondante.

Pour une telle expression lambda, la portée atteignable est définie comme l'ensemble des portées englobantes jusqu'à et y compris la fonction englobante la plus interne (et ses paramètres). Cela inclut les portées de blocs imbriqués et les portées des lambdas englobants si ce lambda est imbriqué.

L' identifiant dans toute capture sans initialiseur (autre que la capture this ) est recherché en utilisant la recherche de nom non qualifiée habituelle dans la portée englobante de la lambda. Le résultat de la recherche doit être une variable avec une durée de stockage automatique déclarée dans la portée englobante , ou une liaison structurée dont la variable correspondante satisfait à ces exigences (depuis C++20) . L'entité est explicitement capturée .

int x = 4;
auto y = [&r = x, x = x + 1]() -> int
{
    r += 2;
    return x * x;
}(); // met à jour ::x à 6 et initialise y à 25.

Si captures a une capture-default et ne capture pas explicitement l'objet englobant (comme this ou * this ), ou une variable automatique qui est odr-usable dans le corps de la lambda , ou une structured binding dont la variable correspondante a une durée de stockage atomique (depuis C++20) , elle capture l'entité implicitement si l'entité est nommée dans une expression potentiellement évaluée au sein d'une expression (y compris lorsque le this - > implicite est ajouté avant une utilisation d'un membre de classe non statique).

Pour déterminer les captures implicites, typeid n'est jamais considéré comme rendant ses opérandes non évalués.

void f(int, const int (&)[2] = {}) {}   // #1
void f(const int&, const int (&)[1]) {} // #2
struct NoncopyableLiteralType
{
    constexpr explicit NoncopyableLiteralType(int n) : n_(n) {}
    NoncopyableLiteralType(const NoncopyableLiteralType&) = delete;
    int n_;
};
void test()
{
    const int x = 17;
    auto l0 = []{ f(x); };           // OK : appelle #1, ne capture pas x
    auto g0 = [](auto a) { f(x); };  // identique au précédent
    auto l1 = [=]{ f(x); };          // OK : capture x (depuis P0588R1) et appelle #1
                                     // la capture peut être optimisée
    auto g1 = [=](auto a) { f(x); }; // identique au précédent
    auto ltid = [=]{ typeid(x); };   // OK : capture x (depuis P0588R1)
                                     // même si x n'est pas évalué
                                     // la capture peut être optimisée
    auto g2 = [=](auto a)
    {
        int selector[sizeof(a) == 1 ? 1 : 2] = {};
        f(x, selector); // OK : expression dépendante, donc capture x
    };
    auto g3 = [=](auto a)
    {
        typeid(a + x);  // capture x indépendamment du fait
                        // que a + x soit un opérande non évalué
    };
    constexpr NoncopyableLiteralType w{42};
    auto l4 = []{ return w.n_; };      // OK : w n'est pas odr-utilisé, capture inutile
    // auto l5 = [=]{ return w.n_; };  // erreur : w doit être capturé par copie
}

Si le corps d'un lambda odr-utilise une entité capturée par copie, le membre du type de fermeture est accédé. S'il n'odr-utilise pas l'entité, l'accès se fait à l'objet original :

void f(const int*);
void g()
{
    const int N = 10;
    [=]
    { 
        int arr[N]; // pas une utilisation odr : fait référence au const int N de g
        f(&N); // utilisation odr : provoque la capture de N (par copie)
               // &N est l'adresse du membre N de l'objet de fermeture, pas de N de g
    }();
}

Si une lambda utilise odr une référence qui est capturée par référence, elle utilise l'objet désigné par la référence originale, et non la référence capturée elle-même :

#include <iostream>
auto make_function(int& x)
{
    return [&] { std::cout << x << '\n'; };
}
int main()
{
    int i = 3;
    auto f = make_function(i); // l'utilisation de x dans f se lie directement à i
    i = 5;
    f(); // OK : affiche 5
}

Dans le corps d'une lambda avec capture par défaut = , le type de toute entité capturable est comme s'il était capturé (et donc une qualification const est souvent ajoutée si la lambda n'est pas mutable ), même si l'entité se trouve dans un opérande non évalué et n'est pas capturée (par exemple dans decltype ):

void f3()
{
    float x, &r = x;
    [=]
    { // x et r ne sont pas capturés (l'apparition dans un opérande decltype n'est pas une odr-use)
        decltype(x) y1;        // y1 a le type float
        decltype((x)) y2 = y1; // y2 a le type float const& car ce lambda
                               // n'est pas mutable et x est une lvalue
        decltype(r) r1 = y1;   // r1 a le type float& (transformation non considérée)
        decltype((r)) r2 = y2; // r2 a le type float const&
    };
}

Toute entité capturée par une lambda (implicitement ou explicitement) est odr-utilisée par l'expression lambda (par conséquent, la capture implicite par une lambda imbriquée déclenche la capture implicite dans la lambda englobante).

Toutes les variables implicitement capturées doivent être déclarées dans la portée atteignable de la lambda.

Si une lambda capture l'objet englobant (comme this ou * this ), soit la fonction englobante la plus proche doit être une fonction membre non statique, soit la lambda doit se trouver dans un initialiseur de membre par défaut :

struct s2
{
    double ohseven = .007;
    auto f() // fonction englobante la plus proche pour les deux lambdas suivantes
    {
        return [this]      // capture l'instance s2 englobante par référence
        {
            return [*this] // capture l'instance s2 englobante par copie (C++17)
            {
                return ohseven; // OK
            }
        }();
    }
    auto g()
    {
        return [] // ne capture rien
        { 
            return [*this] {}; // erreur : *this non capturé par l'expression lambda externe
        }();
    }
};

Si une expression lambda (ou une spécialisation de l'opérateur d'appel de fonction d'une lambda générique) (depuis C++14) utilise ODR * this ou toute variable avec durée de stockage automatique, elle doit être capturée par l'expression lambda.

void f1(int i)
{
    int const N = 20;
    auto m1 = [=]
    {
        int const M = 30;
        auto m2 = [i]
        {
            int x[N][M]; // N et M ne sont pas odr-utilisés
                         // (correct qu'ils ne soient pas capturés)
            x[0][0] = i; // i est explicitement capturé par m2
                         // et implicitement capturé par m1
        };
    };
    struct s1 // classe locale dans f1()
    {
        int f;
        void work(int n) // fonction membre non-statique
        {
            int m = n * n;
            int j = 40;
            auto m3 = [this, m]
            {
                auto m4 = [&, j] // erreur : j n'est pas capturé par m3
                {
                    int x = n; // erreur : n est implicitement capturé par m4
                               // mais pas capturé par m3
                    x += m;    // OK : m est implicitement capturé par m4
                               // et explicitement capturé par m3
                    x += i;    // erreur : i est en dehors de la portée atteignable
                               // (qui se termine à work())
                    x += f;    // OK : this est capturé implicitement par m4
                               // et explicitement capturé par m3
                };
            };
        }
    };
}

Les membres de classe ne peuvent pas être capturés explicitement par une capture sans initialiseur (comme mentionné ci-dessus, seules les variables sont autorisées dans la capture-list ):

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
    //  auto l1 = [i, x] { use(i, x); };      // erreur : x n'est pas une variable
        auto l2 = [i, x = x] { use(i, x); };  // OK, capture par copie
        i = 1; x = 1; l2(); // appelle use(0,0)
        auto l3 = [i, &x = x] { use(i, x); }; // OK, capture par référence
        i = 2; x = 2; l3(); // appelle use(1,2)
    }
};

Lorsqu'un lambda capture un membre par copie implicite, il ne fait pas de copie de cette variable membre : l'utilisation d'une variable membre m est traitée comme une expression ( * this ) . m , et * this est toujours implicitement capturé par référence :

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
        auto l1 = [=] { use(i, x); }; // capture une copie de i et
                                      // une copie du pointeur this
        i = 1; x = 1; l1();           // appelle use(0, 1), comme si
                                      // i par copie et x par référence
        auto l2 = [i, this] { use(i, x); }; // identique au précédent, rendu explicite
        i = 2; x = 2; l2();           // appelle use(1, 2), comme si
                                      // i par copie et x par référence
        auto l3 = [&] { use(i, x); }; // capture i par référence et
                                      // une copie du pointeur this
        i = 3; x = 2; l3();           // appelle use(3, 2), comme si
                                      // i et x sont tous deux par référence
        auto l4 = [i, *this] { use(i, x); }; // effectue une copie de *this,
                                             // incluant une copie de x
        i = 4; x = 4; l4();           // appelle use(3, 2), comme si
                                      // i et x sont tous deux par copie
    }
};

Si une expression lambda apparaît dans un argument par défaut , elle ne peut rien capturer explicitement ou implicitement , sauf si toutes les captures ont des initialiseurs qui satisfont aux contraintes d'une expression apparaissant dans un argument par défaut (depuis C++14) :

void f2()
{
    int i = 1;
    void g1( int = [i] { return i; }() ); // erreur : capture quelque chose
    void g2( int = [i] { return 0; }() ); // erreur : capture quelque chose
    void g3( int = [=] { return i; }() ); // erreur : capture quelque chose
    void g4( int = [=] { return 0; }() );       // OK : sans capture
    void g5( int = [] { return sizeof i; }() ); // OK : sans capture
    // C++14
    void g6( int = [x = 1] { return x; }() ); // OK : 1 peut apparaître
                                              //     dans un argument par défaut
    void g7( int = [x = i] { return x; }() ); // erreur : i ne peut pas apparaître
                                              //        dans un argument par défaut
}

Les membres des unions anonymes ne peuvent pas être capturés. Les champs de bits ne peuvent être capturés que par copie.

Si une lambda imbriquée m2 capture quelque chose qui est également capturée par la lambda englobante immédiate m1 , alors la capture de m2 est transformée comme suit :

• si le lambda englobant m1 capture par copie, m2 capture le membre non statique du type de fermeture de m1 , et non la variable originale ou * this ; si m1 n'est pas mutable, le membre de données non statique est considéré comme qualifié const.
• si le lambda englobant m1 capture par référence, m2 capture la variable originale ou * this .

#include <iostream>
int main()
{
    int a = 1, b = 1, c = 1;
    auto m1 = [a, &b, &c]() mutable
    {
        auto m2 = [a, b, &c]() mutable
        {
            std::cout << a << b << c << '\n';
            a = 4; b = 4; c = 4;
        };
        a = 3; b = 3; c = 3;
        m2();
    };
    a = 2; b = 2; c = 2;
    m1();                             // appelle m2() et affiche 123
    std::cout << a << b << c << '\n'; // affiche 234
}

struct C 
{
    template<typename T>
    C(T);
};
void func(int i) 
{
    int x = [=](this auto&&) { return i; }();  // OK
    int y = [=](this C) { return i; }();       // error
    int z = [](this C) { return 42; }();       // OK
    auto lambda = [n = 42] (this auto self) { return n; };
    using Closure = decltype(lambda);
    struct D : private Closure {
        D(Closure l) : Closure(l) {}
        using Closure::operator();
        friend Closure;
    };
    D{lambda}(); // error
}

Notes

La règle pour la capture implicite des lambdas est légèrement modifiée par le rapport de défaut P0588R1 . En date d'octobre 2023, certaines implémentations majeures n'ont pas complètement implémenté ce DR, et donc l'ancienne règle, qui détecte l'utilisation ODR , est encore utilisée dans certains cas.

Exemple

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> c{1, 2, 3, 4, 5, 6, 7};
    int x = 5;
    c.erase(std::remove_if(c.begin(), c.end(), [x](int n) { return n < x; }), c.end());
    std::cout << "c: ";
    std::for_each(c.begin(), c.end(), [](int i) { std::cout << i << ' '; });
    std::cout << '\n';
    // le type d'une fermeture ne peut pas être nommé, mais peut être déduit avec auto
    // depuis C++14, les lambda peuvent posséder des arguments par défaut
    auto func1 = [](int i = 6) { return i + 4; };
    std::cout << "func1: " << func1() << '\n';
    // comme tous les objets appelables, les fermetures peuvent être capturées dans std::function
    // (cela peut entraîner une surcharge inutile)
    std::function<int(int)> func2 = [](int i) { return i + 4; };
    std::cout << "func2: " << func2(6) << '\n';
    constexpr int fib_max {8};
    std::cout << "Émuler les appels de `lambda récursive` :\nNombres de Fibonacci : ";
    auto nth_fibonacci = [](int n)
    {
        std::function<int(int, int, int)> fib = [&](int n, int a, int b)
        {
            return n ? fib(n - 1, a + b, a) : b;
        };
        return fib(n, 0, 1);
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci(i) << (i < fib_max ? ", " : "\n");
    std::cout << "Approche alternative pour la récursion lambda :\nNombres de Fibonacci : ";
    auto nth_fibonacci2 = [](auto self, int n, int a = 0, int b = 1) -> int
    {
        return n ? self(self, n - 1, a + b, a) : b;
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci2(nth_fibonacci2, i) << (i < fib_max ? ", " : "\n");
#ifdef __cpp_explicit_this_parameter
    std::cout << "Approche C++23 pour la récursion lambda:\n";
    auto nth_fibonacci3 = [](this auto self, int n, int a = 0, int b = 1) -> int
    {
         return n ? self(n - 1, a + b, a) : b;
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci3(i) << (i < fib_max ? ", " : "\n");
#endif
}

c: 5 6 7
func1: 10
func2: 10
Émuler les appels de `lambda récursifs`:
Nombres de Fibonacci : 0, 1, 1, 2, 3, 5, 8, 13
Approche alternative pour la récursion lambda:
Nombres de Fibonacci : 0, 1, 1, 2, 3, 5, 8, 13

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi

Liens externes