前面在做 http server 的时候，需要做一个回调的接口，要求能够绑定类的函数以及普通的函数到这个回调里，对于这种应用要求，选择 boost 的 bind 和 function 是最合适不过了，但现在情况有些不同，我不准备在现在做的这个东西里加入 boost, 本着以造轮子为乐的精神，现在只能捋起袖子自己来搞一个。
大概原型
使用的时候一直没有太留意它们的实现，现在要做起来，发现也不是想像中那么轻而易举。这个东西做到最后要实现的效果就是设计一个泛型的 function holder，这个 holder 既能包装类的函数，又要能包装一般的函数，换言之就是能像下面一样来使用。
#include <iostream>
using namespace std;
class cs
{
public:
int proc(double d) { cout << "mem func proc:" << d << endl; return (int)d;}
};
int Proc(double d)
{
cout << "normal proc:" << d << endl;
return (int)d;
}
int main()
{
function fun = &Proc;
fun(2.3);
cs c;
fun = bind(&cs::proc, &c);
fun(3.3);
return 0;
}
简单实现
一开始你可能会想，a piece of cake! 直接封装一个 function 就行了。
template<class ret_type, class arg_type>
class function1: public copyable
{
public:
typedef ret_type (* NORM_PROC) (arg_type);
function1(NORM_PROC proc = 0): fun_(proc){}
ret_type operator() (arg_type arg) { fun_->operator()(arg); }
private:
NORM_PROC fun_;
};
好，这个类可以封装一般的函数了，那类的函数呢？one more!
template<class CS, class ret_type, class arg_type>
class function2: public copyable
{
public:
typedef ret_type (CS::* MEM_PROC)(arg_type);
function2(CS* obj, MEM_PROC proc): obj_(obj), proc_(proc) {}
ret_type operator() (arg_type arg) { return (obj_->*proc_)(arg); }
private:
CS* obj_;
MEM_PROC proc_;
};
很快我们就发现有问题了，function1 和 function2 是两不同的模板类，bind() 的时候没法处理：bind() 返回的应该要是一个统一的类型。怎么办呢？我们可能想到要抽取出一个基类来，思路是对的！但还有些细节要处理。比如：bind() 返回的是什么类型呢？function1，function2 的基类吗？这好像做不到，不能直接返回 object，所以下面的做法是错的。
template<class ret_type, class arg_type>
class function_base: public copyable
{
public:
virtual ~function_base(){}
virtual ret_type operator() (arg_type arg) = 0;
};
template<class CS, class ret_type, class arg_type>
class function2: public function_base<ret_type, arg_type>
{
public:
typedef ret_type (CS::* MEM_PROC)(arg_type);
function2(CS* obj, MEM_PROC proc): obj_(obj), proc_(proc) {}
ret_type operator() (arg_type arg) { return (obj_->*proc_)(arg); }
private:
CS* obj_;
MEM_PROC proc_;
};
template<class CS, class ret_type, class arg_type>
function_base<ret_type, arg_type> bind(ret_type (CS::* proc)(arg_type), CS* pc)
{
function2<CS, ret_type, arg_type> func_holder(pc, proc);
return func_holder; // object slicing
}
那直接返回指针不就完了！返回指针可行，但不好用，而且容易内存泄漏。解决的办法是对返回的指针再包一层，嗯，RAII。但等等，好像如果再包一层，就已经能直接隔开底下的 function holder 与具体的调用了啊！Perfect!
template<class ret_type, class arg_type>
class function_base: public copyable
{
public:
virtual ~function_base() {}
virtual ret_type operator() (arg_type arg) = 0;
};
template<class ret_type, class arg_type>
class function1: public function_base<ret_type, arg_type>
{
public:
typedef ret_type (* NORM_PROC) (arg_type);
function1(NORM_PROC proc = 0): fun_(proc){}
ret_type operator() (arg_type arg) { fun_->operator()(arg); }
private:
NORM_PROC fun_;
};
template<class CS, class ret_type, class arg_type>
class function2: public function_base<ret_type, arg_type>
{
public:
typedef ret_type (CS::* MEM_PROC)(arg_type);
function2(CS* obj, MEM_PROC proc): obj_(obj), proc_(proc) {}
ret_type operator() (arg_type arg) { return (obj_->*proc_)(arg); }
private:
CS* obj_;
MEM_PROC proc_;
};
template<class ret_type, class arg_type>
class functioin: public copyable
{
public:
function(function_base<ret_type, arg_type>* pf): _obj(pf) {}
ret_type operator()(arg_type arg){obj_->operator()(arg);}
private:
function_base<ret_type, arg_type>* obj_;
};
template<class CS, class ret_type, class arg_type>
function<ret_type, arg_type> bind(ret_type (CS::* proc)(arg_type), CS* pc)
{
return new function2<CS, ret_type, arg_type>(pc, proc);
}
经过这样一包装，function 类好像已经能够用来 bind 类的成员函数了, 也没那么难嘛！但是，代码很差劲：
1) 没有处理内存释放。
2) 没有处理 copy costructor，assignment operator()。
3) 普通函数还是不能直接赋值给 function 类。
再改一下 function 类：
template<class ret_type, class arg_type>
class function
{
public:
typedef ret_type (* NORM_PROC) (arg_type);
function(function_base<ret_type, arg_type>* fun): fun_(fun), ref_(new int(1)) {}
function(NORM_PROC proc = 0): fun_(new function1<ret_type, arg_type>(proc)), ref_(new int(1)) {}
ret_type operator() (arg_type arg) { fun_->operator()(arg); }
~function()
{
Release();
}
void Release()
{
*ref_ -= 1;
if (*ref_ == 0)
{
delete ref_;
delete fun_;
}
}
function(const function& fun)
{
fun_ = fun.fun_;
ref_ = fun.ref_;
*ref_ += 1;
}
void operator=(const function& fun)
{
Release();
fun_ = fun.fun_;
ref_ = fun.ref_;
*ref_ += 1;
}
private:
int* ref_;
function_base<ret_type, arg_type>* fun_;
};
这样一来，终于能够正常使用了，可以看到，为了使得 function 类能被 copy/assign，这里面使用引用计数来控制内存的释放问题，上面的实现比较简单，也不是线程安全的，只是满足了基本的使用需求，具体的代码参看这里。代码写得较快，暂且就这样了，不知道 boost 是怎样实现的？得找个时间研究研究。