Лямбда-выражения (начиная с C++11)

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

Синтаксис

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

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

Пояснение

Переменная __func__ неявно определяется в начале body со смыслом, описанным здесь.

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

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

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

ret operator()(params) { body }

template<template-params>
ret operator()(params) { body }

// 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()
    {
        // the context of the following lambda is the member function X::f
        [=]() -> int
        {
            return operator()(this->x + y); // X::operator()(this->x + (*this).y)
                                            // this has type X*
        };
    }
};

using F = ret(*)(params);
operator F() const noexcept;

using F = ret(*)(params);
constexpr operator F() const noexcept;

template<template-params> using fptr_t = /* see below */;
template<template-params>
operator fptr_t<template-params>() const noexcept;

template<template-params> using fptr_t = /* see below */;
template<template-params>
constexpr operator fptr_t<template-params>() const noexcept;

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

ClosureType() = default;

ClosureType(const ClosureType&) = default;

ClosureType(ClosureType&&) = default;

ClosureType& operator=(const ClosureType&) = delete;

ClosureType& operator=(const ClosureType&) = default;
ClosureType& operator=(ClosureType&&) = default;

ClosureType& operator=(const ClosureType&) = delete;

~ClosureType() = default;

T1 a;
T2 b;
...

Захват в лямбда-выражении

captures определяет внешние переменные, доступные из тела лямбда-функции. Его синтаксис определяется следующим образом:

Синтаксис capture определяется следующим образом:

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

struct S2 { void f(int i); };
void S2::f(int i)
{
    [&] {};          // OK: by-reference capture default
    [&, i] {};       // OK: by-reference capture, except i is captured by copy
    [&, &i] {};      // Error: by-reference capture when by-reference is the default
    [&, this] {};    // OK, equivalent to [&]
    [&, this, i] {}; // OK, equivalent to [&, i]
}

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

struct S2 { void f(int i); };
void S2::f(int i)
{
    [=] {};        // OK: by-copy capture default
    [=, &i] {};    // OK: by-copy capture, except i is captured by reference
    [=, *this] {}; // until C++17: Error: invalid syntax
                   // since C++17: OK: captures the enclosing S2 by copy
    [=, this] {};  // until C++20: Error: this when = is the default
                   // since C++20: OK, same as [=]
}

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

struct S2 { void f(int i); };
void S2::f(int i)
{
    [i, i] {};        // Error: i repeated
    [this, *this] {}; // Error: "this" repeated (C++17)
    
    [i] (int i) {};   // Error: parameter and capture have the same name
}

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

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

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

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

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

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

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

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

Поиск identifier в любом захвате без инициализатора (кроме захвата 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 в теле лямбда-выражения, либо структурированное связывание, соответствующая переменная которого имеет автоматическую длительность хранения(начиная с C++20), эта сущность захватывается неявно, если она названа в потенциально вычисляемом выражении (в том числе когда перед использованием нестатического члена класса неявно добавляется 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: calls #1, does not capture x
    auto g0 = [](auto a) { f(x); };  // same as above

    auto l1 = [=]{ f(x); };          // OK: captures x (since P0588R1) and calls #1
                                     // the capture can be optimized away
    auto g1 = [=](auto a) { f(x); }; // same as above

    auto ltid = [=]{ typeid(x); };   // OK: captures x (since P0588R1)
                                     // even though x is unevaluated
                                     // the capture can be optimized away

    auto g2 = [=](auto a)
    {
        int selector[sizeof(a) == 1 ? 1 : 2] = {};
        f(x, selector); // OK: is a dependent expression, so captures x
    };
    
    auto g3 = [=](auto a)
    {
        typeid(a + x);  // captures x regardless of
                        // whether a + x is an unevaluated operand
    };

    constexpr NoncopyableLiteralType w{42};
    auto l4 = []{ return w.n_; };      // OK: w is not odr-used, capture is unnecessary
    // auto l5 = [=]{ return w.n_; };  // error: w needs to be captured by copy
}

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

void f(const int*);
void g()
{
    const int N = 10;
    [=]
    { 
        int arr[N]; // not an odr-use: refers to g's const int N
        f(&N); // odr-use: causes N to be captured (by copy)
               // &N is the address of the closure object's member N, not g's N
    }();
}

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

#include <iostream>

auto make_function(int& x)
{
    return [&] { std::cout << x << '\n'; };
}

int main()
{
    int i = 3;
    auto f = make_function(i); // the use of x in f binds directly to i
    i = 5;
    f(); // OK: prints 5
}

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

void f3()
{
    float x, &r = x;
    [=]
    { // x and r are not captured (appearance in a decltype operand is not an odr-use)
        decltype(x) y1;        // y1 has type float
        decltype((x)) y2 = y1; // y2 has type float const& because this lambda
                               // is not mutable and x is an lvalue
        decltype(r) r1 = y1;   // r1 has type float& (transformation not considered)
        decltype((r)) r2 = y2; // r2 has type float const&
    };
}

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

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

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

struct s2
{
    double ohseven = .007;
    auto f() // nearest enclosing function for the following two lambdas
    {
        return [this]      // capture the enclosing s2 by reference
        {
            return [*this] // capture the enclosing s2 by copy (C++17)
            {
                return ohseven; // OK
            }
        }();
    }
    
    auto g()
    {
        return [] // capture nothing
        { 
            return [*this] {}; // error: *this not captured by outer lambda expression
        }();
    }
};

Если лямбда-выражение (или специализация оператора вызова функции обобщённой лямбды)(начиная с 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 and M are not odr-used 
                         // (ok that they are not captured)
            x[0][0] = i; // i is explicitly captured by m2
                         // and implicitly captured by m1
        };
    };

    struct s1 // local class within f1()
    {
        int f;
        void work(int n) // non-static member function
        {
            int m = n * n;
            int j = 40;
            auto m3 = [this, m]
            {
                auto m4 = [&, j] // error: j is not captured by m3
                {
                    int x = n; // error: n is implicitly captured by m4
                               // but not captured by m3
                    x += m;    // OK: m is implicitly captured by m4
                               // and explicitly captured by m3
                    x += i;    // error: i is outside of the reaching scope
                               // (which ends at work())
                    x += f;    // OK: this is captured implicitly by m4
                               // and explicitly captured by m3
                };
            };
        }
    };
}

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

class S
{
    int x = 0;
    
    void f()
    {
        int i = 0;
    //  auto l1 = [i, x] { use(i, x); };      // error: x is not a variable
        auto l2 = [i, x = x] { use(i, x); };  // OK, copy capture
        i = 1; x = 1; l2(); // calls use(0,0)
        auto l3 = [i, &x = x] { use(i, x); }; // OK, reference capture
        i = 2; x = 2; l3(); // calls use(1,2)
    }
};

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

class S
{
    int x = 0;
    
    void f()
    {
        int i = 0;
        
        auto l1 = [=] { use(i, x); }; // captures a copy of i and
                                      // a copy of the this pointer
        i = 1; x = 1; l1();           // calls use(0, 1), as if
                                      // i by copy and x by reference
        
        auto l2 = [i, this] { use(i, x); }; // same as above, made explicit
        i = 2; x = 2; l2();           // calls use(1, 2), as if
                                      // i by copy and x by reference
        
        auto l3 = [&] { use(i, x); }; // captures i by reference and
                                      // a copy of the this pointer
        i = 3; x = 2; l3();           // calls use(3, 2), as if
                                      // i and x are both by reference
        
        auto l4 = [i, *this] { use(i, x); }; // makes a copy of *this,
                                             // including a copy of x
        i = 4; x = 4; l4();           // calls use(3, 2), as if
                                      // i and x are both by copy
    }
};

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

void f2()
{
    int i = 1;
    
    void g1( int = [i] { return i; }() ); // error: captures something
    void g2( int = [i] { return 0; }() ); // error: captures something
    void g3( int = [=] { return i; }() ); // error: captures something
    
    void g4( int = [=] { return 0; }() );       // OK: capture-less
    void g5( int = [] { return sizeof i; }() ); // OK: capture-less
    
    // C++14
    void g6( int = [x = 1] { return x; }() ); // OK: 1 can appear
                                              //     in a default argument
    void g7( int = [x = i] { return x; }() ); // error: i cannot appear
                                              //        in a default argument
}

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

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

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

    // the type of a closure cannot be named, but can be inferred with auto
    // since C++14, lambda could own default arguments
    auto func1 = [](int i = 6) { return i + 4; };
    std::cout << "func1: " << func1() << '\n';

    // like all callable objects, closures can be captured in std::function
    // (this may incur unnecessary overhead)
    std::function<int(int)> func2 = [](int i) { return i + 4; };
    std::cout << "func2: " << func2(6) << '\n';

    constexpr int fib_max {8};
    std::cout << "Emulate `recursive lambda` calls:\nFibonacci numbers: ";
    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 << "Alternative approach to lambda recursion:\nFibonacci numbers: ";
    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 approach to lambda recursion:\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
Emulate `recursive lambda` calls:
Fibonacci numbers: 0, 1, 1, 2, 3, 5, 8, 13
Alternative approach to lambda recursion:
Fibonacci numbers: 0, 1, 1, 2, 3, 5, 8, 13

Отчёты об ошибках

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

См. также

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