Lambda expressions (since C++11)

构造一个 闭包 （能够捕获作用域中变量的无名函数对象）。

语法

无显式模板参数列表的Lambda表达式（可能为非泛型）

带显式模板参数列表的Lambda表达式（始终为泛型） (since C++20)

说明

在 函数体 起始处会隐式定义一个变量 __func__ ，其语义说明详见 此处 。

闭包类型

lambda 表达式是一种独特的无名非 联合 非 聚合 类类型的纯右值表达式，称为 闭包类型 。该类型（出于 ADL 目的）声明于包含该 lambda 表达式的最小块作用域、类作用域或命名空间作用域内。

闭包类型拥有以下成员，它们不能被 显式实例化 、 显式特化 ，或 (since 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)...);
};

1. ↑ 尽管函数返回类型推导在 C++14 中引入，但其规则在 C++11 中已可用于 lambda 返回类型推导。

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); // 错误：不可转换
h(glambda);  // OK：调用 #1，因为 #2 不可转换
int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK

auto Fwd = [](int(*fp)(int), auto a) { return fp(a); };
auto C = [](auto a) { return</

Lambda 捕获

捕获列表 定义了可从 lambda 函数体内部访问的外部变量。其语法定义如下：

捕获 的语法定义如下：

如果 捕获默认符 是 & ，后续的简单捕获不得以 & 开头。

struct S2 { void f(int i); };
void S2::f(int i)
{
    [&] {};          // 正确：默认引用捕获
    [&, i] {};       // 正确：引用捕获，但 i 通过拷贝捕获
    [&, &i] {};      // 错误：当默认捕获为引用时不能显式声明引用捕获
    [&, this] {};    // 正确，等价于 [&]
    [&, this, i] {}; // 正确，等价于 [&, i]
}

如果 捕获默认符 是 = ，后续的简单捕获必须以 & 开头或是 *this (C++17起) 或 this (C++20起) 。

struct S2 { void f(int i); };
void S2::f(int i)
{
    [=] {};        // 正确：默认按值捕获
    [=, &i] {};    // 正确：按值捕获，但 i 按引用捕获
    [=, *this] {}; // C++17 前：错误：无效语法
                   // C++17 起：正确：按值捕获外围的 S2 对象
    [=, this] {};  // C++20 前：错误：当 = 为默认捕获时不能显式捕获 this
                   // C++20 起：正确，与 [=] 相同
}

任何捕获只能出现一次，且其名称必须与任何参数名称不同：

struct S2 { void f(int i); };
void S2::f(int i)
{
    [i, i] {};        // 错误：重复捕获 i
    [this, *this] {}; // 错误：重复捕获 "this" (C++17)
    [i] (int i) {};   // 错误：参数与捕获变量同名
}

如果变量满足以下条件，lambda表达式可以不捕获而直接使用该变量：

• 是一个非局部变量，或具有静态或线程局部 存储期 （此时该变量无法被捕获），或
• 是一个已使用 常量表达式 初始化的引用。

如果变量满足以下条件，lambda表达式可以在不捕获的情况下读取其值：

• 具有常量非易失性整型或枚举类型，且已使用 常量表达式 进行初始化，或
• 是 constexpr 类型且不包含可变成员。

当前对象（ * this ）在存在任一捕获默认符时可被隐式捕获。若被隐式捕获，它始终通过引用捕获，即使捕获默认符为 = 。 当捕获默认符为 = 时对 * this 的隐式捕获已被弃用。 (since C++20)

仅满足以下任一条件的lambda表达式可以具有不带初始化器的 capture-default 或 capture ：

• 其最内层的 封闭作用域 是 块作用域 。
• 它出现在 默认成员初始化器 中，且其最内层封闭作用域是对应的 类作用域 。

对于此类 lambda 表达式， 可达作用域 被定义为从最内层封闭函数（及其参数）开始的所有外围作用域集合。这包括嵌套的块作用域，以及当该 lambda 嵌套时外围 lambda 的作用域。

在任意不带初始化器的捕获项（除 this 捕获外）中， 标识符 会通过 lambda 的 可达作用域 中使用常规 非限定名称查找 进行查找。查找结果必须是声明于可达作用域中且具有自动存储期的 变量 ，或是其对应变量满足上述要求的 结构化绑定 (C++20 起) 。该实体被 显式捕获 。

int x = 4;
auto y = [&r = x, x = x + 1]() -> int
{
    r += 2;
    return x * x;
}(); // 将 ::x 更新为 6 并将 y 初始化为 25。

如果 captures 具有 capture-default 且未显式捕获封闭对象（作为 this 或 * this ），或在 lambda 主体中 可 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); };           // 正确：调用 #1，不捕获 x
    auto g0 = [](auto a) { f(x); };  // 同上
    auto l1 = [=]{ f(x); };          // 正确：捕获 x（自 P0588R1 起）并调用 #1
                                     // 该捕获可被优化消除
    auto g1 = [=](auto a) { f(x); }; // 同上
    auto ltid = [=]{ typeid(x); };   // 正确：捕获 x（自 P0588R1 起）
                                     // 即使 x 是未求值操作数
                                     // 该捕获可被优化消除
    auto g2 = [=](auto a)
    {
        int selector[sizeof(a) == 1 ? 1 : 2] = {};
        f(x, selector); // 正确：是依赖表达式，因此捕获 x
    };
    auto g3 = [=](auto a)
    {
        typeid(a + x);  // 无论 a + x 是否为未求值操作数
                        // 都会捕获 x
    };
    constexpr NoncopyableLiteralType w{42};
    auto l4 = []{ return w.n_; };      // 正确：w 未被 ODR 使用，无需捕获
    // auto l5 = [=]{ return w.n_; };  // 错误：w 需要通过拷贝捕获
}

如果 lambda 表达式的主体 ODR 使用 了通过复制捕获的实体，则访问的是闭包类型的成员。如果未 ODR 使用该实体，则访问的是原始对象：

void f(const int*);
void g()
{
    const int N = 10;
    [=]
    { 
        int arr[N]; // 非odr使用：引用的是g函数中的常量N
        f(&N); // odr使用：导致N被（以复制方式）捕获
               // &N是闭包对象成员N的地址，而非g函数中N的地址
    }();
}

如果 lambda 表达式通过引用方式捕获引用并对其进行 ODR 使用，它实际使用的是原始引用所指向的对象，而非被捕获的引用本身：

#include <iostream>
auto make_function(int& x)
{
    return [&] { std::cout << x << '\n'; };
}
int main()
{
    int i = 3;
    auto f = make_function(i); // f 中对 x 的使用直接绑定到 i
    i = 5;
    f(); // 正确：输出 5
}

在具有捕获默认值 = 的 lambda 表达式主体内，任何可捕获实体的类型都如同被捕获一样处理（因此如果该 lambda 不是 mutable ，通常会添加 const 限定），即使该实体处于未求值操作数中且未被实际捕获（例如在 decltype 中）：

void f3()
{
    float x, &r = x;
    [=]
    { // x 和 r 未被捕获（在 decltype 操作数中的出现不是 odr-use）
        decltype(x) y1;        // y1 具有 float 类型
        decltype((x)) y2 = y1; // y2 具有 float const& 类型，因为此 lambda
                               // 不是 mutable 且 x 是左值
        decltype(r) r1 = y1;   // r1 具有 float& 类型（不考虑转换）
        decltype((r)) r2 = y2; // r2 具有 float const& 类型
    };
}

任何被lambda捕获的实体（隐式或显式）都会被该lambda表达式进行odr使用（因此，嵌套lambda的隐式捕获会触发外层lambda的隐式捕获）。

所有隐式捕获的变量必须在 lambda 的 可达作用域 内声明。

如果 lambda 捕获了外围对象（通过 this 或 * this ），则其最接近的外围函数必须是非静态成员函数，或者该 lambda 必须位于 默认成员初始化器 中：

struct s2
{
    double ohseven = .007;
    auto f() // 以下两个lambda表达式的最内层封闭函数
    {
        return [this]      // 通过引用捕获封闭的s2对象
        {
            return [*this] // 通过拷贝捕获封闭的s2对象 (C++17)
            {
                return ohseven; // 正确
            }
        }();
    }
    auto g()
    {
        return [] // 不捕获任何变量
        { 
            return [*this] {}; // 错误：外部lambda表达式未捕获*this
        }();
    }
};

如果 lambda 表达式 （或泛型 lambda 函数调用运算符的特化） (since C++14) ODR-使用 * this 或任何具有自动存储期的变量，则必须被该 lambda 表达式捕获。

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;    // 正确：m 被 m4 隐式捕获
                               // 并被 m3 显式捕获
                    x += i;    // 错误：i 超出可达作用域
                               // （作用域终止于 work()）
                    x += f;    // 正确：this 被 m4 隐式捕获
                               // 并被 m3 显式捕获
                };
            };
        }
    };
}

类成员无法通过无初始化器的捕获显式捕获（如上所述，只有 变量 允许出现在 捕获列表 中）：

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); };  // 正确，复制捕获
        i = 1; x = 1; l2(); // 调用 use(0,0)
        auto l3 = [i, &x = x] { use(i, x); }; // 正确，引用捕获
        i = 2; x = 2; l3(); // 调用 use(1,2)
    }
};

当 lambda 通过隐式按值捕获方式捕获成员时，它并不会复制该成员变量：对成员变量 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 均按值捕获
    }
};

如果 lambda 表达式出现在 默认参数 中，它不能显式或隐式捕获任何内容 ，除非所有捕获都具有满足默认参数中表达式约束的初始化器 (since 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; }() );       // 正确：无捕获
    void g5( int = [] { return sizeof i; }() ); // 正确：无捕获
    // C++14
    void g6( int = [x = 1] { return x; }() ); // 正确：数字1可以出现在默认参数中
                                              //     
    void g7( int = [x = i] { return x; }() ); // 错误：变量i不能出现在默认参数中
                                              //        
}

匿名联合体 的成员不能被捕获。 位域 只能通过复制方式捕获。

如果嵌套的 lambda m2 捕获了某个也被直接外层 lambda m1 捕获的实体，那么 m2 的捕获将按以下方式转换：

• 如果外层 lambda m1 通过复制捕获， m2 捕获的是 m1 闭包类型的非静态成员，而非原始变量或 * this ；若 m1 不可变，其非静态数据成员被视为 const 限定。
• 如果外层 lambda 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; }();  // 正确
    int y = [=](this C) { return i; }();       // 错误
    int z = [](this C) { return 42; }();       // 正确
    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}(); // 错误
}

注释

隐式 lambda 捕获规则因缺陷报告 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';
    // 闭包的类型无法命名，但可以用auto推断
    // 自C++14起，lambda可以拥有默认参数
    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 << "模拟`递归lambda`调用：\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 << "lambda递归的替代方法：\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的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;
    };
    <

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的C++标准。

参见

外部链接