C++ lambda表达式详解

C++11 lambda表达式精讲

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

capture 是捕获列表，params 是参数表，opt 是函数选项，ret 是返回值类型，body是函数体

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

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

lambda 表达式还可以通过捕获列表捕获一定范围内的变量：

[] 不捕获任何变量
[&] 捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获）
[=] 捕获外部作用域中所有变量，并作为副本在函数体中使用（按值捕获）
[=，&foo] 按值捕获外部作用域中所有变量，并按引用捕获 foo 变量
[bar] 按值捕获 bar 变量，同时不捕获其他变量
[this] 捕获当前类中的 this 指针，让 lambda 表达式拥有和当前类成员函数同样的访问权限。如果已经使用了 & 或者 =，就默认添加此选项。捕获 this 的目的是可以在 lamda 中使用当前类的成员函数和成员变量

class A
{public:int i_ = 0;void func(int x, int y){auto x1 = []{ return i_; };                    // error，没有捕获外部变量auto x2 = [=]{ return i_ + x + y; };           // OK，捕获所有外部变量auto x3 = [&]{ return i_ + x + y; };           // OK，捕获所有外部变量auto x4 = [this]{ return i_; };                // OK，捕获this指针auto x5 = [this]{ return i_ + x + y; };        // error，没有捕获x、yauto x6 = [this, x, y]{ return i_ + x + y; };  // OK，捕获this指针、x、yauto x7 = [this]{ return i_++; };              // OK，捕获this指针，并修改成员的值}
};
int a = 0, b = 1;
auto f1 = []{ return a; };               // error，没有捕获外部变量
auto f2 = [&]{ return a++; };            // OK，捕获所有外部变量，并对a执行自加运算
auto f3 = [=]{ return a; };              // OK，捕获所有外部变量，并返回a
auto f4 = [=]{ return a++; };            // error，a是以复制方式捕获的，无法修改
auto f5 = [a]{ return a + b; };          // error，没有捕获变量b
auto f6 = [a, &b]{ return a + (b++); };  // OK，捕获a和b的引用，并对b做自加运算
auto f7 = [=, &b]{ return a + (b++); };  // OK，捕获所有外部变量和b的引用，并对b做自加运算

从上例中可以看到，lambda 表达式的捕获列表精细地控制了 lambda 表达式能够访问的外部变量，以及如何访问这些变量

需要注意的是，默认状态下 lambda 表达式无法修改通过复制方式捕获的外部变量。如果希望修改这些变量的话，我们需要使用引用方式进行捕获

一个容易出错的细节是关于 lambda 表达式的延迟调用的：

int a = 0;
auto f = [=]{ return a; };      // 按值捕获外部变量
a += 1;                         // a被修改了
std::cout << f() << std::endl;  // 输出？

在这个例子中，lambda 表达式按值捕获了所有外部变量。在捕获的一瞬间，a 的值就已经被复制到f中了。之后 a 被修改，但此时 f 中存储的 a 仍然还是捕获时的值，因此，最终输出结果是 0

如果希望 lambda 表达式在调用时能够即时访问外部变量，我们应当使用引用方式捕获

从上面的例子中我们知道，按值捕获得到的外部变量值是在 lambda 表达式定义时的值。此时所有外部变量均被复制了一份存储在 lambda 表达式变量中。此时虽然修改 lambda 表达式中的这些外部变量并不会真正影响到外部，我们却仍然无法修改它们

那么如果希望去修改按值捕获的外部变量应当怎么办呢？这时，需要显式指明 lambda 表达式为 mutable：

int a = 0;
auto f1 = [=]{ return a++; };             // error，修改按值捕获的外部变量
auto f2 = [=]() mutable { return a++; };  // OK，mutable

需要注意的一点是，被 mutable 修饰的 lambda 表达式就算没有参数也要写明参数列表

声明式的编程风格，简洁的代码

就地定义匿名函数，不再需要定义函数对象，大大简化了标准库算法的调用。比如，在 C++11 之前，我们要调用 for_each 函数将 vector 中的偶数打印出来，如下所示

class CountEven
{int& count_;
public:CountEven(int& count) : count_(count) {}void operator()(int val){if (!(val & 1))       // val % 2 == 0{++ count_;}}
};
std::vector<int> v = { 1, 2, 3, 4, 5, 6 };
int even_count = 0;
for_each(v.begin(), v.end(), CountEven(even_count));
std::cout << "The number of even is " << even_count << std::endl;

这样写既烦琐又容易出错。有了 lambda 表达式以后，我们可以使用真正的闭包概念来替换掉这里的仿函数，代码如下：

std::vector<int> v = { 1, 2, 3, 4, 5, 6 };
int even_count = 0;
for_each( v.begin(), v.end(), [&even_count](int val){if (!(val & 1))  // val % 2 == 0{++ even_count;}});
std::cout << "The number of even is " << even_count << std::endl;