• 作者: 雪山肥鱼
• 时间：20220226 21:52
• 目的: function

# 标准库中的std::function
# 实现类似std::function的功能

标准库中的 std::function

function 可调用对象包装器
函数名(函数指针)，仿函数，lambda表达式等等，都是可调用对象

#include <iostream>
#include <functional>

using namespace std;

void myfunc(int tmpvalue) {
    cout << "myfunc 执行了 tmpvalue = " << tmpvalue << endl;
}

void callObjFunc(function<void(int)> cobj) {
    cobj(120);
}

int main(int argc, char **argv) {

    callObjFunc(myfunc);

    callObjFunc([](int tmpvalue) {
        cout << "lambda tmpvalue= " << tmpvalue << endl;
    });

    return 0;
}

function 即 接受各种可调用对象。

实现类似 function 的功能

#include <iostream>
#include <functional>

using namespace std;

void myfunc(int tmpvalue) {
   cout << "myfunc 执行了 tmpvalue = " << tmpvalue << endl;
}

void callObjFunc(function<void(int)> cobj) {
   cobj(120);
}

//4.引入可调用对象处理器
template <typename T, typename... Args>
class CFObjHandler {
public:
   virtual T invoke(Args... args) const {

   }
};

//5.需要传给handler U(可调用类型) 增加子类模板 
template <typename U, typename T, typename... Args>
class CFObjHandlerChild :public CFObjHandler<T, Args...>
{
public:
   //构造函数，这里并不是万能引用，纯右值引用
   CFObjHandlerChild(U && tmpfuncobj) :functor(std::forward<U>(tmpfuncobj))
   {

   }

   T invoke(Args... args) const {
       return functor(std::forward<Args>(args)...);
   }
private:
   U functor;//U 是一个可调用变量类型，functor 用于保存可调用对象
};

//泛化版本 -- 仅声明,因为用不到，但 有特化 必须先有泛化
template <typename T>
class CallFuncObj;

//特化版本
template<typename T, typename... Args>
class CallFuncObj<T(Args...)> {//1. T: 可调用对象的返回类型， Args...: 参数类型
   //整个 T(Args) 是一个参数， 与上面的 泛化只有一个 typename T统一
public:
   //2. 增加构造函数
   template<typename U>
   CallFuncObj(U && acobj) {//万能引用,acobj 是一个可调用对象，需要保存下来,U 需要传递到CFObjHandler
       //也需要把U(可调用类型) 传给 CFObjHandler
       //6. 增加相关代码
       handler = new CFObjHandlerChild<U, T, Args...>(std::forward<U>(acobj));
   }

   ~CallFuncObj()
   {
       delete handler;
   }

   //3. 增加 opertor()
   T operator() (Args... args) const {
       return handler->invoke(std::forward<Args>(args)...);//保持原始实参的左值性和 右值性
   }

private:
   CFObjHandler<T, Args...> * handler;//可调用对象处理起 这是父类型

};

void callObjFunc2(CallFuncObj<void(int)> cobj){
   cobj(120);//调用额是 CallFuncObj 的 opertor（），所以需要重载()
}

int main(int argc, char **argv) {

   callObjFunc2(myfunc);
   CallFuncObj<void(int)> f1 = myfunc;
   f1(1200);
   return 0;
}

1. 关于特化的补充，如注释所说，在特化中，在意的是 特化<参数个数A> 与 template<参数个数B> 泛化， A 与 B 的统一。
2. 增加模板构造函数，参数为万能引
   用
3. 重载 opertor()
4. 增加可调用对象处理器
5. .需要传给handler U(可调用类型) 增加子类模板
6. 在构造函数中，增加相关代码

解释：为何子类CFObjHandlerChild 的构造函数 参数为 U && 右值。

1. 首先避免拷贝，用U 也是完全可以的。
2. 如果传入的是 lambda表达式，修改成左值是不行的。

分析调用流程：

CallFuncObj<void(int)> f1 = myfunc

1. 执行构造函数模板

template <typename U>
CallFuncObj(U && acobj) {
  handler = new CFObjHandlerChild<U, T, Args...>(std::forward<U>(acobj))
}

这里U 的类型是void(&)(int) 是左值引用类型。foward后 依旧是 左值类型。

2. 进入 child 的构造函数

CFObjHandlerChild(U && tmpfuncobj): functor(std::foward<U>(tmpfuncobj)) {

}

此时 用用到引用折叠规则，U &，如果任意一个引用为左值引用，那么结果就为左值引用。
传进来的是 void(&)(int) 此时 U& 依旧为 void(&)(int)

左值-》 左值 没问题。

依旧是折叠规则，如果参数为 U && ， 左值void(&)(int) 进来，这两个其中有一个 是 左值引用，则 U && 输出结果 依旧为 void(&)(int)左值引用。

所以 这里如果是&& 左值引用和右值引用都没问题。
只是左值引用 lambda 表达式 就不能编译通过了。