std::function实现原理简述

实际上，每个function实例都根据函数类型的中返回值和参数类型推演出一个特例化，然后用类的成员变量去保留用这个函数类型的产生的函数指针，使用的时候实际上调用该类的小括号运算符重载operator()。

int sum(int a,int b){
  return a+b;
}

template <typename R>
class MyFunction{};

/*
部分特例化
R:operator()的返回值，Arg1，Arg1为operator()的形参类型
*/
template <typename R,typename Arg1,typename Arg2>
class MyFunction<R(Arg1,Arg2)>{
public:
  using Pfunc = R(*)(Arg1,Arg2); //定义用户传入的对于函数类型的函数指针 
  //typedef R(*Pfunc)(Arg...);
  MyFunction(Pfunc pfunc):pfunc_(pfunc){
    cout<<"call MyFunction(Pfunc pfunc)"<<"\n";
  }
  R operator()(Arg1 a1,Arg2 a2){
    cout <<"R operator()(Arg1 a1,Arg2 a2)"<<endl;
    return pfunc_(a1,a2);
  }
private:
  Pfunc pfunc_;//用来保留外部传入的可调用目标
};

使用时和标准库中无差别：

int main(){
  //使用标准库中的function来保留可调用目标类的成员变量
  std::function<int(int,int)>  func1 = sum;
  cout<<func1(10,10)<<endl;;

  //使用自定义的fuction来保留可调用目标到类的成员变量
  MyFunction<int(int,int)> func2 = sum;
  cout<<func2(10,20)<<endl; //func2.operator()(10,20)
  return 0;
}

上面的方式可以满足我们的需求，但是这样有个缺点，std::function保留的可调用目标的参数个数是不确定的，返回值肯定只能有一个，不能每次都根据不同的参数个数，去产生一大堆不一样的部分特例化，这样显然是不现实。c++11提供了模板可变参，可以将上面模板修改如下：

template <typename R,typename... Arg>
class MyFunction<R(Arg...)>{
public:
  using Pfunc = R(*)(Arg...); //定义用户传入的对于函数类型的函数指针 
  //typedef R(*Pfunc)(Arg...);
  MyFunction(Pfunc pfunc):pfunc_(pfunc){
    cout<<"call MyFunction(Pfunc pfunc)"<<"\n";
  }
  R operator()(Arg... arg){
    cout <<"R operator()(Arg...)"<<endl;
    return pfunc_(arg...);
  }
private:
  Pfunc pfunc_;//用来保留外部传入的可调用目标
};