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 }                               ===> 如果没有形参，可以省略圆括号。

int main()
{
        int x = 10;
        int y = 3;
        int z = [=]()mutable throw() -> int 
        { 
                int n = x + y;
                x = y; 
                y = n;
                return n; 
        }();
        cout << z << endl;
        cout << "x:" << x << "\t" << "y:" << y << endl;
        return 0;
}

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

int main()
{
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    a = 321;
    f(); // 输出：123
}

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

int main()
{
    int a = 123;
    auto f = [&a] { cout << a << endl; }; 
    a = 321;
    f(); // 输出：321
}

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

int main()
{
    int a = 123;
    auto f = [=] { cout << a << endl; };    // 值捕获
    f(); // 输出：123
}

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

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

int main()
{
    int a = 123;
    auto f = [a]()mutable { cout << ++a; }; // 不会报错
    cout << a << endl; // 输出：123
    f(); // 输出：124
}

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

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

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

template <typename F>
void pri#include "iostream"
#include "string"
#include <typeinfo.h>  // 类型推断头文件
using namespace std;

template <typename F>
void print(F const &f) 
{
        std::cout << f() << std::endl; 
} 

int main() 
{

        std::cout << "Hello, World!" << std::endl;
        int num = 101;

        auto a = [&]//以引用的方式捕获本函数中的变量  
                () //无参数    
                ->std::string 
        {//返回值的类型为std::string  
                return std::to_string(num);    
        };
        cout << "a的类型：" << typeid(a).name() << endl;  //输出  class <lambda_ab0ac4e1dfacdc99b54bfdb8129c8b23> 

        print(a); 
        num++;    
        print(a);
        system("pause");
        return 0;
}

易水霖