前言

在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;     // undefinedtemplate <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;     //43cout << newFun(3, 4) << endl;  //34return 0;
}

bind中的占位符用来确定实参的位置，根据实参所在位置从左往右确定_1、_2等等。然后bind再将对应占位符的值传给原本的函数。以实现参数位置的调整。

调整参数个数

通过确定某个位置的值，以达到少传参数、调整参数个数的目的。

auto newFun_4 = bind(fun, _1, 4);cout << newFun_2(3) << endl;  // 3 + 4 * 10;

强调：占位符指的是实参的位置。。。不要搞混了。