C++ 11 Lambda表达式

  C++ 11的几大新特性为：引入了lambda表达式；改进了智能指针......。利用Lambda表达式，更方便的定义和创建匿名函数。这项新功能的添加同样也是用来缩短了（调用代码）距离，简洁，效率，功能性都有提升，下面详细介绍。

C++声明Lambda表达式

[ capture list ] ( params list ) mutable exception -> return type { function body }

各项详细介绍：

具体项介绍

1.capture list:	捕获外部变量列表
2.params list:	形参列表
3.mutable指示符：	用来说明是否可以修改捕获的变量
4.exception:	异常设定
5.return type:	放回类型
6.function body:	函数体

此外还有几种“不完整”的Lambda表达式：

//①
[capture list](params list)->return type{function body}
//②
[capture list](params list){function body}
//③
[capture list]{function body}

详细介绍：

》格式①：声明了const类型的表达式，这种类型的表达式不能修改捕获列表中的值。

》格式②：省略了返回值类型，但编译器可以根据以下规则推断出Lambda表达式的返回类型：如果有返回值，根据返回值的类型确定；没有返回值，则为                    viod类型。

》格式③：省略了参数列表，类似普通函数的无参函数。

庐山真面目：使用方法

//排序的实现
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;


//旧时做法：
bool cmp(int a,int b)
{
    return a<b;
}

int main()
{
    vector<int >myvec = {3,2,15,96,67,46};
    sort(myvec.begin(),myvec.end(),cmp);
    cout<<"Predicate function: "<<endl;
    for(int it:myvec)
    {
        cout<<it<<" ";
    }
    cout<<endl;
}
//Lambda做法：
int main()
{
    vector<int >myvec = {3,2,15,96,67,46};
    sort(myvec.begin(),myvec.end(),[](int a,int b)->bool {return a<b;});
    cout<<"Lambda expression: "<<endl;
    for(int it:myvec)
        cout<<it<<" ";
}   
        

在C++之前，我们使用STL的sort函数，需要提供一个谓词函数。如果使用C++11的Lambda表达式，我们只需要传入一个匿名函数即可，方便简洁，而且代码的可读性也比旧式的做法好多了。

下面我们来介绍一下Lambda表达式各项的具体用法。

捕获外部变量

Lambda表达式可以使用其可见范围内的外部变量，但是必须明确声明（明确声明哪些外部变量可以背该Lambda表达式使用）。那么，在哪里指定这些外部变量呢？Lambda表达式通过在最前面的方括号[]来明确指定其内部可以访问的外部变量，这一过程也称过Lambda表达式“捕获”了外部变量。

我们通过一个例子来直观地说明一下：

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

    //或通过“函数体”后面（）传入参数。
    auto x = [](int a){cout<<a<<endl;}(123);

}

先声明了一个整型变量a，然后创建Lambda表达式，该表达式“捕获”了a变量，这样在Lambda表达式函数体中就可以获得该变量的值。

类似的参数传递方式（值传递，引入传递，指针传递），在Lambda表达式中，外部变量的捕获方式也有值捕获，引用捕获，隐式捕获。

1.值捕获：

值捕获和参数传递中的值传递类似，被捕获的变量的值在Lambda表达式创建时通过值拷贝的方式传入，因此随后对变量的修改不会影响lambda表达式中的值。

2.引用捕获：

使用引用捕获一个外部变量，只需要在捕获列表变量前面加上一个引用说明符&。如下：

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

引用捕获变量使用的实际上就是该引用所绑定的对象。

3.隐式捕获：

上面的值捕获和引用捕获都需要我们在捕获列表中显示列出Lanbda表达式中使用的外部变量。除此之外，我们还可以让编译器根据函数体中的代码来推断需要捕获哪些变量，这种方式称之为隐式捕获有两种方式，分别是[=]和[&]。[=]表示以值捕获的方式捕获外部变量，[&]表示以引用的方式捕获外部变量。

隐式捕获示例：

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

隐式引用捕获示例：

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

4.混合方式

上面的例子，要么是值捕获，要么是引用捕获，Lambda表达式捕获外部变量主要是以下形式：

C++11中的Lambda表达式捕获外部变量的主要形式有一下形式：

捕获外部变量的主要形式

捕获形式：	说明：
[]	不捕获任何外部变量
[变量名......]	默认以值形式捕获指定的多个外部变量（用逗号分隔），如果引用捕获，需要显示声明（使用&说明符）
[this]	以值的形式捕获this指针
[=]	以值的形式捕获所有外部变量
[&]	以引用的方式捕获所有外部变量
[=,&x]	变量x以引用的方式捕获，其余变量以值传递形式捕获
[&,x]	变量x以值的形式捕获，其余变量以引用形式捕获

修改捕获变量

在Lambda表达式中，如果以传值方式捕获外部变量，则函数体中不能修改该外部变量，否则就会引发编译错误。那么有没有办法可以修改值捕获的外部变量呢？这是就是需要使用mutable关键字，该关键字用以说明表达式体内的代码可以修改值捕获的变量，实例：

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

Lambda表达式的参数

Lambda表达式的参数和普通函数的参数类似，但是Lambda表达式中传递参数还有一些限制，主要有一下几点：

 》1.参数列表中不能有默认参数

 》2.不支持可变参数

 》3.所有参数必须有参数名

{
　　　　 int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5);
        cout << "m:" << m << endl;            　　//输出m:16

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

        auto hFunc = [](const function<int(int)>& f, int z) { return f(z) + 1; };
        auto a = hFunc(gFunc(7), 8);

        int a = 111, b = 222;
        auto func = [=, &b]()mutable { a = 22; b = 333; cout << "a:" << a << " b:" << b << endl; };

        func();
        cout << "a:" << a << " b:" << b << endl;

        a = 333;
        auto func2 = [=, &a] { a = 444; std::cout << "a:" << a << " b:" << b << std::endl; };
        func2();

        auto func3 = [](int x) ->function<int(int)> { return [=](int y) { return x + y; }; };

    　　
　　　　 std::function<void(int x)> f_display_42 = [](int x) { print_num(x); };
	f_display_42(44);
　　}

匿名函数与仿函数的相似之处与不同

#include <iostream>
using namespace std;

//仿函数：对（）进行重载的函数，在调用（）时与调用函数有着相似之处，但是是通过对象名称调用的
class Functor{
public:
    Functor(int a = 0; int b = 0){}        
    void operator() (){cout<<_a + _b;}
private:
    int _a;
    int _b;
};
int main()
{
    Functor sum(10,20);
    sum();
    
    auto sum1 = [](int a,int b){cout<<a+b<<endl;};
    sum1(20,20);    
    return 0;
}

通过上面的例子，除去在语法层面上的不同，仿函数和Lambda表达式都是通过捕捉一些变量作为初始值，之后进行传递参数并进行计算。在形式上，仿函数通过构造函数构造进行初始化，而Lambda表达通过捕捉列表[capture]获取初始值。仿函数通过operator()重载函数的参数列表进行传参，而Lambda表达式通过（parameters）参数列表进行传参。最后仿函数的执行体在operator（）函数体中进行运算，而lambda表达式在{}进行计算。