056-C++11之匿名函数（lambda表达式）

moc

1、lambda表达式声明
lambda表达式是C++11引入的新特性，可以方便的定义和创建匿名函数。
Lambda表达式完整的声明格式如下：
        [capture list] (params list) mutable exception-> return type { function body }

各项具体含义如下
        capture list：  捕获外部变量列表
        params list：  形参列表
        mutable指示符：  用来说明是否可以修改捕获的变量
        exception：  异常设定
        return type：  返回类型
        function body：  函数体
当然上面是完整类型的lambda表达式，也可为：
1） [ capture-list ] ( params ) -> ret { body }      ===> 省略了mutable，表示Lambda表达式不能修改捕获的变量。
2） [ capture-list ] ( params ) { body }               ===> Lambda的返回值类型如果可以由函数体中的实际返回值推导出，可以省略。  
3） [ capture-list ] { body }                               ===> 如果没有形参，可以省略圆括号。

1. int main()
   
2. {
   
3.         int x = 10;
   
4.         int y = 3;
   
5.         int z = [=]()mutable throw() -> int
   
6.         {
   
7.                 int n = x + y;
   
8.                 x = y;
   
9.                 y = n;
   
10.                 return n;
    
11.         }();
    
12.         cout << z << endl;
    
13.         cout << "x:" << x << "\t" << "y:" << y << endl;
    
14.         return 0;
    
15. }

复制代码

2、参数捕获
        Lambda表达式可以使用其可见范围内的外部变量，但必须明确声明哪些外部变量可以被该Lambda表达式使用。
        通过在最前面的方括号[]来明确指明其内部可以访问的外部变量，这一过程也称为Lambda表达式“捕获”外部变量。
1.值捕获
        值捕获和参数传递中的值传递类似，被捕获的变量的值在Lambda表达式创建时通过值拷贝的方式传入，因此随后对该变量的修改不会影响影响Lambda表达式中的值。
注意：如果以传值方式捕获外部变量，则在Lambda表达式函数体中不能修改该外部变量的值。

1. int main()
   
2. {
   
3.     int a = 123;
   
4.     auto f = [a] { cout << a << endl; };
   
5.     a = 321;
   
6.     f(); // 输出：123
   
7. }

复制代码

2、引用捕获
        使用引用捕获一个外部变量，通过[&]。
        引用捕获的变量使用的实际上就是和引用的对象绑定。

1. int main()
   
2. {
   
3.     int a = 123;
   
4.     auto f = [&a] { cout << a << endl; };
   
5.     a = 321;
   
6.     f(); // 输出：321
   
7. }

复制代码

3、[=]捕获
隐式捕获:   让编译器根据函数体中的代码来推断需要捕获哪些变量，有两种方式，分别是[=]和[&].
[=]  表示以值得方式捕获外面所有变量，[&] 表示以引用得方式捕获外面所有变量。

1. int main()
   
2. {
   
3.     int a = 123;
   
4.     auto f = [=] { cout << a << endl; };    // 值捕获
   
5.     f(); // 输出：123
   
6. }

复制代码

4、混合方式
上述捕获方式的组合。
[]      ==>           不捕获任何外部变量；
[变量名, …]    ==>    以值得形式捕获指定的多个外部变量（用逗号分隔）;
[this]    ==>   以值的形式捕获this指针;
[=, &x]    ==>  变量x以引用形式捕获，其余变量以传值形式捕获;
[&, x]    ==>  变量x以值的形式捕获，其余变量以引用形式捕获
推荐使用：[=]方式

修改捕获变量：  mutable关键字
        如果以传值方式捕获外部变量，则函数体中不能修改该外部变量，如果非要改变外部的值，就需要使用mutable关键字，该关键字用以说明表达式体内的代码可以修改值捕获的变量。

1. int main()
   
2. {
   
3.     int a = 123;
   
4.     auto f = [a]()mutable { cout << ++a; }; // 不会报错
   
5.     cout << a << endl; // 输出：123
   
6.     f(); // 输出：124
   
7. }

复制代码

3、lambda表达式的参数
Lambda表达式中传递参数有一些限制，主要有：
        1. 参数列表中不能有默认参数;
        2. 不支持可变参数;
        3. 所有参数必须有参数名.

1. int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5);
   
2.         std::cout << "m:" << m << std::endl;            　　//输出m:16
   
3.         std::cout << "n:" << [](int x, int y) { return x + y; }(5, 4) << std::endl;    //输出n:9
   
4.         auto gFunc = [](int x) -> function<int(int)> { return [=](int y) { return x + y; };

复制代码

4、lambda表达式做函数参数
        经测试无法用函数指针去接匿名函数，通过类型推断匿名表达式应该是一个匿名函数对象，所以无法用正常的函数指针去接；
        需要使用函数模板通过类型自动推导来实现参数的传递。

1. template <typename F>
   
2. void pri#include "iostream"
   
3. #include "string"
   
4. #include <typeinfo.h>  // 类型推断头文件
   
5. using namespace std;
   
6. 
   
7. template <typename F>
   
8. void print(F const &f)
   
9. {
   
10.         std::cout << f() << std::endl;
    
11. }
    
12. 
    
13. int main()
    
14. {
    
15. 
    
16.         std::cout << "Hello, World!" << std::endl;
    
17.         int num = 101;
    
18. 
    
19.         auto a = [&]//以引用的方式捕获本函数中的变量  
    
20.                 () //无参数   
    
21.                 ->std::string
    
22.         {//返回值的类型为std::string  
    
23.                 return std::to_string(num);   
    
24.         };
    
25.         cout << "a的类型：" << typeid(a).name() << endl;  //输出  class <lambda_ab0ac4e1dfacdc99b54bfdb8129c8b23>
    
26. 
    
27.         print(a);
    
28.         num++;   
    
29.         print(a);
    
30.         system("pause");
    
31.         return 0;
    
32. }

复制代码

易水霖