C++11之Lambda表达式

C++11提供了对匿名函数的支持，即 lambda 函数（表达式）。C++11的 lambda 表达式语法格式如下：

//[capture](parameters)->returnType{body}
//[关联](参数)->返回类型{表达式内容}

如果没有参数，这里的小括号就可以省略。如果表达式里只有一个return语句，或者是返回void，则返回值也可以省略掉。

//[capture](parameters){body}

参数、返回值、表达式体

我们先了解一下lambda表达式的参数、返回值、表达式体。

下面就C++的lambda表达式举内处例子：

[](int x, int y) { return x + y; } // 只有一个return语句，返回类型可省略。
[](int& x) { ++x; }   // 函数体里没有return语句。即此匿名函数返回void类型。
[]() { ++global_x; }  // 没有参数，表达式里直接使用全局的变量。
[]{ ++global_x; }     // 同上，因为没有参数，所以小括号可以省略。
[](int a, int b)->int{ double c = sqrt(a * b); return round(c);} // 带有返回值声明的lambda表达式。

其实，如果没有指定返回值，lambda表达式的返回值是通过C++的decltype(x+y)确定的（对于上面第一个例子）。事实上，如果lambda表达式内的所有return语句的decltype(XXX)都是一样的，或者没有return语句时，都可以省略其返回类型。

关联

下面讨论一下关联参数。在其它语言或者概念里，这里的参数和表达式被称为闭包(Closure)。

C++的lambda表达式比普通的C++函数多一样东西就是它的关联参数。lambda表达式所在的定义的地方能访问的变量，如果在表达式内要使用，都可以通过中括号，把外部的变量引进过来。很多人第一次看到这东西也会搞不明白是干什么的。在很多其它支持匿名函数（或者匿名类）的语言中，并没有这个。原因是其它语言基本上都会把外部的变量自动全都引入，用C++的术语说，就是默认全部通过C++引用传给lambda表达式。在这些语言里如果想要在lambda里“修改”外部变量的值，而外部变量的值不被修改，则只能通过给lambda传参数来实现。

例如一个javascript匿名函数，可以自由的使用“外部”变量：

function max(v) {
    var x = 0;
    var f = function(val) { // 匿名函数
        if (v[val] > x) {   // 在匿名函数里可以引用外部变量v和x。
            x = v[val];     // 在匿名函数里，对外部变量的引用都是“直接”的，相当于C++中的传引用关联。可以修改外部变量的值。
        }
    }
    for (k in v) {
        f(k);
    }
    return x;
}
alert(max([1, 6, 3, 0, 2])); // 提示结果为“6”

就像本节开始所说的，在lambda表达式内中括号关联引用外部变量，被叫做闭包。在C++中，闭包可以通过传值关联，也可以通过传引用关联。这里先科普一下“闭包”。在数学里，闭包就是对一个集合执行某运算，如果运算结果还是这个集合，则这个集合就是这个运算的闭包。在程序中，闭包的概念更广义一些，就是lambda函数执行所需要的所有运行时环境、还有函数本身。运行时环境就包括函数体外部定义的非全局的，可以被lambda直接使用的被关联的变量。

举几个例子：

[]        // 没有任何关联，如果在lambda里引用外部参数。则会报编译错误。
[x, &y]   // 外部变量x是通过传值关联，y是通过传引用关联。
[&]       // 默认传引用关联，在lambda里所有使用外部的变量都使用外部变量的引用。
[=]       // 默认传值关联，在lambda里所有使用外部的变量都是传值的。
[&, x]    // 变量x为传值关联，其它外部变量则使用传引用关联。
[=, &z]   // 变量z为传引用关联，其它外部变量则使用传值关联。

用C++代码举个例子：

std::vector<int> some_list{ 1, 2, 3, 4, 5 };
int total = 0;
std::for_each(begin(some_list), end(some_list), [&total](int x) {
total += x;
});

这个例子会计算some_list的内容的和。由于是传引用关联的total，所以lambda里对total的修改会让外部的total也看到变化。

std::vector<int> some_list{ 1, 2, 3, 4, 5 };
int total = 0;
int value = 5;
std::for_each(begin(some_list), end(some_list), [&, value, this](int x) {
total += x * value * this->some_func();
});

这段代码里value中传值关联的。total没有指定，但是有默认使用引用关联，所以total会以引用关联。

这里还关联的一个特殊变量this。在C++里this只能通过传值关联，不能传this的引用。当然另外就是传this时只能是在类的非静态成员函数中使用。在lambda里使用this时，具有和lambda所在的函数对this同样的访问权限，即可访问本对象的private变量，可访问父对象的protected变量，等等。

在lambda里关联this后，也和lambda所在的函数里一样，在访问this成员时，在没有歧义时，可以省略“this->”。

高级主题

实现了C++11的lambda表达式的编译器，在内部实现细节上，可以不一样，但是，因为lambda一般都是作用域小、没有内部局部变量、函数体简单的，所以一般情况下，C++中的lambda都是可以通过inline优化，去掉多余的栈空间使用，从而把lambda表达式优化到像使用C的宏函数一样。

使用lambda时，经常为了处理异步调用，而让lambda表达式所在的函数走完，才去再调用这个lambda。在javascript中这很常见，特别是现在的node.js，由于javascript中的函数也是对象，所以在lambda调用时，lambda里所引用的外部变量还是有效的。在C++规范中，这样的行为是未定义的。因此，在C++中这样做，可能会让程序直接异常退出。

到目前为止，我们只讲了实现C++的lambda，在C++中，一个函数也可作为一个变量类型。那么lambda是什么类型的呢？

在各个编译器中，lambda的具体实现类型可能都不一样。在接收lambda为参数时，或者需要直接把lambda传给一个变量时，则可以使用std::function或者类似的类来接收lambda。因为C++11引入了简化的自动变量，所以我们也可以在这儿用上auto关键字：

auto my_lambda_func = [&](int x) { /*...*/ };
auto my_onheap_lambda_func = new auto([=](int x) { /*...*/ });

这里再举一个例子，是把lambda保存在变量里，vector里和数组里，然后作为参数传给别的函数：

#include<functional>
#include<vector>
#include<iostream>
double eval(std::function<double(double)> f, double x = 2.0){return f(x);}
int main(){
std::function<double(double)> f0    = [](double x){return 1;};
auto                          f1    = [](double x){return x;};
decltype(f0)                  fa[3] = {f0,f1,[](double x){return x*x;}};
std::vector<decltype(f0)>     fv    = {f0,f1};
fv.push_back                  ([](double x){return x*x;});
for(int i=0;i<fv.size();i++)  std::cout << fv[i](2.0) << "\n";
for(int i=0;i<3;i++)          std::cout << fa[i](2.0) << "\n";
for(auto &f : fv)             std::cout << f(2.0) << "\n";
for(auto &f : fa)             std::cout << f(2.0) << "\n";
std::cout << eval(f0) << "\n";
std::cout << eval(f1) << "\n";
std::cout << eval([](double x){return x*x;}) << "\n";
return 0;
}

在C++里，一个没有关联参数（即中括号为空）的lambda表达式，是可以隐式地转成同类型的函数指针的。所以这样的调用是合法的：

auto a_lambda_func = [
4000
](int x) { /*...*/ };
void(*func_ptr)(int) = a_lambda_func;
func_ptr(4); //调用lambda函数。

附注：本文主要取材自Wikipedia。