lambda 表达式是类、构造和函数调用运算符。 如同，在定义类时，决定需要发生的对象捕获变量不受值还是引用或者是否是必需的。 captured.‘ data-guid="6c33afef79a40306c474574370f5d5d3">如果 lambda 表达式需要访问局部变量和函数参数，它们需要 捕获。 lambda-introducer in the syntax) specifies whether the body of the lambda expression can access variables in the enclosing scope by value or by reference: Variables that have the ampersand (&) prefix are accessed by reference and variables that do not have the & prefix are accessed by value.‘ data-guid="c40c2b1e1b09d1b6c817849b8f6620a7">get 子句 (语法中的lambda-introducer ) 所指定 lambda 表达式的主体是可以访问在封闭范围内的变量通过值或通过引用：包含" &的变量 (&) 为前缀) 没有 & 前缀的引用和变量访问值由访问。

[ ], indicates that the body of the lambda expression accesses no variables in the enclosing scope.‘ data-guid="63675b2a3256576c874023b197bac1c0">空 capture 子句 [ ] 指示 lambda 表达式的主体不访问封闭范围中的变量。

捕获默认模式指定您未显式指定的获取变量是否捕获通过值或通过引用，如果使用它们。 capture-default in the syntax) by specifying & or = as the first element of the capture clause.‘ data-guid="06ca7cba6d4564676c3248770ee0e3f1">您可以通过将 & 或 = 指定为 capture 子句的第一个元素来指定默认捕获模式（语法中的 capture-default）。 & element specifies that the body of the lambda expression accesses all captured variables by reference unless you explicitly specify otherwise.‘ data-guid="e1b847322b78a606bba9d77c52fe04be">& 元素指定 lambda 表达式的主体通过引用访问所有捕获的变量，除非您显式地另行指定。 = element specifies that the body of the lambda expression accesses all captured variables by value unless you explicitly specify otherwise.‘ data-guid="ee082ebeb43766571328678d7d2f24fe">= 元素指定 lambda 表达式的主体通过值访问所有捕获的变量，除非您显式地另行指定。 total by reference and the external variable factor by value, then the following capture clauses are equivalent:‘ data-guid="5bad063af18403fe3f4e25e148c3651f">例如，如果 lambda 表达式的主体通过引用访问外部变量 total 并通过值访问外部变量 factor，那么以下 capture 子句等效：

[&total, factor]
{factor, &total]
[&, factor]
[factor, &]
[=, &total]
[&total, =]

capture-default is that all variables in the scope are captured whether they are used in the lambda or not.‘ data-guid="b08db9512b44b311fa2f9cc31c0b2a9e">有关使用 capture-default 的一种常见的误会位于范围内的任何变量捕获是否使用 lambda。 capture-default.‘ data-guid="cc904375d879668befe499b0b9a84de0">事实上并非如此 - 在 lambda 提到的那些变量捕获，则使用 capture-default。

如果捕获子句包括 capture-default&，该 lambda 的 get 子句 capture 的 identifier 不能由 &。 capture-default (=), each capture of that capture clause must be in the form & identifier.‘ data-guid="1cb38aa3342faf3177ce98fff2e74c79">沿着同一行，因此，如果获取子句包括 capture-default (=)，该子句获得每个 capture 必须以窗体 & identifier。 this cannot appear more than once in a capture clause.‘ data-guid="cf4debaa20847e79b392630c6e1a44b3">标识符或 this 不能多次出现在子句获得。 下面的代码段阐释了一些示例。

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
    [i, i]{};    // ERROR: i repeated
}

省略号 capture 后跟是 pack 扩展，以下面的示例：variadic 模板

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

参数列表

可变规范

异常规范

throw() exception specification to indicate that the lambda expression does not throw any exceptions.‘ data-guid="864feb25d624512223eac67ca5e65a0d">您可以使用 throw() 异常规范来指示 lambda 表达式不会引发任何异常。 C4297 if a lambda expression declares the throw() exception specification and the lambda body throws an exception, as shown in the following example:‘ data-guid="51492dd90d3455655471188842c736ef">与正则函数一样，如果 lambda 表达式声明 throw() 异常规范且 lambda 体引发异常，Visual C++ 编译器将生成警告 C4297，如以下示例所示：

// throw_lambda_expression.cpp
// compile with: /W4 /EHsc 
int main() // C4297 expected
{
   []() throw() { throw 5; }();
}

返回类型

auto keyword unless a trailing-return-type is specified.‘ data-guid="c38d414de342a6f2033ff784ef760918">lambda 表达式的返回类型自动推断，并且，这发生，而无需添加关键字，除非指定 trailing-return-type。auto trailing-return-type resembles the return type part of an ordinary method or function.‘ data-guid="c2fa50eaa88f4b294a0827a5d39305b0">trailing-return-type 类似于普通方法或函数返回类型的部件。 -> before the return type.‘ data-guid="f32cc4800f78ae0b4a707e2f4b348df9">但是，遵循返回类型参数列表，您必须包括尾部的返回类型关键字 ->，在返回类型。

如果 lambda 体包含单个返回语句或 lambda 表达式不返回值，则可以省略 lambda 表达式的返回类型部分。 如果 lambda 体包含单个返回语句，编译器将从返回表达式的类型推导返回类型。 void.‘ data-guid="dbcad1a80c2671c1e63e83dbb889d62b">否则，编译器会将返回类型推导为 void（可能需要显示指明返回类型）。 考虑阐释此原则下面的示例代码段。

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 not valid

lambda 表达式可以生成另一个 lambda 表达式作为其返回值。 Examples of Lambda Expressions.‘ data-guid="5de864549207e726053ee89acb16218d">有关详细信息，请参阅主题 Lambda 表达式的示例中的“高阶 Lambda 表达式”。

Lambda 体

compound-statement) part of a lambda expression can contain anything that the body of an ordinary method or function can contain.‘ data-guid="f6f7711b58566f4e0ba3338648808408">lambda 表达式主体的 lambda (compound-statement) 中可以包含一般的方法或函数主体所能包含的所有内容。 普通函数和 lambda 表达式的主体均可访问以下变量类型：

• 参数

• 本地声明变量

• this is captured)‘ data-guid="061c2060e88df49524cd1ca88ab3cd19">类数据成员 (在声明类和 this 内捕获)

• 具有静态存储持续时间的任何变量（例如，全局变量）

此外，lambda 表达式可以访问它从封闭范围中捕获的变量。 explicitly captured if it appears in the capture clause of the lambda expression.‘ data-guid="4b80d2b6a52c7399c0814480cbe56ad4">如果某个变量显示在 lambda 表达式的 capture 子句中，则该变量是显式捕获的。 implicitly captured.‘ data-guid="452895ab9d3dc569058e37c3da341035">否则，该变量是隐式捕获的。 lambda 表达式的主体使用默认捕获模式来访问隐式捕获的变量。

n by value and implicitly captures the variable m by reference:‘ data-guid="2fa2baef7118434466b3bf796a5f9c70">以下示例包含通过值显式捕获变量 n 并通过引用隐式捕获变量 m 的 lambda 表达式：

// 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;
}

本示例将以下内容输出到控制台：

5
0

n is captured by value, its value remains 0 after the call to the lambda expression.‘ data-guid="cd5a3531d8a41f6e44e7be185f221c83">由于变量 n 是通过值捕获的，因此在调用 lambda 表达式后，变量的值仍保持 0 不变。 mutable specification allows n to be modified within the lambda.‘ data-guid="2b5ab9c1f809320dd5702b305da46788">指定 mutable 允许 n 是在 lambda 中修改。

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

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 is not thread-safe and is shown for illustration only
}

generate function, see generate. ‘ data-guid="d7921455d70fff4b583ab6a110d1cabf">有关 generate 函数的详细信息，请参阅 生成。

下面的代码示例使用从前面的函数，并将该表达式的 lambda 表达式的示例与 STL generate_n的算法。 该 lambda 表达式分配的 vector 对象的元素。前两个元素的和的。 mutable keyword is used so that the body of the lambda expression can modify its copies of the external variables x and y, which the lambda expression captures by value.‘ data-guid="08d948f43c776a52ea7576cf6e11a107">改用 mutable 关键字，这样 lambda 表达式体才能改变其外部变量 x 和 y的复制，lambda 表达式按值捕获。 x and y by value, their values remain 1 after the lambda executes.‘ data-guid="79c37a26742c33aa9f3aff17d10e8cc7">由于 lambda 表达式按值捕获原始变量 x 和 y，它们的值保持为 1，在 lambda 后执行。

// 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 is not 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);
}

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