Lambda expressions (since C++11)

Construye un closure (un objeto función anónimo capaz de capturar variables en el ámbito).

Sintaxis

Expresiones lambda sin una lista de parámetros de plantilla explícita (posiblemente no genéricas)

Expresiones lambda con una lista de parámetros de plantilla explícita (siempre genéricas) (since C++20)

Explicación

Una variable __func__ está definida implícitamente al inicio del cuerpo , con semántica como se describe aquí .

Tipo de clausura

La expresión lambda es una expresión prvalue de tipo de clase único, sin nombre, no union , no aggregate , conocido como closure type , que se declara (para los propósitos de ADL ) en el ámbito de bloque, ámbito de clase o ámbito de namespace más pequeño que contiene la expresión lambda.

El tipo de clausura tiene los siguientes miembros, los cuales no pueden ser explícitamente instanciados , explícitamente especializados , o (desde C++14) nombrados en una declaración 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()
    {
        // el contexto de la siguiente lambda es la función miembro X::f
        [=]() -> int
        {
            return operator()(this->x + y); // X::operator()(this->x + (*this).y)
                                            // this tiene tipo X*
        };
    }
};

1. ↑ Aunque la deducción del tipo de retorno de funciones se introduce en C++14, su regla está disponible para la deducción del tipo de retorno de lambdas 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); // error: no convertible
h(glambda);  // OK: llama a #1 ya que #2 no es 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

Captura de lambda

Las captures definen las variables externas que son accesibles desde dentro del cuerpo de la función lambda. Su sintaxis se define de la siguiente manera:

La sintaxis de capture se define de la siguiente manera:

Si la capture-default es & , las capturas simples posteriores no deben comenzar con & .

struct S2 { void f(int i); };
void S2::f(int i)
{
    [&] {};          // OK: captura por referencia por defecto
    [&, i] {};       // OK: captura por referencia, excepto i que se captura por copia
    [&, &i] {};      // Error: captura por referencia cuando por referencia es el valor por defecto
    [&, this] {};    // OK, equivalente a [&]
    [&, this, i] {}; // OK, equivalente a [&, i]
}

Si la captura-por-defecto es = , las capturas simples posteriores deben comenzar con & o ser *this (desde C++17) o this (desde C++20) .

struct S2 { void f(int i); };
void S2::f(int i)
{
    [=] {};        // OK: captura por copia por defecto
    [=, &i] {};    // OK: captura por copia, excepto i que se captura por referencia
    [=, *this] {}; // hasta C++17: Error: sintaxis inválida
                   // desde C++17: OK: captura el S2 envolvente por copia
    [=, this] {};  // hasta C++20: Error: this cuando = es el valor por defecto
                   // desde C++20: OK, igual que [=]
}

Cualquier captura puede aparecer solo una vez, y su nombre debe ser diferente de cualquier nombre de parámetro:

struct S2 { void f(int i); };
void S2::f(int i)
{
    [i, i] {};        // Error: i repetido
    [this, *this] {}; // Error: "this" repetido (C++17)
    [i] (int i) {};   // Error: parámetro y captura tienen el mismo nombre
}

Una expresión lambda puede usar una variable sin capturarla si la variable

• es una variable no local o tiene duración de almacenamiento estática o local de hilo (en cuyo caso la variable no puede ser capturada), o
• es una referencia que ha sido inicializada con una expresión constante .

Una expresión lambda puede leer el valor de una variable sin capturarla si la variable

• tiene un tipo integral o de enumeración const no volátil y ha sido inicializado con una expresión constante , o
• es constexpr y no tiene miembros mutables.

El objeto actual ( * this ) puede ser capturado implícitamente si existe un modo de captura por defecto. Si se captura implícitamente, siempre se captura por referencia, incluso si el modo de captura por defecto es = . La captura implícita de * this cuando el modo de captura por defecto es = está obsoleta. (since C++20)

Solo las expresiones lambda que cumplan con alguna de las siguientes condiciones pueden tener un capture-default o capture sin inicializadores:

• Su ámbito más interno circundante es un ámbito de bloque .
• Aparece dentro de un inicializador de miembro predeterminado , y su ámbito más interno circundante es el ámbito de clase correspondiente.

Para tal expresión lambda, el ámbito de alcance se define como el conjunto de ámbitos envolventes hasta e incluyendo la función envolvente más interna (y sus parámetros). Esto incluye ámbitos de bloques anidados y los ámbitos de lambdas envolventes si esta lambda está anidada.

El identificador en cualquier captura sin un inicializador (distinta de la captura this ) se busca utilizando la búsqueda de nombre no calificada habitual en el ámbito de alcance de la lambda. El resultado de la búsqueda debe ser una variable con duración de almacenamiento automático declarada en el ámbito de alcance , o un enlace estructurado cuya variable correspondiente cumpla con dichos requisitos (desde C++20) . La entidad es explícitamente capturada .

int x = 4;
auto y = [&r = x, x = x + 1]() -> int
{
    r += 2;
    return x * x;
}(); // actualiza ::x a 6 e inicializa y a 25.

Si captures tiene un capture-default y no captura explícitamente el objeto envolvente (como this o * this ), o una variable automática que es odr-usable en el cuerpo de la lambda , o un structured binding cuya variable correspondiente tiene duración de almacenamiento atómica (since C++20) , captura la entidad implícitamente si la entidad se nombra en una expresión potencialmente evaluada dentro de una expresión (incluyendo cuando el this - > implícito se añade antes de un uso de un miembro no estático de la clase).

Para el propósito de determinar capturas implícitas, typeid nunca se considera para hacer que sus operandos no sean evaluados.

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: llama a #1, no captura x
    auto g0 = [](auto a) { f(x); };  // igual que arriba
    auto l1 = [=]{ f(x); };          // OK: captura x (desde P0588R1) y llama a #1
                                     // la captura puede optimizarse
    auto g1 = [=](auto a) { f(x); }; // igual que arriba
    auto ltid = [=]{ typeid(x); };   // OK: captura x (desde P0588R1)
                                     // aunque x no se evalúa
                                     // la captura puede optimizarse
    auto g2 = [=](auto a)
    {
        int selector[sizeof(a) == 1 ? 1 : 2] = {};
        f(x, selector); // OK: es una expresión dependiente, así que captura x
    };
    auto g3 = [=](auto a)
    {
        typeid(a + x);  // captura x independientemente de
                        // si a + x es un operando no evaluado
    };
    constexpr NoncopyableLiteralType w{42};
    auto l4 = []{ return w.n_; };      // OK: w no se usa como odr, la captura es innecesaria
    // auto l5 = [=]{ return w.n_; };  // error: w necesita ser capturado por copia
}

Si el cuerpo de una lambda odr-uses una entidad capturada por copia, se accede al miembro del tipo de clausura. Si no está odr-using la entidad, el acceso es al objeto original:

void f(const int*);
void g()
{
    const int N = 10;
    [=]
    { 
        int arr[N]; // no es un odr-use: se refiere al const int N de g
        f(&N); // odr-use: provoca que N sea capturado (por copia)
               // &N es la dirección del miembro N del objeto de clausura, no del N de g
    }();
}

Si una lambda utiliza odr-una referencia que es capturada por referencia, está utilizando el objeto referido por la referencia original, no la referencia capturada en sí misma:

#include <iostream>
auto make_function(int& x)
{
    return [&] { std::cout << x << '\n'; };
}
int main()
{
    int i = 3;
    auto f = make_function(i); // el uso de x en f se vincula directamente a i
    i = 5;
    f(); // OK: imprime 5
}

Dentro del cuerpo de una lambda con captura por defecto = , el tipo de cualquier entidad capturable es como si fuera capturada (y por lo tanto a menudo se añade calificación const si la lambda no es mutable ), incluso si la entidad está en un operando no evaluado y no es capturada (por ejemplo, en decltype ):

void f3()
{
    float x, &r = x;
    [=]
    { // x y r no son capturadas (la aparición en un operando decltype no es un odr-use)
        decltype(x) y1;        // y1 tiene tipo float
        decltype((x)) y2 = y1; // y2 tiene tipo float const& porque este lambda
                               // no es mutable y x es un lvalue
        decltype(r) r1 = y1;   // r1 tiene tipo float& (transformación no considerada)
        decltype((r)) r2 = y2; // r2 tiene tipo float const&
    };
}

Cualquier entidad capturada por un lambda (implícitamente o explícitamente) es odr-used por la expresión lambda (por lo tanto, la captura implícita por un lambda anidado activa la captura implícita en el lambda que lo engloba).

Todas las variables capturadas implícitamente deben declararse dentro del alcance de accesibilidad de la lambda.

Si una lambda captura el objeto envolvente (como this o * this ), la función envolvente más cercana debe ser una función miembro no estática o la lambda debe estar en un inicializador de miembro predeterminado :

struct s2
{
    double ohseven = .007;
    auto f() // función envolvente más cercana para los siguientes dos lambdas
    {
        return [this]      // capturar el s2 envolvente por referencia
        {
            return [*this] // capturar el s2 envolvente por copia (C++17)
            {
                return ohseven; // OK
            }
        }();
    }
    auto g()
    {
        return [] // no capturar nada
        { 
            return [*this] {}; // error: *this no capturado por la expresión lambda externa
        }();
    }
};

Si una expresión lambda (o una especialización del operador de llamada a función de una lambda genérica) (desde C++14) utiliza ODR * this o cualquier variable con duración de almacenamiento automático, debe ser capturada por la expresión lambda.

void f1(int i)
{
    int const N = 20;
    auto m1 = [=]
    {
        int const M = 30;
        auto m2 = [i]
        {
            int x[N][M]; // N y M no son odr-usadas
                         // (está bien que no sean capturadas)
            x[0][0] = i; // i es capturada explícitamente por m2
                         // e implícitamente capturada por m1
        };
    };
    struct s1 // clase local dentro de f1()
    {
        int f;
        void work(int n) // función miembro no estática
        {
            int m = n * n;
            int j = 40;
            auto m3 = [this, m]
            {
                auto m4 = [&, j] // error: j no es capturada por m3
                {
                    int x = n; // error: n es capturada implícitamente por m4
                               // pero no es capturada por m3
                    x += m;    // OK: m es capturada implícitamente por m4
                               // y explícitamente capturada por m3
                    x += i;    // error: i está fuera del alcance de captura
                               // (que termina en work())
                    x += f;    // OK: this es capturado implícitamente por m4
                               // y explícitamente capturado por m3
                };
            };
        }
    };
}

Los miembros de clase no pueden capturarse explícitamente mediante una captura sin inicializador (como se mencionó anteriormente, solo se permiten variables en la capture-list ):

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
    //  auto l1 = [i, x] { use(i, x); };      // error: x no es una variable
        auto l2 = [i, x = x] { use(i, x); };  // OK, captura por copia
        i = 1; x = 1; l2(); // llama a use(0,0)
        auto l3 = [i, &x = x] { use(i, x); }; // OK, captura por referencia
        i = 2; x = 2; l3(); // llama a use(1,2)
    }
};

Cuando una lambda captura un miembro mediante captura implícita por copia, no realiza una copia de esa variable miembro: el uso de una variable miembro m se trata como una expresión ( * this ) . m , y * this siempre se captura implícitamente por referencia:

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
        auto l1 = [=] { use(i, x); }; // captura una copia de i y
                                      // una copia del puntero this
        i = 1; x = 1; l1();           // llama a use(0, 1), como si
                                      // i fuera por copia y x por referencia
        auto l2 = [i, this] { use(i, x); }; // igual que arriba, hecho explícito
        i = 2; x = 2; l2();           // llama a use(1, 2), como si
                                      // i fuera por copia y x por referencia
        auto l3 = [&] { use(i, x); }; // captura i por referencia y
                                      // una copia del puntero this
        i = 3; x = 2; l3();           // llama a use(3, 2), como si
                                      // tanto i como x fueran por referencia
        auto l4 = [i, *this] { use(i, x); }; // hace una copia de *this,
                                             // incluyendo una copia de x
        i = 4; x = 4; l4();           // llama a use(3, 2), como si
                                      // tanto i como x fueran por copia
    }
};

Si una expresión lambda aparece en un argumento por defecto , no puede capturar nada explícita o implícitamente , a menos que todas las capturas tengan inicializadores que satisfagan las restricciones de una expresión que aparece en un argumento por defecto (desde C++14) :

void f2()
{
    int i = 1;
    void g1( int = [i] { return i; }() ); // error: captura algo
    void g2( int = [i] { return 0; }() ); // error: captura algo
    void g3( int = [=] { return i; }() ); // error: captura algo
    void g4( int = [=] { return 0; }() );       // OK: sin captura
    void g5( int = [] { return sizeof i; }() ); // OK: sin captura
    // C++14
    void g6( int = [x = 1] { return x; }() ); // OK: 1 puede aparecer
                                              //     en un argumento por defecto
    void g7( int = [x = i] { return x; }() ); // error: i no puede aparecer
                                              //        en un argumento por defecto
}

Los miembros de anonymous unions no pueden ser capturados. Los bit-fields solo pueden ser capturados por copia.

Si una lambda anidada m2 captura algo que también es capturado por la lambda envolvente inmediata m1 , entonces la captura de m2 se transforma de la siguiente manera:

• si la lambda envolvente m1 captura por copia, m2 está capturando el miembro no estático del tipo de clausura de m1 , no la variable original o * this ; si m1 no es mutable, el miembro de datos no estático se considera calificado como const.
• si la lambda envolvente m1 captura por referencia, m2 está capturando la variable original o * 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();                             // llama a m2() e imprime 123
    std::cout << a << b << c << '\n'; // imprime 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
}

Notas

La regla para la captura implícita de lambdas se modifica ligeramente por el informe de defectos P0588R1 . A partir de octubre de 2023, algunas implementaciones principales no han implementado completamente el DR, y por lo tanto la regla anterior, que detecta odr-use , todavía se utiliza en algunos casos.

Ejemplo

#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';
    // el tipo de una clausura no puede ser nombrado, pero puede ser inferido con auto
    // desde C++14, lambda puede tener argumentos predeterminados
    auto func1 = [](int i = 6) { return i + 4; };
    std::cout << "func1: " << func1() << '\n';
    // como todos los objetos invocables, los closures pueden capturarse en std::function
    // (esto puede generar una sobrecarga innecesaria)
    std::function<int(int)> func2 = [](int i) { return i + 4; };
    std::cout << "func2: " << func2(6) << '\n';
    constexpr int fib_max {8};
    std::cout << "Emular llamadas `recursive lambda`:\nNúmeros 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 << "Enfoque alternativo para la recursión lambda:\nNúmeros 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 << "Enfoque de C++23 para la recursión de lambdas:\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
Emular llamadas `recursive lambda`:
Números de Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13
Enfoque alternativo para recursión lambda:
Números de Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Véase también

Enlaces externos