前言
在Cpp11以前，为了把函数当作对象调用，可以使用C中的函数指针类型，也可以使用Cpp98的仿函数。
但二者都不是很好用，函数指针 return_type (*name)(parameters)的长相就令人望而却步，仿函数将一个函数重载为一个类的operator()的方式又沉重麻烦。
C++11中做出了(抄Python的)更灵活、轻便的lambda表达式。
lambda表达式
lambda表达式 是一个 匿名函数对象，本质上是一个对象。
语法格式
[capture_list](parameters)->return_type
{
};由捕捉列表、参数列表、返回值、函数体四大部分构成。
捕捉列表用于捕捉此前出现过的变量，后三大部分就是函数正常的定义理解。（如果函数无参且无返回值，可以省略这两大部分，但是捕捉列表和函数体不可省略）
捕捉列表
由于lambda本质是一个对象，在写出lambda表达式时，就在创建一个对象。
捕捉列表中捕捉的值，就是构造函数的参数，用于初始化成员变量，以供函数体中直接使用。
捕捉的规则如下：
【1】捕捉某变量的值
int a = 1, b = 2;
auto afun = [a](){
cout << a << endl;
}
auto abfun = [a, b](int x, int y){
cout << a + b << endl;
}此时，捕捉a、b值，相当于拷贝a、b的值，lambda中的a、b和外面的变量a、b是两个东西。
且lambda内部不能修改捕捉的变量值，会报错。（硬要修改就要了解mutable关键字）
【2】捕捉某变量的引用
要捕捉变量引用，就在捕捉列表中，变量前加上一个&。
int a = 0;
auto af = [&a](){
a++;
cout<< a << endl;
};此时的变量a就是内外统一的了，允许修改了。
【3】捕捉所有变量的值
int a = 0, b = 1, c = 2, d = 3;
auto all_fun = [=]{ //捕捉所有要用到的变量值
cout << a+b+c+d << endl;
};
auto all_fun = [=, &a]{ //在=后指定需要引用的变量
a++;
cout << a+b+c+d << endl;
};前者用 = 表示 捕捉所有要用到的变量值；后者在 = 后指定需要引用的变量。
【4】捕捉所有变量的引用
int a = 0, b = 1, c = 2, d = 3;
auto r_fun_1 = [&]{
a++;b++;c++;
};
auto r_fun_2 = [&, a]{
b++;c++;d++;
};用&表示捕获所有被使用的变量的引用；后者指定捕获某变量的值。
补充
【1】全局变量不需要捕捉，也不能。
【2】返回值可以不写，函数体内部返回值时，编译器会自己推。但建议写，为了代码的可读性。
【3】使用auto可以推导lambda的类型，这个类型由编译器决定，MSVC用uuid来保证不同的lambda有不同的类型。这样匿名函数对象就可以被引用了，延长了生命周期，可以直接作为一个函数使用。（模板也能推）
应用场景
在使用算法库中的sort排序时，有时想要按照特殊的要求进行排序，就要传仿函数对象。
现在，我们可以直接传lambda匿名函数对象即可，轻便易读。可以替换仿函数的大部分使用。
包装器
function和bind都在<functional>头文件中。
function类模板
template <class T> function; // undefined
template <class Ret, class... Args> class function<Ret(Args...)>;function包装器一般用于包装返回值、参数列表的函数对象。包装前进行特化即可。
用函数的返回值和参数类型进行特化：Ret是前者类型，可变参数包Args是后者。
int pf(int a, int b)
{
return a + b;
}
struct Functor
{
int operator()(int a, int b)
{
return a - b;
}
};
int main()
{
auto lf = [](int a, int b) { return a * b; };
function<int(int, int)> f1 = &pf; //函数名也行，也是函数指针
function<int(int, int)> f2 = lf;
function<int(int, int)> f3 = Functor();
vector<function<int(int, int)>> funcs = { f1, f2, f3 };
//非静态成员函数
function<int(Functor*, int, int)> f4 = &Functor::operator();
function<int(Functor&&, int, int)> f5 = &Functor::operator();
Functor f1_obj;
f4(&f1_obj, 5, 6);
f5(Functor(), 5, 6);
return 0;
}通过上例可见，用function包装了函数指针，lambda函数对象，仿函数对象。
这样统一了他们的类型，最后竟能放在一个容器里。
特殊的地方在于下面的非静态成员函数的包装。由于成员函数有一个隐式的参数--this指针，所以其特化类型与上面不同，但既可以传引用，也可以传指针。
在调用时，也要手动传入对象的指针或者对象。
这个就需要回顾类和对象重载运算符 .* 和 ->* 的知识点。但对比一下，可以看出，函数指针真的不方便，不如包装器好用。
typedef int(Functor::*PF)(int, int);
PF pf = &Functor::operator(); //成员函数指针必须加&才能取到
//int(Functor::*)(int, int) p = &Functor::operator();
//cpp不允许这样写和用函数指针类型
Functor f;
(f.*pf)(5, 6);
Functor* p = &f;
(p->*pf)(5, 6);bind函数模板
在了解了function的包装类型后，bind的作用就不太一样。
bind主要用于函数的参数个数或位置调整。需要结合placeholders命名空间中的_1、_2、...、_n的占位符使用。
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);使用：把要调整的函数的包装后的对象传给bind，使用占位符进行调整。
调整参数位置
using namespace placeholders;
int main()
{
auto fun = [](int a, int b) {
return a + b*10;
};
auto newFun = bind(fun, _2, _1);
cout << fun(3, 4) << endl; //43
cout << newFun(3, 4) << endl; //34
return 0;
}
bind中的占位符用来确定实参的位置，根据实参所在位置从左往右确定_1、_2等等。然后bind再将对应占位符的值传给原本的函数。以实现参数位置的调整。
调整参数个数
通过确定某个位置的值，以达到少传参数、调整参数个数的目的。
auto newFun_4 = bind(fun, _1, 4);
cout << newFun_2(3) << endl; // 3 + 4 * 10;强调：占位符指的是实参的位置。。。不要搞混了。