C++ lambda表达式

C++11 引入了lambda表达式，这个特性的最广泛应用，就是配合泛型算法。

泛型算法，采用了迭代器操做，从而使得各类不一样的容器能使用一套算法。泛型算法容许咱们定制本身的操做，即传递一个可调用对象，lambda其实也是一个可调用对象。下面先介绍下lambda表达式的基本结构和特性，最后再深刻探索lambda表达式的本质。

1、lambda表达式的基本构成

lambda表达式表示了一个可调用的单元代码，与函数相似，具备一个返回类型，一个参数列表，一个函数体，不一样之处在于，还有一个捕获参数列表。

[](int a, int b)->bool{return a > b; }

须要注意的是，返回类型必须使用尾置返回。参数列表和返回类型都是能够忽略的，可是捕获列表和函数体必须保留。我的猜测，省略了捕获列表和函数体可能会使得编译器没法判断类型。

lambda既然是个可调用对象，那么它的调用方法也与通常的函数对象一致：

class Increase
{
public:
    void operator()(int& val){++val;}
};
int main()
{
    int i = 1, j = 1;
    auto f = [](int& j){ ++j; };//等价于Increase
    f(j);//1
    Increase Inc;
    Inc(i);//2
}//1与2等价

2、捕获

捕获能够说是lambda最难理解的部分。所谓捕获，指的是容许lambda使用它所在函数中的局部变量。对于函数外的变量以及函数内的static变量，无需进行捕获便可直接使用。

捕获有两种方式，一种是值捕获，另一种是引用捕获。

static i=1;
int j=1;
auto f1 = [&j]()->int{ ++j; return j; };//引用捕获
auto f2 = [j](){return j; };//值捕获
auto f3 = [](){return i; }//静态变量无需捕获

引用捕获，实际上就是引用了一个局部变量。既然是引用，就要注意引用存在的问题。必须确保引用的变量在整个lambda执行的周期内都是存在的，而且为一个正确的值。

值捕获，至关于函数参数值传递的过程。所以，必须保证捕获的量是可拷贝的。此外，针对捕获的值为指针或者引用类型，也存在确保对象依然存在的问题。

所以，应对尽可能减小捕获，避免潜在的问题。可能的话，尽可能避免捕获指针或者引用。

隐式捕获

隐式捕获是一种简略的方法，下面举个例子来讲明一下：

int i = 1, j = 1;
auto f = [=, &j](){return i + (++j); };

前面“=”或者“&”说明默认捕获的类型，若是有须要显示捕获的另一种类型，在后面单独列出便可。

修改捕获量的值

auto f2 = [j](){return ++j; };//error，由于这是个右值
auto f4 = [j]()mutable{return ++j; };//正确

值捕获是没法修改变量值的，加一个mutable便可。

3、返回类型

前面的例子中咱们能够看到，咱们没有显示说明返回类型，也获得了正确的结果。不过，默认的规则以下

一、若是仅有return ，那么根据return 的类型肯定返回类型。

二、若是除了return 还有别的语句，那么返回void。

因此，不只有return语句时，尽可能要本身显示说明返回类型。

4、lambda表达式的本质

咱们知道，定义了调用运算符的对象，能够称为函数对象，即这个对象能够像函数同样被调用，行为相似函数。

与lambda同样，函数对象一样能够做为泛型算法的自定义操做：

class Bigger//1
{
public:
    bool operator()(int a, int b){ return a > b; }
};
bool bigger(int a, int b){ return a > b; }
int main()
{
    vector<int> vec{ 2, 0, 1, 3, 3, 0, 1, 9, 7, 7 };
    sort(vec.begin(), vec.end(), [](int a, int b)->bool{return a > b; });//2
    sort(vec.begin(), vec.end(), bigger);
    sort(vec.begin(), vec.end(), Bigger());
}

上面的例子中，分别用了lambda表达式、函数指针、函数对象来进行了排序，结果是相同的。

事实上，lambda表达式就是一个函数对象。当编写了一个lambda表达式的时候，编译器将该表达式翻译成一个未命名类的未命名对象。

lambda表达式产生的类中会有一个重载的函数调用运算符。若是没有捕获任何变量，如上面咱们定义的lambda（1）和函数对象（2），实际上是彻底相同的。

若是lambda采用引用捕获的方式，那么该变量其实不是lambda对象的成员，因此无需进行额外操做。

若是采用值捕获，那么就至关于在对象内部建立了本身的成员，所以须要增长一部份内容：

class F
{
public:
    F(int n) :num(n){}
    int operator()(){ return num; }
private:
    int num;
};
int num = 100;
auto f = [num](){return num; };//等价于F

即增长了一个用捕获的值进行构造的构造函数。

lambda表达式产生的类，不含有默认构造函数、赋值运算符和默认析构函数，其余成员由须要捕获的类型肯定。

 

本文只是简单介绍了lambda的基本操做和功能，以及lambda表达式编译时产生函数对象的行为，更加深刻的内容，本人暂时还不清楚0 0