1. std::bind

std::bind 的函数原型：

simple(1)：	template <class Fn, class... Args>  /* unspecified */ bind (Fn&& fn, Args&&... args);with return type (2)：template <class Ret, class Fn, class... Args>  /* unspecified */ bind (Fn&& fn, Args&&... args);

作用：返回基于fn的函数对象，但其参数绑定到args。

每个参数都可以绑定到一个值或占位符：

如果绑定到一个值，则调用返回的函数对象将始终使用该值作为参数。如果是一个占位符，则调用返回的函数对象会转发一个传递给调用的参数（该参数的顺序号由占位符指定）。

使用std::bind要注意的地方

bind预先绑定的参数需要传具体的变量或值进去，对于预先绑定的参数，是pass-by-value的。除非该参数被std::ref或者std::cref包装，才pass-by-reference。对于不事先绑定的参数，需要传std::placeholders进去，从_1开始，依次递增。placeholder是pass-by-reference的；bind的返回值是可调用实体，可以直接赋给std::function对象； 对于绑定的指针、引用类型的参数，使用者需要保证在可调用实体调用之前，这些参数是可用的；类的this可以通过对象或者指针来绑定

测试程序：

#include <iostream>     // std::cout#include <functional>   // std::bindusing namespace std;// a function: (also works with function object: std::divides<double> my_divide;)double my_divide (double x, double y) {return x/y;}struct MyPair {  double a,b;  double multiply() {return a*b;}};struct MyAdd {  double add(int a,int b) {return a+b;}};int main () {  using namespace std::placeholders;    // adds visibility of _1, _2, _3,...  // binding functions:  auto fn_five = std::bind (my_divide,10,2);               // returns 10/2  cout <<"fn_five(): "<<fn_five() << endl;                          	   // 5  auto fn_half = std::bind (my_divide,_1,2);               // returns x/2  cout <<"fn_half(10): "<< fn_half(10) << endl;                      		// 5  auto fn_invert = std::bind (my_divide,_2,_1);            // returns y/x  cout <<"fn_invert(10,2): "<< fn_invert(10,2) << endl;                      	// 0.2  auto fn_rounding = std::bind<int> (my_divide,_1,_2);     // returns int(x/y)  cout <<"fn_rounding(10,3): "<< fn_rounding(10,3) << endl;                   // 3  MyPair ten_two {10,2};  // binding members:  auto bound_member_fn = std::bind (&MyPair::multiply,_1); // returns x.multiply()  cout <<"bound_member_fn():ten_two.multiply() "<< bound_member_fn(ten_two) << endl;           // 20  auto bound_member_data = std::bind (&MyPair::a,ten_two); // returns ten_two.a  cout <<"bound_member_data():ten_two.a "<< bound_member_data() << endl;                // 10    MyAdd mAdd;      auto bound_member_fn_add = std::bind (&MyAdd::add,&mAdd,_1,_2); 	// returns mAdd.add(_1,_2)  cout <<"bound_member_fn_add(30,50): "<< bound_member_fn_add(30,50) << endl;           		// 80  return 0;}

执行结果：

[root@192 function和bind函数学习]# ./bindTestfn_five(): 5fn_half(10): 5fn_invert(10,2): 0.2fn_rounding(10,3): 3bound_member_fn():ten_two.multiply() 20bound_member_data():ten_two.a 10bound_member_fn_add(30,50): 80

类模版std::function是一种通用、多态的函数封装。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、bind表达式、函数指针以及其它函数对象。std::function对象是对C++中现有的可调用实体的一种类型安全的包装（我们知道像函数指针这类可调用实体，是类型不安全的）。

通过std::function对C++中各种可调用实体（普通函数、Lambda表达式、函数指针、以及其它函数对象等）的封装，形成一个新的可调用的std::function对象；让我们不再纠结那么多的可调用实体。

测试程序：

#include <functional>#include <assert.h>#include <iostream>using namespace std; /*加减乘除举例*/typedef std::function<int(int,int)>  mFunctor;int add(int a,int b){    return a+b;}struct sub{    int operator()(int a,int b)    {        return a-b;    }};auto Lam = [](int a,int b)->int{return a*b;};class Math{public:    static int div(const int a, const int b)    {        assert(b);        return a/b;    }	int print_sum(int n1, int n2)    {        return n1+n2;    }};int main(){    int a = 10, b = 5;	Math math;	    std::function<int(int,int)> fun1 = add;     //普通函数    mFunctor fun2 = sub();						//重载了函数调用运算符的函数对象    mFunctor fun3 = Lam;      					//lambada表达式    mFunctor fun4 = Math::div;  				//类静态成员函数	std::function<int(int,int)> fun5 = std::bind(&Math::print_sum, &math, std::placeholders::_1, std::placeholders::_2);//类成员函数		cout<<"fun1 add:"<<fun1(10,5)<<endl;	cout<<"fun2 sub():"<<fun2(10,5)<<endl;	cout<<"fun3 Lam:"<<fun3(10,5)<<endl;	cout<<"fun4 Math::div:"<<fun4(10,5)<<endl;	cout<<"fun5 Math::print_sum:"<<fun5(10,5)<<endl;    return 0;}

执行结果：

[root@192 function和bind函数学习]# ./functionTestfun1 add:15fun2 sub():5fun3 Lam:50fun4 Math::div:2fun5 Math::print_sum:15