C++11 Lambda表达式

前言

lambda表达式是C++11最重要的也是最常用的一个特性之一。其实在C#3.5中就引入了lambda，java至今还没有引入，要等到Java8中才有lambda表达式。lambda表达式源于函数式编程的理念，也是现代编程语言的一个特点。lambda表达式具有如下的优点：

（1）声明式编程风格：就地匿名定义目标函数或函数对象，不需要额外写一个命名函数或者函数对象。以更直接的方式去写程序，好的可读性和可维护性。

（2）简洁：不需要额外再写一个函数或者函数对象，避免了代码膨胀和功能分散，让开发者更加几种精力在手边的问题，同时也获得了更高的生产效率。

（3）在需要的时间和地点实现功能闭包，是程序更灵活

1. lambda表达式初探

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

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

其中：capture为捕获列表；params是参数表；opt是函数选项；ret是返回值类型；body是函数体。

因而一个完整的表达式就是这样定义和使用的：

auto f = [](int x)->int{int b = x+10; return b;};	//定义
f(1014);	//调用

在C++11中，lambda表达式的返回值是通过前面定义的返回值后置语法来定义的。其实很多时候，lambda表达式的返回值非常明显。因此C++11中允许省略lambda表达式的返回值定义。因而就可以写成这样了

auto f = [](int x){int b = x+10; return b;};   //定义
f(1014);    //调用

另外，lambda表达式在没有参数列表的时候，参数列表时可以省略的。因此像下面的写法都是正确的

auto f1 = [](){return 1;};
cout << f1() << endl;
auto f2 = []{return 2;};
cout << f2() << endl;

2. lambda表达式捕获

lambda表达式可以通过捕获列表捕获一定范围内的变量，具体的捕获规则是这样的：

（1）[]不捕获任何变量

（2）[&]捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获），也就是在函数体中可以对其进行修改。

（3）[=]捕获外部作用域中所有变量，并作为副本在函数体重使用（按值捕获）

（4）[=, &foo]按值捕获外部作用域中所有变量，并按引用捕获foo变量

（5）[bar]按值捕获bar变量，同时不捕获其他变量

（6）[this]捕获当前类中的this指针，让lambda表达式拥有和当前类成员函数同样的访问权限。如果已经使用了&或者=，就默认添加此项。捕获this的目的是可以再lambda中使用当前类的成员函数和成员变量。

使用例子

class A
{
public:
    int i = 0;

    void func(int x, int y)
    {
        auto x1 = []{return i;};                //错误，没有捕获外部变量
        auto x2 = [=]{return i+x+y;};           //正确，捕获所有的外部变量
        auto x3 = [&]{return i+x+y;};           //正确，捕获所有的外部变量
        auto x4 = [this]{return i;};            //正确，捕获this指针
        auto x5 = [this]{return i+x+y;};        //错误，没有捕获x和y
        auto x6 = [this, x, y]{return i+x+y;};  //正确，捕获this指针、x、y
        auto x7 = [this]{return ++i;};          //正确，捕获this指针，并修改成员的值
    }
};

int a=0,b=1;
auto f1 = []{return a;};            //错误，没有捕获外部变量
auto f2 = [&]{retrurn a++;};        //正确，捕获所有外部变量，并对a自加
auto f3 = [=]{return a;};           //正确，捕获所有外部变量
auto f4 = [=]{return a++};          //错误，a是复制形式捕获的，无法修改
auto f5 = [a]{return a+b;};         //错误，没有捕获变量b
auto f6 = [a, &b]{return a+(++b);}; //正确
auto f7 = [=, &b]{return a+(++b);}; //正确

要注意：默认状态下lambda表达式无法修改通过复制方式捕获的外部变量，如果希望修改这些变量的话，需要使用引用方式进行捕获。但是，如果是按值捕获外部变量但是想修改外部变量，那就需要关键字mutable，下面是使用例子

int a = 0；
auto f1 = [=]{return ++a;};             //错误，捕获是按置捕获的
auto f2 = [=]()mutable{return ++a;};    //正确，使用了mutable关键字

3. lambda表达式类型

lambda表达式的类型在C++11中被称为“闭包类型”。它是一个特殊的，匿名的非nunion的类类型。因此，可以认为它是一个带有operator()的类，既是仿函数。因而就可以使用std::function和std::bind来存储和操作lambda表达式

std::function<int(int)> f1 = [](int a){return a++;};
auto f2 = std::bind([](int a){return ++a;}, std::placeholders::_1);

此外，对于没有捕获任何变量的lambda表达式，还可以被转换成为一个普通的函数指针

using my_func = int(*)(int, int);
my_func f1 = [](int a, int b){return a+b;};
f1(10, 20);

lambda表达式可以说是就地定义仿函数闭包的“语法糖”，它的捕获列表捕获住的任何外部变量，最终均会变为闭包类型的成员变量。

对于lambda表达式按值无法修改捕获的外部变量。这是因为按照C++标准，lambda表达还是的operator()默认是const，因而就导致对按值捕获的外部变量无法进行修改。但是mutable的作用就是取消了const，使其变得可以修改。