C++lambda表达式

先来一个简单的例子

#include<iostream>
using namespace std;
int main()
{
	auto basic_lambda = [] {cout << "Hello Lambda" << endl; }; //定义简单的lambda表达式
	basic_lambda(); //调用
}

再来一个复杂的例子

#include<iostream>
using namespace std;
int main()
{
	int x = 10; // 定义作用域内的x，方便下面的lambda捕捉
	auto add_x = [x](int a) { return a + x; }; // 传值捕捉x
	auto multiply_x = [&x](int a) {return a * x; }; //引用捕捉x
	cout <<add_x(2)  << endl;
	cout << multiply_x(2) << endl;
}

lambda 表达式定义了一个匿名函数，并且可以捕获一定范围内的变量。lambda 表达式的语法形式可简单归纳如下：

[ capture ] ( params ) opt -> ret { body; };

其中 capture 是捕获列表，params 是参数表，opt 是函数选项，ret 是返回值类型，body是函数体。
在上面例子二中，auto add_x = [x](int a) { return a + x; }; capture 捕获了上下文中的x

因此，一个完整的 lambda 表达式看起来像这样：

auto f = [](int a) -> int { return a + 1; };
std::cout << f(1) << std::endl;  // 输出: 2

lambda表达式最前面的方括号提供了“闭包”功能。每当定义一个lambda表达式以后，编译器会自动生成一个 匿名类 ，并且这个类重载了()运算符，我们将其称之为闭包类型（closure type）。在运行时，这个lambda表达式会返回一个匿名的闭包实例，并且该实例是一个右值。闭包的一个强大之处在于其可以通过传值或引用的方式捕捉其封装作用域内的变量，lambda表达式前面的方括号就是用来定义捕捉模式以及变量的lambda捕捉块。

C++ 中的lambda表达式

lambda表达式捕获变量的生命周期

在C++11中，lambda表达式有两种变量捕获方式，分别为值捕获和引用捕获。这两种捕获的形式如下：

#include <iostream>

int main(int argc, char* argv[])
{
    int i = 42;
    auto l1 = [i]() //值捕获
    {
        std::cout << "l1::i = " <<  i << std::endl;
    };
    auto l2 = [&i]() //引用捕获
    {
        std::cout << "l2::i = " << i << std::endl;
    };
    i = 1024;

    l1(); //42
    l2(); //1024

    return 0;
}
//g++ lambda_lifecycle.cpp -o test -std=c++11

使用值传递时，编译器将l1中的i初始化为main函数中的i相同的值（42），之后，l1中的i与main函数中的i不再有任何关系。使用引用传递时则不同，l2中的i为main函数中i的副本，两者在内存中的地址是相同的。

所以，在main函数中更改i的值时，对l1无任何影响，而对l2有影响。l1中的i的声明周期与main函数中的i没有任何关系，l2中的i的声明周期与main函数中的i是相同的。这也导致了一个问题：当lambda表达式的生命周期大于main函数i的生命周期时，程序会产生致命错误。

#include <iostream>
#include <thread>
#include <chrono>

std::thread t;
void func()
{
    int i = 42;
    std::cout << "address of i:" << &i << " value of i:" << i << std::endl;
    t = std::thread([&i](){
        std::this_thread::sleep_for(std::chrono::seconds(2));
        std::cout << "address of i:" << &i << " value of i:" << i << std::endl;
    });
}

int main(int argc, char* argv[])
{
    func();
    std::this_thread::sleep_for(std::chrono::seconds(1));
    t.join();
    return 0;
}

执行结果如下：

g++ lambda_lifecycle.cpp -o test -std=c++11 -lpthread
./test
address of i:0x7fff7ab11ebc value of i:42
address of i:0x7fff7ab11ebc value of i:0
当func函数执行完成之后，变量i所在地址被弹出栈，等待2秒之后，线程t对变量i执行读取操作是未定义行为。

在使用lambda表达式捕获变量时，永远不要在捕获局部变量时使用引用捕获。

值捕获
先看如下代码：

int factor = 2;
auto multiply = [factor](int value)
        {return factor * value;};
factor = 4;
cout << multiply(2) << endl;

代码中首先为factor赋值2，创建lambda表达式以后，再次赋值4。由于lambda表达式的捕获是在该表达式创建是进行的，而第二次赋值在lambda表达式创建之后所以muliply(2)的执行结果为4。

引用捕获
还是这段代码，只要在捕获列表中变量的前面多了一个&，就变成了引用捕获。

int factor = 2;
auto multiply = [&factor](int value)
               {return factor * value;};
        factor = 4;
cout << multiply(2) << endl;

捕获的时机并没有变化，只是捕获的是factor的引用而不是factor的值，所以定义lambda之后，对factor再次赋值4依然会影响multiply(2)的结果。此时的输出为8。

隐式捕获
前面例子中使用捕获列表时，具体指定了变量名，属于显式捕获。另外还有隐式捕获，由lambda表达式推断需要捕获的变量。具体方法是：

当需要隐式值捕获时，使用[=];
当需要隐式引用捕获时，使用[&];

在上面例子中使用隐式捕获以后，结果不会发生变化。