- 作者: 雪山肥鱼
- 时间：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;
}
- 关于特化的补充，如注释所说，在特化中，在意的是 特化<参数个数A> 与 template<参数个数B> 泛化， A 与 B 的统一。
- 增加模板构造函数，参数为万能引
用 - 重载 opertor()
- 增加可调用对象处理器
- .需要传给handler U(可调用类型) 增加子类模板
- 在构造函数中，增加相关代码
解释：为何子类CFObjHandlerChild 的构造函数 参数为 U && 右值。
- 首先避免拷贝，用U 也是完全可以的。
- 如果传入的是 lambda表达式，修改成左值是不行的。
分析调用流程：
CallFuncObj<void(int)> f1 = myfunc
- 执行构造函数模板
template <typename U>
CallFuncObj(U && acobj) {
handler = new CFObjHandlerChild<U, T, Args...>(std::forward<U>(acobj))
}
这里U 的类型是void(&)(int) 是左值引用类型。foward后 依旧是 左值类型。
- 进入 child 的构造函数
CFObjHandlerChild(U && tmpfuncobj): functor(std::foward<U>(tmpfuncobj)) {
}
此时 用用到引用折叠规则，U &，如果任意一个引用为左值引用，那么结果就为左值引用。
传进来的是 void(&)(int) 此时 U& 依旧为 void(&)(int)
左值-》 左值 没问题。
依旧是折叠规则，如果参数为 U && ， 左值void(&)(int) 进来，这两个其中有一个 是 左值引用，则 U && 输出结果 依旧为 void(&)(int)左值引用。
所以 这里如果是&& 左值引用和右值引用都没问题。
只是左值引用 lambda 表达式 就不能编译通过了。
