c++11——std::function和bind绑定器

c++11中增加了std::function和std::bind，可更加方便的使用标准库，同时也可方便的进行延时求值。

可调用对象

c++中的可调用对象存在以下几类： 
（1）函数指针 
（2）具有operator()成员函数的类对象（仿函数） 
（3）可被转换为函数指针的类对象 
（4）类成员（函数）指针

void func(void){
    //....
}
 
struct Foo{
    void operator()(void){
        //...
    }
};
 
struct Bar{
    using fr_t = void(*)(void);
    static void func(void){
        //...
    }
    operator fr_t(void){  //可以进行隐式转换，转换结果为 fr_t 为一个函数指针
        return func;     //operator xxx (void) 函数可以对类的对象进行隐式转换
    }
};
 
struct A{
    int a_;
    void mem_func(void){
        //...
    }
};
int main(){
    void(* func_ptr)(void) = &func; //1.函数指针
    func_ptr(); 
 
    Foo foo;                //2. 仿函数
    foo();
 
    Bar bar;
    bar();          //可被转化为函数指针的类对象
 
    void (A::*mem_func_ptr)(void) = &A::mem_func; //类成员函数指针
 
    int A::*mem_obj_ptr = &A::a; //类成员指针
    return 0;
}

可调用对象包装器——std::function

c++11通过std::function, std::bind统一了可调用对象的各种操作。std::function是可调用对象的包装器，它是一个类模板，可以容纳类成员（函数）指针之外的所有可调用对象。通过指定它的模板参数，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延时执行它们。 
std::function<返回值（参数类型）> f;

void func(void){
}
class Foo{
public:
    static int foo_func(int a){
        std::cout << "hello" <<std::endl;
        return a;
    }
};
int main(){
    std::function<void(void)> f;
    f = func;
    std::function<int(int)> = Foo::foo_func;
    return 0;
}

std::bind绑定器

std::bind用来将可调用对象与其参数一起进行绑定。绑定后的结果可以使用 std::function进行保存，并延迟调用到任何我们需要的时候。它主要有两大作用： 
（1）将可调用对象与其参数一起绑定成一个仿函数 
（2）将多元（参数个数为n>1）可调用对象转成x元( 0 <= 0 <= n)元可调用对象，即只绑定部分参数。 
（3）使用bind可以将类的非静态成员函数绑定起来，赋值给一个可执行std::function对象

#include<functional>
using namespace std;
 
int func(int a, int b){
	std::cout << "a = " << a << ", b = " << b << std::endl;
	return a + b;
}
 
class A{
public:
	int mem_func(int a, int b){
		std::cout << "a = " << a << ", b = " << b << std::endl;
		return a + b;
	}
};
int main(){
	//直接生成一个可调用对象，然后调用，参数为3
	//bind(func, 1, std::placeholders::_1)中表示将参数1 和参数 std::placeholders::_1作为函数func的参数，绑定成另一个可执行对象。
	//在绑定的时候， 按照顺序，1 作为 func(int a, int b) 中形参a的实参； std::placeholders::_1 作为 func(int a, int b) 中形参b的实参
 
	//std::placeholders::_1 是占位符，表示将绑定后得到的可执行对象进行调用的时候，实参的第1个，放到 std::placeholders::_1的位置上去
	//依次，std::placeholders::_2 将调用的时候实参的第2个，放到该位置上去
	//注意，占位符 std::placeholders::_x 中x必须小于等于调用的时候实际参数的个数！！
	std::bind(func, 1, std::placeholders::_1)(3);		//输出 a = 1, b = 3
	std::bind(func, 1, std::placeholders::_2)(3, 6);	//输出 a = 1, b = 6
 
	//用function可调用对象f保存bind后的结果
	std::function<int(int)> f = std::bind(func, 1, std::placeholders::_1);
	f(2);		//输出 a = 1, b = 2
	f = std::bind(func, std::placeholders::_1, 1);
	f(3);		//输出 a = 3, b = 1
 
	//将类的非静态成员函数，以及类的对象实例，进行绑定
	A a;
	f = std::bind(&A::mem_func, a, 1, std::placeholders::_1);
	f(10);
	return 0;
}

使用组合bind函数

bind可以组合多个函数，假设要找出集合中大于5小于10的元素个数. 
判断一个数是否大于5的闭包，代码std::bind(std::greater< int>(), std::placeholders::_1, 5) 
判断一个数是否小于10的闭包，代码std::bind(std::less_equal< int>(), std::placeholders::_1, 10) 
然后进行组合，得到：

using std::placeholders::_1;
//查找集合中大于5小于等于10的元素个数
auto f = std::bind(
std::logic_and<bool>(),
std::bind(std::greater<int>(), _1, 5),
std::bind(std::less_equal<int>(), _1, 10));
 
int count = std::count_if(coll.begin(), coll.end(), f);