Lambda expressions (since C++11)

Создаёт closure (безымянный функциональный объект, способный захватывать переменные из области видимости).

Синтаксис

Лямбда-выражения без явного списка параметров шаблона (возможно, негенерические)

Лямбда-выражения с явным списком параметров шаблона (всегда обобщённые) (начиная с C++20)

Объяснение

Переменная __func__ неявно определяется в начале тела функции , с семантикой, описанной здесь .

Тип замыкания

Лямбда-выражение является prvalue-выражением уникального безымянного не- union не- aggregate типа класса, известного как closure type , который объявляется (для целей ADL ) в наименьшей области видимости блока, класса или пространства имен, содержащей лямбда-выражение.

Тип замыкания имеет следующие члены, они не могут быть явно инстанцированы , явно специализированы , или (начиная с C++14) указаны в объявлении дружественной функции :

// 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()
    {
        // контекст следующей лямбды - функция-член X::f
        [=]() -> int
        {
            return operator()(this->x + y); // X::operator()(this->x + (*this).y)
                                            // this имеет тип X*
        };
    }
};

1. ↑ Хотя вывод типа возвращаемого значения функции был введен в C++14, его правило доступно для вывода типа возвращаемого значения лямбда-выражений в 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: not convertible
h(glambda);  // OK: calls #1 since #2 is not 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 определяется следующим образом:

Если capture-default является & , последующие простые захваты не должны начинаться с & .

struct S2 { void f(int i); };
void S2::f(int i)
{
    [&] {};          // OK: захват по ссылке по умолчанию
    [&, i] {};       // OK: захват по ссылке, кроме i, который захватывается по копии
    [&, &i] {};      // Ошибка: захват по ссылке, когда захват по ссылке установлен по умолчанию
    [&, this] {};    // OK, эквивалентно [&]
    [&, this, i] {}; // OK, эквивалентно [&, i]
}

Если capture-default имеет значение = , последующие простые захваты должны начинаться с & или быть *this (начиная с C++17) или this (начиная с C++20) .

struct S2 { void f(int i); };
void S2::f(int i)
{
    [=] {};        // OK: захват по умолчанию по копии
    [=, &i] {};    // OK: захват по копии, за исключением i, который захватывается по ссылке
    [=, *this] {}; // до C++17: Ошибка: неверный синтаксис
                   // начиная с C++17: OK: захватывает включающий объект S2 по копии
    [=, this] {};  // до C++20: Ошибка: this при = по умолчанию
                   // начиная с C++20: OK, то же самое что [=]
}

Любой захват может появляться только один раз, и его имя должно отличаться от любого имени параметра:

struct S2 { void f(int i); };
void S2::f(int i)
{
    [i, i] {};        // Ошибка: повторение i
    [this, *this] {}; // Ошибка: повторение "this" (C++17)
    [i] (int i) {};   // Ошибка: параметр и захват имеют одинаковое имя
}

Лямбда-выражение может использовать переменную без её захвата, если переменная

• является нелокальной переменной или имеет статическую или локальную для потока продолжительность хранения (в этом случае переменная не может быть захвачена), или
• является ссылкой, которая была инициализирована с помощью константного выражения .

Лямбда-выражение может читать значение переменной без её захвата, если переменная

• имеет константный не-volatile целочисленный или перечисляемый тип и была инициализирована с помощью константного выражения , или
• является constexpr и не имеет изменяемых членов.

Текущий объект ( * this ) может быть неявно захвачен, если присутствует стандартный захват. Если он захвачен неявно, он всегда захватывается по ссылке, даже если стандартный захват имеет значение = . Неявный захват * this при стандартном захвате = устарел. (начиная с C++20)

Только лямбда-выражения, удовлетворяющие любому из следующих условий, могут иметь capture-default или capture без инициализаторов:

• Его самая внутренняя охватывающая область видимости является областью видимости блока .
• Он появляется внутри инициализатора члена по умолчанию , и его самая внутренняя охватывающая область видимости является соответствующей областью видимости класса .

Для такого лямбда-выражения область достижимости определяется как набор охватывающих областей видимости вплоть до и включая самую внутреннюю охватывающую функцию (и её параметры). Это включает вложенные области видимости блоков и области видимости охватывающих лямбда-выражений, если данная лямбда является вложенной.

Идентификатор в любой capture-записи без инициализатора (кроме capture-записи this ) ищется с использованием обычного поиска имени без квалификации в охватывающей области видимости лямбда-выражения. Результатом поиска должна быть переменная с автоматической продолжительностью хранения, объявленная в охватывающей области видимости , либо структурированная привязка , соответствующая переменная которой удовлетворяет указанным требованиям (начиная с C++20) . Сущность является явно захваченной .

int x = 4;
auto y = [&r = x, x = x + 1]() -> int
{
    r += 2;
    return x * x;
}(); // updates ::x to 6 and initializes y to 25.

Если captures имеет capture-default и не захватывает явно объемлющий объект (как this или * this ), или автоматическую переменную, которая является odr-usable в теле лямбды , или structured binding , соответствующая переменная которой имеет атомарную длительность хранения (since C++20) , она захватывает сущность неявно , если сущность упоминается в potentially-evaluated выражении внутри выражения (включая случаи, когда неявный this - > добавляется перед использованием нестатического члена класса).

Для определения неявных захватов, typeid никогда не считается операцией, делающей свои операнды невычисляемыми.

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: вызывает #1, не захватывает x
    auto g0 = [](auto a) { f(x); };  // то же самое, что выше
    auto l1 = [=]{ f(x); };          // OK: захватывает x (начиная с P0588R1) и вызывает #1
                                     // захват может быть оптимизирован
    auto g1 = [=](auto a) { f(x); }; // то же самое, что выше
    auto ltid = [=]{ typeid(x); };   // OK: захватывает x (начиная с P0588R1)
                                     // даже несмотря на то, что x не вычисляется
                                     // захват может быть оптимизирован
    auto g2 = [=](auto a)
    {
        int selector[sizeof(a) == 1 ? 1 : 2] = {};
        f(x, selector); // OK: является зависимым выражением, поэтому захватывает x
    };
    auto g3 = [=](auto a)
    {
        typeid(a + x);  // захватывает x независимо от того,
                        // является ли a + x невычисляемым операндом
    };
    constexpr NoncopyableLiteralType w{42};
    auto l4 = []{ return w.n_; };      // OK: w не используется как odr-выражение, захват не требуется
    // auto l5 = [=]{ return w.n_; };  // ошибка: w должен быть захвачен по копии
}

Если тело лямбда-выражения odr-использует сущность, захваченную по значению, происходит обращение к члену типа замыкания. Если сущность не odr-используется, обращение происходит к исходному объекту:

void f(const int*);
void g()
{
    const int N = 10;
    [=]
    { 
        int arr[N]; // не является odr-использованием: ссылается на const int N функции g
        f(&N); // odr-использование: приводит к захвату N (по копии)
               // &N является адресом члена N объекта замыкания, а не N функции g
    }();
}

Если лямбда ODR-использует ссылку, захваченную по ссылке, она использует объект, на который ссылается исходная ссылка, а не саму захваченную ссылку:

#include <iostream>
auto make_function(int& x)
{
    return [&] { std::cout << x << '\n'; };
}
int main()
{
    int i = 3;
    auto f = make_function(i); // использование x в f напрямую связывается с i
    i = 5;
    f(); // OK: выводит 5
}

В теле лямбды с захватом по умолчанию = , тип любой захватываемой сущности трактуется так, как если бы она была захвачена (и поэтому часто добавляется const-квалификация, если лямбда не mutable ), даже если сущность находится в невычисляемом операнде и не захватывается (например, в decltype ):

void f3()
{
    float x, &r = x;
    [=]
    { // x и r не захватываются (появление в операнде decltype не является odr-использованием)
        decltype(x) y1;        // y1 имеет тип float
        decltype((x)) y2 = y1; // y2 имеет тип float const&, потому что эта лямбда
                               // не является mutable, а x - lvalue
        decltype(r) r1 = y1;   // r1 имеет тип float& (преобразование не рассматривается)
        decltype((r)) r2 = y2; // r2 имеет тип float const&
    };
}

Любая сущность, захваченная лямбдой (неявно или явно), является odr-используемой лямбда-выражением (следовательно, неявный захват вложенной лямбдой вызывает неявный захват в охватывающей лямбде).

Все неявно захваченные переменные должны быть объявлены в пределах достижимой области видимости лямбда-выражения.

Если лямбда захватывает объемлющий объект (как this или * this ), то либо ближайшая объемлющая функция должна быть нестатической функцией-членом, либо лямбда должна находиться в инициализаторе элемента по умолчанию :

struct s2
{
    double ohseven = .007;
    auto f() // ближайшая охватывающая функция для следующих двух лямбда-выражений
    {
        return [this]      // захват охватывающего s2 по ссылке
        {
            return [*this] // захват охватывающего s2 по копии (C++17)
            {
                return ohseven; // OK
            }
        }();
    }
    auto g()
    {
        return [] // ничего не захватывает
        { 
            return [*this] {}; // ошибка: *this не захвачен внешним лямбда-выражением
        }();
    }
};

Если лямбда-выражение (или специализация оператора вызова функции обобщённой лямбды) (since C++14) ODR-использует * this или любую переменную с автоматической продолжительностью хранения, она должна быть захвачена лямбда-выражением.

void f1(int i)
{
    int const N = 20;
    auto m1 = [=]
    {
        int const M = 30;
        auto m2 = [i]
        {
            int x[N][M]; // N и M не используются как odr-использование
                         // (нормально, что они не захвачены)
            x[0][0] = i; // i явно захвачен m2
                         // и неявно захвачен m1
        };
    };
    struct s1 // локальный класс внутри f1()
    {
        int f;
        void work(int n) // нестатическая функция-член
        {
            int m = n * n;
            int j = 40;
            auto m3 = [this, m]
            {
                auto m4 = [&, j] // ошибка: j не захвачен m3
                {
                    int x = n; // ошибка: n неявно захвачен m4
                               // но не захвачен m3
                    x += m;    // OK: m неявно захвачен m4
                               // и явно захвачен m3
                    x += i;    // ошибка: i находится вне области видимости
                               // (которая заканчивается на work())
                    x += f;    // OK: this неявно захвачен m4
                               // и явно захвачен m3
                };
            };
        }
    };
}

Члены класса не могут быть захвачены явно в захвате без инициализатора (как упомянуто выше, только переменные разрешены в capture-list ):

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
    //  auto l1 = [i, x] { use(i, x); };      // ошибка: x не является переменной
        auto l2 = [i, x = x] { use(i, x); };  // OK, захват по копии
        i = 1; x = 1; l2(); // вызывает use(0,0)
        auto l3 = [i, &x = x] { use(i, x); }; // OK, захват по ссылке
        i = 2; x = 2; l3(); // вызывает use(1,2)
    }
};

Когда лямбда захватывает член с помощью неявного захвата по копии, она не создаёт копию этой переменной-члена: использование переменной-члена m трактуется как выражение ( * this ) . m , и * this всегда неявно захватывается по ссылке:

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
        auto l1 = [=] { use(i, x); }; // захватывает копию i и
                                      // копию указателя this
        i = 1; x = 1; l1();           // вызывает use(0, 1), как если бы
                                      // i по копии и x по ссылке
        auto l2 = [i, this] { use(i, x); }; // то же самое, что выше, явно указано
        i = 2; x = 2; l2();           // вызывает use(1, 2), как если бы
                                      // i по копии и x по ссылке
        auto l3 = [&] { use(i, x); }; // захватывает i по ссылке и
                                      // копию указателя this
        i = 3; x = 2; l3();           // вызывает use(3, 2), как если бы
                                      // i и x оба по ссылке
        auto l4 = [i, *this] { use(i, x); }; // создает копию *this,
                                             // включая копию x
        i = 4; x = 4; l4();           // вызывает use(3, 2), как если бы
                                      // i и x оба по копии
    }
};

Если лямбда-выражение появляется в аргументе по умолчанию , оно не может явно или неявно захватывать что-либо , если только все захваты не имеют инициализаторов, удовлетворяющих ограничениям выражения, появляющегося в аргументе по умолчанию (начиная с C++14) :

void f2()
{
    int i = 1;
    void g1( int = [i] { return i; }() ); // ошибка: захватывает что-то
    void g2( int = [i] { return 0; }() ); // ошибка: захватывает что-то
    void g3( int = [=] { return i; }() ); // ошибка: захватывает что-то
    void g4( int = [=] { return 0; }() );       // OK: без захвата
    void g5( int = [] { return sizeof i; }() ); // OK: без захвата
    // C++14
    void g6( int = [x = 1] { return x; }() ); // OK: 1 может присутствовать
                                              //     в аргументе по умолчанию
    void g7( int = [x = i] { return x; }() ); // ошибка: i не может присутствовать
                                              //        в аргументе по умолчанию
}

Члены анонимных объединений не могут быть захвачены. Битовые поля могут быть захвачены только по копии.

Если вложенная лямбда m2 захватывает нечто, что также захватывается непосредственно охватывающей лямбдой m1 , то захват m2 преобразуется следующим образом:

• если внешняя лямбда m1 захватывает по значению, m2 захватывает нестатический член замыкающего типа m1 , а не исходную переменную или * this ; если m1 не является mutable, нестатический член данных считается константно-квалифицированным.
• если внешняя лямбда m1 захватывает по ссылке, m2 захватывает исходную переменную или * 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();                             // вызывает m2() и выводит 123
    std::cout << a << b << c << '\n'; // выводит 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
}

Примечания

Правило для неявного захвата в лямбда-выражениях было немного изменено в соответствии с отчётом о дефекте P0588R1 . По состоянию на октябрь 2023 года некоторые основные реализации ещё не полностью внедрили этот отчёт, поэтому старое правило, которое определяет odr-использование , всё ещё применяется в некоторых случаях.

Пример

#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';
    // тип замыкания не может быть назван, но может быть выведен с помощью auto
    // начиная с C++14, лямбда может иметь аргументы по умолчанию
    auto func1 = [](int i = 6) { return i + 4; };
    std::cout << "func1: " << func1() << '\n';
    // как и все вызываемые объекты, замыкания могут быть захвачены в std::function
    // (это может привести к излишним накладным расходам)
    std::function<int(int)> func2 = [](int i) { return i + 4; };
    std::cout << "func2: " << func2(6) << '\n';
    constexpr int fib_max {8};
    std::cout << "Эмулировать вызовы `рекурсивных лямбда`:\nЧисла Фибоначчи: ";
    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 << "Альтернативный подход к рекурсии лямбда-функций:\nЧисла Фибоначчи: ";
    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 << "Подход C++23 к рекурсии лямбда-функций:\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
Эмуляция вызовов `рекурсивных лямбда`:
Числа Фибоначчи: 0, 1, 1, 2, 3, 5, 8, 13
Альтернативный подход к рекурсии лямбда-функций:
Числа Фибоначчи: 0, 1, 1, 2, 3, 5, 8, 13

Отчёты о дефектах

Следующие отчеты об изменениях в поведении, содержащие описания дефектов, были применены ретроактивно к ранее опубликованным стандартам C++.

Смотрите также

Внешние ссылки