c++学习笔记——lambda表达式

最近在复习c++，接触到了lambda表达式，参考了别人的博客和书籍，整理如下供自己今后复习时候使用。

lambda表达式的结构定义如下：

[capture](parameters) mutable ->return-type{statement}

1.[capture]：捕捉列表。捕捉列表总是出现在Lambda函数的开始处。实际上，[]是Lambda引出符。编译器根据该引出符判断接下来的代码是否是Lambda函数。捕捉列表能够捕捉上下文中的变量以供Lambda函数使用;

2.(parameters)：参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号“()”一起省略;

3.mutable：mutable修饰符。默认情况下，Lambda函数总是一个const函数，mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）;

4.->return-type：返回类型。用追踪返回类型形式声明函数的返回类型。我们可以在不需要返回值的时候也可以连同符号”->”一起省略。此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导;

5.{statement}：函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。

与普通函数最大的区别是，除了可以使用参数以外，Lambda函数还可以通过捕获列表访问一些上下文中的数据。具体地，捕捉列表描述了上下文中哪些数据可以被Lambda使用，以及使用方式（以值传递的方式或引用传递的方式）。语法上，在“[]”包括起来的是捕捉列表，捕捉列表由多个捕捉项组成，并以逗号分隔。捕捉列表有以下几种形式：

1.[var]表示值传递方式捕捉变量var；
2.[=]表示值传递方式捕捉所有父作用域的变量（包括this）；
3.[&var]表示引用传递捕捉变量var；
4.[&]表示引用传递方式捕捉所有父作用域的变量（包括this）；
5.[this]表示值传递方式捕捉当前的this指针。

上面提到了一个父作用域，也就是包含Lambda函数的语句块，说通俗点就是包含Lambda的“{}”代码块。上面的捕捉列表还可以进行组合，例如：

1.[=,&a,&b]表示以引用传递的方式捕捉变量a和b，以值传递方式捕捉其它所有变量;
2.[&,a,this]表示以值传递的方式捕捉变量a和this，引用传递方式捕捉其它所有变量。

不过值得注意的是，捕捉列表不允许变量重复传递。下面一些例子就是典型的重复，会导致编译时期的错误。例如：

3.[=,a]这里已经以值传递方式捕捉了所有变量，但是重复捕捉a了，会报错的;
4.[&,&this]这里&已经以引用传递方式捕捉了所有变量，再捕捉this也是一种重复。

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  
        auto x5 = [this] { return i_ + x + y; };            //error,没有捕获x,y  
        auto x6 = [this, x, y] { return i_ + x + y; };      //OK  
        auto x7 = [this] { return i_++; };                  //OK  
};  
  
int a=0 , b=1;  
auto f1 = [] { return a; };                     //error,没有捕获外部变量      
auto f2 = [&] { return a++ };                   //OK  
auto f3 = [=] { return a; };                    //OK  
auto f4 = [=] {return a++; };                   //error,a是以复制方式捕获的，无法修改  
auto f5 = [a] { return a+b; };                  //error,没有捕获变量b  
auto f6 = [a, &b] { return a + (b++); };      	//OK  
auto f7 = [=, &b] { return a + (b++); };      	//OK 

有些需要提醒的地方：

1. 一个容易出错的细节是lambda表达式的延迟调用，lambda表达式按值捕获了所有外部变量。在捕获的一瞬间，a的值就已经被复制了。如果希望lambda表达式在调用时能即时访问外部变量，我们应当使用引用方式捕获。

int a = 0;  
auto f = [=] { return a; };  
a+=1;  
  
cout << f() << endl;       //输出0  
   
int a = 0;  
auto f = [&a] { return a; };   
a+=1;  
  
cout << f() <<endl;       //输出1  

2.

虽然按值捕获的变量值均补复制一份存储在lambda表达式变量中， 修改他们也并不会真正影响到外部，但我们却仍然无法修改它们。

那么如果希望去修改按值捕获的外部变量，需要显示指明lambda表达式为mutable。

需要注意：被mutable修饰的lambda表达式就算没有参数也要写明参数列表。
原因：lambda表达式可以说是就地定义仿函数闭包的“语法糖”。它的捕获列表捕获住的任何外部变量，最终均会变为闭包类型的成员变量。按照C++标准，lambda表达式的operator()默认是const的，一个const成员函数是无法修改成员变量的值的。而mutable的作用，就在于取消operator()的const。

int a = 0;  
auto f1 = [=] { return a++; };                  //error  
auto f2 = [=] () mutable { return a++; };       //OK  

最后，举两个例子，加深对C++中的lambda表达式的理解。

// example1

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 % 2) == 0) 
        ++ even_count;  
});  
std::cout << "The number of even is " << even_count << std::endl;  

// example2

int count = std::count_if( coll.begin(), coll.end(), [](int x){ return x > 10; });  
  
int count = std::count_if( coll.begin(), coll.end(), [](int x){ return x < 10; });  
  
int count = std::count_if( coll.begin(), coll.end(), [](int x){ return x > 5 && x<10; });