windows C++-Lambda表达式(二)

mutable 规范

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

异常规范

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

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

返回类型

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

如果 Lambda 体仅包含一个返回语句，则可以省略 Lambda 表达式的 return-type 部分。 或者，在表达式未返回值的情况下。 如果 lambda 体包含单个返回语句，编译器将从返回表达式的类型推导返回类型。 否则，编译器会将返回类型推导为 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 isn't valid

lambda 表达式可以生成另一个 lambda 表达式作为其返回值。 

Lambda 体

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

从封闭范围捕获变量，如前所述。

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

以下示例包含通过值显式捕获变量 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 是通过值捕获的，因此在调用 lambda 表达式后，变量的值仍保持 0 不变。 mutable 规范允许在 Lambda 中修改 n。

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

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

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

上面代码的输出为:

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

constexpr Lambda 表达式

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

    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：

    auto answer = [](int n)
    {
        return 32 + n;
    };

    constexpr int response = answer(10);

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

    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 表达式。 例如：

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

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