C++lambda表达式简记

简记：

C++11的新特性，lambda表达式在python、javascript等语言当中要已实现。它可以简洁代码，把逻辑抽象出来，使程序富于弹性，更加方便阅读等功能。作为c++11里面比较重要的一个补充，还是很有必要总结和记录滴。

在 C++ 11 中，lambda 表达式（通常称为 “lambda”）是一种在被调用的位置或作为参数传递给函数的位置定义匿名函数对象的简便方法。 Lambda 通常用于封装传递给算法或异步方法的少量代码行。

使用格式：

1. Capture 子句（在 C++ 规范中也称为 lambda 引导。），在c++ primer叫做捕获列表。在上下文当中捕获变量提供给lambda表达式使用，还可以设置值传递方式等。
2. 参数列表（可选）。 （也称为 lambda 声明符)和普通的函数参数列表一样，没什么区别。
3. 可变规范（可选）。在缺省的情况下，lambda函数是一个const函数（后面有例子），mutable参数可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）。
4. 异常规范（可选）。用来抛出异常使用。
5. 尾随返回类型（可选）。如果省略返回类型，那么编译器将自动推导类型。

6. “lambda 体”。就是函数体，可以使用参数表中的参数，和捕获变量。

   大概模样是这样

#include <bits/stdc++.h>
using namespace std;
int main()
{
    ios::sync_with_stdio(false);
    int x=1,y=2;//第1行
    auto lam=[=](int p)mutable->int{return p+x+y;};
    cout<<lam(10)<<endl;//输出13
    return 0;
}

首先简单解释一下上面的代码
第1行声明了两个变量，x和y。没啥好废话的。
第2行声明了一个lambda表达式，其中捕获列表[=] 表示lambda函数当中可以使用上下文当中的变量，如果写成[] 编译器会报错数x和y没有被捕获到。
接下来是一个参数表(int p) 声明了一个int参数p，后面的关键字表示这不是一个常量的lambda函数，后面会有例子。接下来指定返回类型为int型，同时执行函数体当中的内容。

捕获列表：

1. [factor]表示通过值传递直接捕获factor。
2. [=]表示值传递方式波或所有上文中的所有变量。
3. [&factor]表示引用方式捕获变量factor。
4. [&]表示引用方式捕获所有上文中的遍历。
5. [this]表示值传递捕获this指针。
6. []不捕获任何变量

其中部分捕获列表可以组合使用，比如
[=,&x]表示用引用的方式捕获x其余的用值传递的方式。
[&,x]表示用值传递的方式捕获x，其余的用引用的方式。
注意，不能重复，否则会报错。比如
[=,x]所有值都用值传递捕获，再设置x用值传递会报错，同理引用。
例子

#include <bits/stdc++.h>
using namespace std;
int main()
{
    ios::sync_with_stdio(false);

    int x=1,y=2;
    auto lam1=[]{return 10;};//除了捕获列表和函数体，其余均缺省
    cout<<lam1()<<endl;//10

    auto lam2=[=,&x]{return ++x;};
    lam2();
    cout<<x<<endl;//x为2

    return 0;
}

this指针作为捕获值出现

#include <bits/stdc++.h>
using namespace std;
class A
{
public:
    void fun()
    {
        cout<<"hi"<<endl;
    };
    void lambda(int x)
    {
        auto la=[this](int x){this->fun();cout<<x<<endl;};
        la(x);
    }
};
int main()
{
    ios::sync_with_stdio(false);
    A a;
    a.lambda(1);
    return 0;
}

mutable参数：

lambda是只const函数，mutable可以取消mutable的性质。但是，还会有一些注意事项。

#include <bits/stdc++.h>
using namespace std;
int main()
{
    ios::sync_with_stdio(false);
    int x=1,y=2;
//    auto lam2=[=,&x]{return ++y;};报错，y是只读的

    auto lam3=[=]()mutable{return ++y;};

    cout<<y<<" "<<lam3()<<endl;//2 3

    y=100;

    cout<<y<<" "<<lam3()<<endl;//100 4？

    auto lam4=[&]{return ++y;};

    cout<<y<<endl;//100

    cout<<y<<" "<<lam4()<<endl;//101 101？
    return 0;
}

其中lam2并未设置为mutable型，所以y值只读

lam3设置为mutable型，“y”值不再是只读类型（先给所谓的y加上个引号）。
第一个结果输出是2 3，分析一下。y等于2，因为lam3是拷贝传递值，对外面的y没有影响，所以y值仍然是2。输出lam3，其中lam3对拷贝进来的y值增加了1，所以输出3.

接下来将y设置成100，再次输出y和lam3。结果y值是100，lam3居然是4？！ 怎么回事？
原来lam3里面的y看做一个常量，初始化后不会再改变，再次调用lam3只是对初始化后的y进行了+1操作，结果是4

调用lam4，其中lam4是以引用传递值的，先输出y，是100。嗯，没毛病，再次输出，咦？y咋变成101了，而且lam4也是101。

针对lam4再做个实验。

#include <iostream>
using namespace std;
int fun(int &x)
{
    return ++x;
}
int main()
{
    int y=2;
    cout<<y<<" "<<fun(y)<<endl;//3 3
    return 0;
}

上面写的情况的出现，涉及到cout求值顺序的问题。
计算顺序：自右至左
输出顺序：自左至右
详见如下博客输出流的执行顺序

在泛型算法中配合使用：

C++的泛型算法当中几乎都支持像算法传递函数，使用lambda能减少无谓的函数定义，缩减代码量。程序更加清晰易懂。
在C++ primer当中使用了如下几种函数作为例子来配合lambda表达式的使用，充分展现新特性的魅力。

• sort（排序函数）
• find_if（找到第一个满足条件的对象）
• for_each（操作一定范围内的对象，引用传值）
• transform （同样是操作一定范围的对象，拷贝传值）
• bind （后续再写）

以上函数简单记录，后序详细描述

使用例子

sort函数

    vector<int> v={2,3,1,5,4};
    sort(v.begin(),v.end(),[](const int &a,const int &b){return a>b;});

find_if函数
返回一个迭代器

    vector<int> v={2,3,1,5,4};
    int ind=3;
    auto it=find_if(v.begin(),v.end(),[ind](const int &a){return a>ind;});
    cout<<*it<<endl;

for_each函数

vector<int> v={2,3,1,5,4};
    for_each(v.begin(),v.end(),[](const int &a){cout<<a<<" ";});

transform函数

接受4个参数，还能接受6个。在4个参数的情况，前两个参数为原始迭数据的范围，第三个参数为返回值存储的起始位置，第四为一元函数。

    vector<int> v={2,3,1,5,4};
    vector<int> vt(5,0);//一定要初始化!
    transform(v.begin(),v.end(),vt.begin(),[](const int &a){return a+1;});
    for(auto x:vt)
        cout<<x<<" ";//3 4 2 6 5
    cout<<endl;

lambda还能实现闭包等操作一些列高级操作，等后续遇到的时候再写上

to be continue~