lambda表达式

Posted 2020-09-30 leno米雷のcoding记录

ISO C++ 11 标准的一大亮点是引入Lambda表达式。基本语法如下：

[capture list] (parameter list) ->return type { function body }

简单的讲一下各个部分的作用

1. [capture list]捕获列表，捕获到函数体中，使得函数体可以访问
2. (parameter list)参数列表，用来表示lambda表达式的参数列表
3. ->return type函数返回值 {function body}就是函数体

lambda表达式可以理解为一个匿名函数（但本质并不是），如果要使用lambda表达式声明的函数，需要给他“命名”

lambda表达式可以表示闭包，因为本身就是这个类
闭包是指可以包含自由变量的代码块 （未绑定到特定的对象：举个栗子std::function就可以产生一个对象，或者一个未指向任何函数的函数指针）
闭包讲的通俗一些有以下几点

1. 自带上下文的函数，闭包可以储存运行时需要的上下文，这样就可以在上下文不存在的时候还可以使用闭包（变量a生命周期到了被销毁，但是在闭包中还可以拿来用）
2. 可以把闭包看成一个重载了operator()的类，带有状态的意思就可以解释成通过this指针使用成员变量
3. capture list就是lambda表达式实现闭包的方式

简单使用的例子

---

 

C++11为auto提供了新的功能，如他的名字一般，现在可以看成自动适应类型，可以适应多数类型
使用auto来代替变量的类型，前提是被明确类型的初始化变量初始化的，可以使用auto关键字

1 auto f = [](){};  
2 auto f = [](int a, int b)->int {return a + b; };
3 f(1, 2);//需要这么使用

 

只要是函数类型就都可以使用这个lambda表达式

1 typedef int(*FUNC)(int a, int b);
2 int main()
3 {
4     FUNC  a= [](int a, int b) {return a + b; };
5    
6     printf("%d\n", a(1, 2));
7 }

 

声明函数的方法都可以接收不带捕获列表的lambda表达式

1 typedef std::function<int(int a, int b)> FUNC;
2 int main()
3 {
4     FUNC  a= [](int a, int b) {return a + b; };
5    
6     printf("%d\n", a(1, 2));
7 }

 

---

lambda表达式中capture list的用法

 1 int func(int a, int b, std::function<int(int, int)> f)
 2 {
 3     return f(a, b);
 4 }
 5 
 6 
 7 int a=1；
 8 int b=2;
 9 int c=3;
10 int d = func(a, b, [a, &b](int m, int n) {
11 
12         printf("a = %d\n", a); // a是通过值传递捕获，mutable只在函数体内修改有效
13         printf("b = %d\n", b); // b是引用传递捕获，mutable可以对外部b造成影响
14 
15                                //printf("c = %d\n", c); // c不可访问
16 
17         return m + n;
18     });
19 typedef int(*FUNC)(int m, int n,std::function<int(int ,int )> f);
20 
21 void test()
22 {
23     FUNC oho;
24     int a = 10;
25     int b = 20;
26     auto func = [&a, &b](int m, int n) {printf("a:%d  b:%d\n", a, b); return m + n;  };
27     
28 }

1. []空。没有使用任何函数对象参数。
2. [=]。函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是值传递方式（相当于编译器自动为我们按值传递了所有局部变量）。
3. [&]。函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是引用传递方式（相当于编译器自动为我们按引用传递了所有局部变量）。
4. [this]。函数体内可以使用Lambda所在类中的成员变量。
5. [a]。将a按值进行传递。按值进行传递时，函数体内不能修改传递进来的a的拷贝，因为默认情况下函数是const的。要修改传递进来的a的拷贝，可以添加mutable修饰符。
6. [&a]。将a按引用进行传递。
7. [a, &b]。将a按值进行传递，b按引用进行传递。
8. [=，&a, &b]。除a和b按引用进行传递外，其他参数都按值进行传递。注意=符号的位置必须在头一个
9. [&, a, b]。除a和b按值进行传递外，其他参数都按引用进行传递。&符号的位置必须在头一个

当你想改变通过传值方式捕捉的变量的时候就要添加mutable

[a, &b, &b2](int m, int n)mutable {a *= 2; return m*n; }:

---

lambda表达式的其他用法

 1 class A
 2 {
 3 public:
 4     A();
 5     ~A();
 6     void test()
 7     {
 8         auto f = [this](int m, int n) {printf("%d\n", a); };
 9     }
10         
11 private:
12     int a;
13 };

lambda表达式本质是一种闭包类型，虽然他可以赋值给函数指针，但是只限于在捕获列表为空的时候，当捕获列表有值的时候，应该使用auto来接收lambda表达式，或者用std::function也是可以的

1 main::__l2::<lambda_eb7b0a89c14bee3d2620c108ffb635c6>
2 //这是一个lambda表达式在VS2015环境下显示的类型，不用auto用什么来接收调用他呢？

 

本质来说lambda表达式之间是不允许赋值的

1 auto a = [](int m, int n) {return m + n; };
2 auto b = [](int m, int n) {return m - n; };
3 a = b;

 

操作非法，因为闭包类型不允许使用赋值操作符，但是函数指针可以，也就是可以有下面的操作

1 typedef int(*FUNC)(int a, int b);
2 int main()
3 {
4     FUNC  a = [](int a, int b) {return a + b; };
5     FUNC  b = [](int a, int b) {return a + b; };
6     a = b;
7     return 0;
8 }

std::function之间也是可以赋值的，他就可以办到有capture list的lambda表达式进行赋值

1 typedef std::function<int(int,int)> FUNC;
2 int m = 10;
3 int n = 20;
4 FUNC a = [m, n](int a, int b){printf("%d\n", m); return a + b; };
5 FUNC b = [m, n](int a, int b){return a + b; };
6 b = a;
7 b(1, 2);
8 //执行结果是可以把m打印出来的