详解C++11中的std::function和std::bind

在学习一些项目的过程中，我们常会设计一些回调函数来实现我们想要完成的任务，这就不可避免的接触到可回调对象。随着C++的不断发展，在C++11中，为我们提供了std::function和std::bind两个方法来对可回调对象进行统一和封装，这里对两者的用法进行一个总结。
首先来说一些可被调用的对象。

可调用的对象

C++中有以下几种可调用对象：

• 函数
• 函数指针，函数指针指向的是函数而非对象。和其他指针类型一样，函数指针指向某种特定类型，一般对于函数来说，函数名即为函数指针；
• lambda表达式：一段可调用的代码。适合于只用到一两次的简短代码段。由于lambda是匿名的，所以保证了其不会被不安全的访问: auto lambda = [](int a)->int{return a;};
• bind对象：std::bind可以用来生产，一个可调用对象来适应原对象的参数列表。
• 函数对象：重载了函数调用运算符()的类的对象。

什么是std::function

使用一个统一的方式保存可调用对象或者传递可调用对象。std::function是一个可调用对象包装器，是一个类模板，可以容纳除了类成员函数指针之外的所有可调用对象，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟它们的执行。一般形式如下：

# include <functional>
std::function<函数类型>

例如：

# include <iostream>
# include <functional>

typedef std::function<int(int, int)> comfun;

// 普通函数
int add(int a, int b) { return a + b; }

// lambda表达式
auto mod = [](int a, int b){ return a % b; };

// 函数对象类
struct divide{
    int operator()(int denominator, int divisor){
        return denominator/divisor;
    }
};

int main(){
	comfun a = add;
	comfun b = mod;
	comfun c = divide();
    std::cout << a(5, 3) << std::endl;
    std::cout << b(5, 3) << std::endl;
    std::cout << c(5, 3) << std::endl;
}

std::function做回调函数

代码参考：

• 首先，定义了一个Callback类型，是一个函数指针类型，表示可以接受一个正数参数并返回空值的函数。
• 随后，定义了一个performOperation函数，接受一个整型参数和一个回调函数参数，并执行相应操作
• 执行完以后，调用回调函数handleResult，执行相应操作。
  实际上，performOperation传入的handleResult就是Callback类型，相当于callback就是handleResult（100）

std::function的优点

• std::function对C++中各种可调用实体(普通函数、Lambda表达式、函数指针、以及其它函数对象等)的封装，形成一个新的可调用的std::function对象，简化调用；
• std::function对象是对C++中现有的可调用实体的一种类型安全(类型安全的代码不会试图访问自己没被授权的内存区域)的包裹(如：函数指针这类可调用实体，是类型不安全的)。

std::bind是什么

std::bind可以看作一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来适应原对象的参数列表。将可调用对象与其参数一起进行绑定，绑定后的结果可以使用std::function保存。

auto fr = std::bind(func1, std::placeholders::_1);

当调用fr时，会调用func1，并传给它参数。其中std::placeholders::_1是占位符。它们占据了传递给函数的参数的位置。_1为第一个参数，_2为第二个参数，以此类推。

需要注意的是：

• 如果预绑定的参数是以值传递的形式，不预绑定的参数要用std::placeholders(占位符)的形式占位，从_1开始，依次递增，是以引用传递的形式；并且std::placeholders表示新的可调用对象的第几个参数，而且与原函数的该占位符所在位置的进行匹配，例如：

auto f3 = std::bind(fun_1, std::placeholders::_2, std::placeholders::_1, 3); 
f2(1, 2);

这里调用fun_1时，传入的第一个参数是f2(1, 2)里面的2，第二个参数是f2(1, 2)里面的1，第三个是3，即和参数占位符中的_n是一一对应的。

• bind绑定类成员函数时，第一个参数表示对象的成员函数的指针，第二个参数表示对象的地址，这是因为对象的成员函数需要有this指针。并且编译器不会将对象的成员函数隐式转换成函数指针，需要通过&手动转换；
• std::bind的返回值是可调用实体，可以直接赋给std::function。

std::bind的作用

• 将可调用对象和其参数绑定成一个仿函数；
• 将多元（参数个数为n,n-1）可调用对象转换成一元或者（n-1）元可调用对象，即只绑定部分对象。
  用法参考：代码

#include <iostream>
#include <functional>

class A {
public:
    void fun_3(int k,int m) {
        std::cout << "print: k = "<< k << ", m = " << m << std::endl;
    }
};

void fun_1(int x,int y,int z) {
    std::cout << "print: x = " << x << ", y = " << y << ", z = " << z << std::endl;
}

void fun_2(int &a,int &b) {
    ++a;
    ++b;
    std::cout << "print: a = " << a << ", b = " << b << std::endl;
}

int main(int argc, char * argv[]) {
    //f1的类型为 function<void(int, int, int)>
    auto f1 = std::bind(fun_1, 1, 2, 3); 					//表示绑定函数 fun 的第一，二，三个参数值为： 1 2 3
    f1(); 													//print: x=1,y=2,z=3

    auto f2 = std::bind(fun_1, std::placeholders::_1, std::placeholders::_2, 3);
    //表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f2 的第一，二个参数指定
    f2(1, 2);												//print: x=1,y=2,z=3
 
    auto f3 = std::bind(fun_1, std::placeholders::_2, std::placeholders::_1, 3);
    //表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f3 的第二，一个参数指定
    //注意： f2  和  f3 的区别。
    f3(1, 2);												//print: x=2,y=1,z=3

    int m = 2;
    int n = 3;
    auto f4 = std::bind(fun_2, std::placeholders::_1, n); //表示绑定fun_2的第一个参数为n, fun_2的第二个参数由调用f4的第一个参数（_1）指定。
    f4(m); 													//print: a=3,b=4
    std::cout << "m = " << m << std::endl;					//m=3  说明：bind对于不事先绑定的参数，通过std::placeholders传递的参数是通过引用传递的,如m
    std::cout << "n = " << n << std::endl;					//n=3  说明：bind对于预先绑定的函数参数是通过值传递的，如n
    
    A a;
    //f5的类型为 function<void(int, int)>
    auto f5 = std::bind(&A::fun_3, &a, std::placeholders::_1, std::placeholders::_2); //使用auto关键字
    f5(10, 20);												//调用a.fun_3(10,20),print: k=10,m=20

    std::function<void(int,int)> fc = std::bind(&A::fun_3, a,std::placeholders::_1,std::placeholders::_2);
    fc(10, 20);   											//调用a.fun_3(10,20) print: k=10,m=20 

    return 0; 
}