在 C++ 11 和更高版本中，Lambda 表达式（通常称为 Lambda）是一种在被调用的位置或作为参数传递给函数的位置定义匿名函数对象（闭包）的简便方法。 Lambda 通常用于封装传递给算法或异步函数的少量代码行。 本文将提供 Lambda 的定义、将它与其他编程技术进行比较。 其中介绍了各自的优点，并提供了一些基本示例。

Lambda 表达式的各个部分

下面是一个简单的 Lambda，它作为第三个参数传递给 std::sort() 函数：

1
2
3
4
5
6
7
8
9
10
11
#include <algorithm>
#include <cmath>

void abssort(float* x, unsigned n) {
    std::sort(x, x + n,
        // Lambda expression begins
        [](float a, float b) {
            return (std::abs(a) < std::abs(b));
        } // end of lambda expression
    );
}

此图显示了 Lambda 语法的组成部分：

capture 子句（在 C++ 规范中也称为 Lambda 引导。）

参数列表（可选）。 （也称为 Lambda 声明符）

mutable 规范（可选）。

exception-specification（可选）。

trailing-return-type（可选）。

Lambda 体。

capture 子句

Lambda 可在其主体中引入新的变量（用 C++14），它还可以访问（或“捕获”）周边范围内的变量。 Lambda 以 capture 子句开头。 它指定捕获哪些变量，以及捕获是通过值还是通过引用进行的。 有与号 (&) 前缀的变量通过引用进行访问，没有该前缀的变量通过值进行访问。

空 capture 子句 [ ] 指示 lambda 表达式的主体不访问封闭范围中的变量。

可以使用默认捕获模式来指示如何捕获 Lambda 体中引用的任何外部变量：[&] 表示通过引用捕获引用的所有变量，而 [=] 表示通过值捕获它们。 可以使用默认捕获模式，然后为特定变量显式指定相反的模式。 例如，如果 lambda 体通过引用访问外部变量 total 并通过值访问外部变量 factor，则以下 capture 子句等效：

1
2
3
4
[&total, factor]
[factor, &total]
[&, factor]
[=, &total]

使用默认捕获时，只有 Lambda 体中提及的变量才会被捕获。

如果 capture 子句包含默认捕获 &，则该 capture 子句的捕获中没有任何标识符可采用 &identifier 形式。 同样，如果 capture 子句包含默认捕获 =，则该 capture 子句没有任何捕获可采用 =identifier 形式。 标识符或 this 在 capture 子句中出现的次数不能超过一次。 以下代码片段给出了一些示例：

1
2
3
4
5
6
7
8
9
struct S { void f(int i); };

void S::f(int i) {
    [&, i]{};      // OK
    [&, &i]{};     // ERROR: i preceded by & when & is the default
    [=, this]{};   // ERROR: this when = is the default
    [=, *this]{ }; // OK: captures this by value. See below.
    [i, i]{};      // ERROR: i repeated
}

捕获后跟省略号是一个包扩展，如以下可变参数模板示例中所示：

1
2
3
4
5
template<class... Args>
void f(Args... args) {
    auto x = [args...] { return g(args...); };
    x();
}

要在类成员函数体中使用 Lambda 表达式，请将 this 指针传递给 capture 子句，以提供对封闭类的成员函数和数据成员的访问权限。

Visual Studio 2017 版本 15.3 及更高版本（在 /std:c++17 模式及更高版本中可用）：可以通过在 capture 子句中指定 \*this 通过值捕获 this 指针。 通过值捕获会将整个闭包复制到调用 Lambda 的每个调用站点。 （闭包是封装 Lambda 表达式的匿名函数对象）。当 Lambda 在并行或异步操作中执行时，通过值捕获非常有用。 它在某些硬件体系结构（如 NUMA）上特别有用。

有关展示如何将 Lambda 表达式与类成员函数一起使用的示例，请参阅 Lambda 表达式示例中的“示例：在方法中使用 Lambda 表达式”。

在使用 capture 子句时，建议你记住以下几点（尤其是使用采取多线程的 Lambda 时）：

  • 引用捕获可用于修改外部变量，而值捕获却不能实现此操作。 （**mutable** 允许修改副本，而不能修改原始项。）
  • 引用捕获会反映外部变量的更新，而值捕获不会。
  • 引用捕获引入生存期依赖项，而值捕获却没有生存期依赖项。 当 Lambda 以异步方式运行时，这一点尤其重要。 如果在异步 Lambda 中通过引用捕获局部变量，该局部变量将很容易在 Lambda 运行时消失。 代码可能会导致在运行时发生访问冲突。

通用捕获 (C++14)

在 C++14 中，可在 Capture 子句中引入并初始化新的变量，而无需使这些变量存在于 Lambda 函数的封闭范围内。 初始化可以任何任意表达式表示；且将从该表达式生成的类型推导新变量的类型。 借助此功能，你可以从周边范围捕获只移动的变量（例如 std::unique_ptr）并在 Lambda 中使用它们。

1
2
3
4
5
6
pNums = make_unique<vector<int>>(nums);
//...
      auto a = [ptr = move(pNums)]()
        {
           // use ptr
        };

参数列表

Lambda 既可以捕获变量，也可以接受输入参数。 参数列表（在标准语法中称为 Lambda 声明符）是可选的，它在大多数方面类似于函数的参数列表

1
2
3
4
auto y = [] (int first, int second)
{
    return first + second;
};

在 C++14 中，如果参数类型是泛型，则可以使用 auto 关键字作为类型说明符。 此关键字将告知编译器将函数调用运算符创建为模板。 参数列表中的每个 auto 实例等效于一个不同的类型参数。

1
2
3
4
auto y = [] (auto first, auto second)
{
    return first + second;
};

Lambda 表达式可以将另一个 Lambda 表达式作为其自变量。 有关详细信息，请参阅 Lambda 表达式示例一文中的“高阶 Lambda 表达式”。

由于参数列表是可选的，因此在不将自变量传递到 Lambda 表达式，并且其 Lambda 声明符不包含 exception-specification、trailing-return-type 或 mutable 的情况下，可以省略空括号。

mutable 规范

通常，Lambda 的函数调用运算符是 const-by-value，但对 mutable 关键字的使用可将其取消。它不产生 mutable 数据成员。 利用 mutable 规范，Lambda 表达式的主体可以修改通过值捕获的变量。 本文后面的一些示例将展示如何使用 **mutable**。

异常规范

你可以使用 noexcept 异常规范来指示 Lambda 表达式不会引发任何异常。 与普通函数一样，如果 Lambda 表达式声明 noexcept 异常规范且 Lambda 体引发异常，Microsoft C++ 编译器将生成警告 C4297，如下所示：

1
2
3
4
5
6
// throw_lambda_expression.cpp
// compile with: /W4 /EHsc
int main() // C4297 expected
{
   []() noexcept { throw 5; }();
}

有关详细信息，请参阅异常规范 (throw)。

返回类型

将自动推导 Lambda 表达式的返回类型。 无需使用 auto 关键字，除非指定了 trailing-return-type。 trailing-return-type 类似于普通函数或成员函数的 return-type 部分。 但是，返回类型必须跟在参数列表的后面，你必须在返回类型前面包含 trailing-return-type 关键字 **->**。

如果 Lambda 体仅包含一个返回语句，则可以省略 Lambda 表达式的 return-type 部分。 或者，在表达式未返回值的情况下。 如果 lambda 体包含单个返回语句，编译器将从返回表达式的类型推导返回类型。 否则，编译器会将返回类型推导为 **void**。 下面的示例代码片段说明了这一原则：

1
2
3
auto x1 = [](int i){ return i; }; // OK: return type is int
auto x2 = []{ return{ 1, 2 }; };  // ERROR: return type is void, deducing
                                  // return type from braced-init-list isn't valid

lambda 表达式可以生成另一个 lambda 表达式作为其返回值。 有关详细信息，请参阅 Lambda 表达式示例中的“高阶 Lambda 表达式”。

Lambda 体

Lambda 表达式的 Lambda 体是一个复合语句。 它可以包含普通函数或成员函数体中允许的任何内容。 普通函数和 lambda 表达式的主体均可访问以下变量类型：

  • 从封闭范围捕获变量，如前所述。
  • 参数。
  • 本地声明变量。
  • 类数据成员（在类内部声明并且捕获 this 时）。
  • 具有静态存储持续时间的任何变量（例如，全局变量）。

以下示例包含通过值显式捕获变量 n 并通过引用隐式捕获变量 m 的 lambda 表达式：

1
2
3
4
5
6
7
8
9
10
11
12
// captures_lambda_expression.cpp
// compile with: /W4 /EHsc
#include <iostream>
using namespace std;

int main()
{
   int m = 0;
   int n = 0;
   [&, n] (int a) mutable { m = ++n + a; }(4);
   cout << m << endl << n << endl;
}
1
2
5
0

由于变量 n 是通过值捕获的，因此在调用 lambda 表达式后，变量的值仍保持 0 不变。 mutable 规范允许在 Lambda 中修改 n。

Lambda 表达式只能捕获具有自动存储持续时间的变量。 但是，可以在 Lambda 表达式体中使用具有静态持续存储时间的变量。 以下示例使用 generate 函数和 lambda 表达式为 vector 对象中的每个元素赋值。 lambda 表达式将修改静态变量以生成下一个元素的值。

1
2
3
4
5
6
7
8
9
10
11
void fillVector(vector<int>& v)
{
    // A local static variable.
    static int nextValue = 1;

    // The lambda expression that appears in the following call to
    // the generate function modifies and uses the local static
    // variable nextValue.
    generate(v.begin(), v.end(), [] { return nextValue++; });
    //WARNING: this isn't thread-safe and is shown for illustration only
}

有关详细信息，请参阅 generate。

下面的代码示例使用上一示例中的函数，并添加了使用 C++ 标准库算法 generate_n 的 Lambda 表达式的示例。 该 lambda 表达式将 vector 对象的元素指派给前两个元素之和。 使用了 mutable 关键字，使 Lambda 表达式主体可以修改 Lambda 表达式通过值捕获的外部变量 x 和 y 的副本。 由于 lambda 表达式通过值捕获原始变量 x 和 y，因此它们的值在 lambda 执行后仍为 1。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
// compile with: /W4 /EHsc
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c) {
    cout << s;

    for (const auto& e : c) {
        cout << e << " ";
    }

    cout << endl;
}

void fillVector(vector<int>& v)
{
    // A local static variable.
    static int nextValue = 1;

    // The lambda expression that appears in the following call to
    // the generate function modifies and uses the local static
    // variable nextValue.
    generate(v.begin(), v.end(), [] { return nextValue++; });
    //WARNING: this isn't thread-safe and is shown for illustration only
}

int main()
{
    // The number of elements in the vector.
    const int elementCount = 9;

    // Create a vector object with each element set to 1.
    vector<int> v(elementCount, 1);

    // These variables hold the previous two elements of the vector.
    int x = 1;
    int y = 1;

    // Sets each element in the vector to the sum of the
    // previous two elements.
    generate_n(v.begin() + 2,
        elementCount - 2,
        [=]() mutable throw() -> int { // lambda is the 3rd parameter
        // Generate current value.
        int n = x + y;
        // Update previous two values.
        x = y;
        y = n;
        return n;
    });
    print("vector v after call to generate_n() with lambda: ", v);

    // Print the local variables x and y.
    // The values of x and y hold their initial values because
    // they are captured by value.
    cout << "x: " << x << " y: " << y << endl;

    // Fill the vector with a sequence of numbers
    fillVector(v);
    print("vector v after 1st call to fillVector(): ", v);
    // Fill the vector with the next sequence of numbers
    fillVector(v);
    print("vector v after 2nd call to fillVector(): ", v);
}
1
2
3
4
vector v after call to generate_n() with lambda: 1 1 2 3 5 8 13 21 34
x: 1 y: 1
vector v after 1st call to fillVector(): 1 2 3 4 5 6 7 8 9
vector v after 2nd call to fillVector(): 10 11 12 13 14 15 16 17 18

有关详细信息，请参阅 generate_n。

constexpr Lambda 表达式

Visual Studio 2017 版本 15.3 及更高版本（在 /std:c++17 模式和更高版本中可用）：在常量表达式中允许初始化捕获或引入的每个数据成员时，可以将 Lambda 表达式声明为 **constexpr**（或在常量表达式中使用它）。

1
2
3
4
5
6
7
8
9
10
11
int y = 32;
    auto answer = [y]() constexpr
    {
        int x = 10;
        return y + x;
    };

    constexpr int Increment(int n)
    {
        return [n] { return n + 1; }();
    }

如果 Lambda 结果满足 constexpr 函数的要求，则 Lambda 是隐式的 **constexpr**：

1
2
3
4
5
6
auto answer = [](int n)
    {
        return 32 + n;
    };

    constexpr int response = answer(10);

如果 Lambda 是隐式或显式的 **constexpr**，则转换为函数指针将生成 constexpr 函数：

1
2
3
4
5
6
auto Increment = [](int n)
    {
        return n + 1;
    };

    constexpr int(*inc)(int) = Increment;

Microsoft 专用

以下公共语言运行时 (CLR) 托管实体中不支持 Lambda：**ref class、ref struct、value class** 或 **value struct**。

如果你使用 Microsoft 专用的修饰符（例如 __declspec），可以紧接在 parameter-declaration-clause 后将其插入 Lambda 表达式。 例如：

1
auto Sqr = [](int t) __declspec(code_seg("PagedMem")) -> int { return t*t; };

若要确定 Lambda 是否支持某个特定修饰符，请参阅 Microsoft 专用修饰符一文中有关该修饰符的部分。

Visual Studio 支持 C++11 标准 Lambda 功能和无状态 Lambda。 无状态 Lambda 可转换为使用任意调用约定的函数指针。

另请参阅

有趣的东西