前言
boost::function和boost:bind是一對強大的利器。相信用過的童鞋多少有些體會。
雖然平時在用boost::function，但是用的時候心中總會一些不安，因為不知道它是怎么實現的。於是，就自己琢磨着簡單的實現一下，搞明白基本的原理。
對於這個簡單實現，有以下幾個目標：
- 選取比較常見的接收2個參數的情況。
- 支持普通函數/函數指針、成員函數指針。
- 兼容函數對象、函數適配器/boost::bind。
實現
首先，定義一個基類：
template<typename R, typename T1, typename T2>
class base
{
public:
virtual ~base()
{
}
virtual R operator()(T1, T2) = 0;
};
然后再實現一個普通函數/函數指針的版本：
template<typename R, typename T1, typename T2>
class func : public base<R, T1, T2>
{
public:
func(R (*ptr)(T1, T2))
: ptr_(ptr)
{
}
virtual R operator()(T1 a, T2 b)
{
return ptr_(a, b);
}
private:
R (*ptr_)(T1, T2);
};
接着，實現支持成員函數指針的版本：
template<typename R, typename Class, typename T>
class member : public base<R, Class, T>
{
};
template<typename R, typename Class, typename T>
class member<R, Class*, T> : public base<R, Class*, T>
{
public:
member(R (Class::*ptr)(T))
: ptr_(ptr)
{
}
virtual R operator()(Class* obj, T a)
{
return (obj->*ptr_)(a);
}
private:
R (Class::*ptr_)(T);
};
可能有的童鞋要問，為什么這里要有一個空的member類呢？這個問題放到下面解釋。
自然的輪到最后一個種情況，函數對象/boost::bind類型的了：
template<typename T, typename R, typename T1, typename T2>
class functor : public base<R, T1, T2>
{
public:
functor(const T& obj)
: obj_(obj)
{
}
virtual R operator()(T1 a, T2 b)
{
return obj_(a, b);
}
private:
T obj_;
};
最后，就是可用的function類了，實現如下：
template<typename T>
class function
{
};
template<typename R, typename T1, typename T2>
class function<R (T1, T2)>
{
public:
template<typename Class, typename _R, typename _T2>
function(_R (Class::*ptr)(_T2))
: ptr_(new member<R, T1, T2>(ptr))
{
}
template<typename _R, typename _T1, typename _T2>
function(_R (*ptr)(_T1, _T2))
: ptr_(new func<R, T1, T2>(ptr))
{
}
template<typename T>
function(const T& obj)
: ptr_(new functor<T, R, T1, T2>(obj))
{
}
~function()
{
delete ptr_;
}
virtual R operator()(T1 a, T2 b)
{
return ptr_->operator()(a, b);
}
private:
base<R, T1, T2>* ptr_;
};
大家可能注意到了，和前面的member類一樣，function也有一個空的類，那么這些有什么用呢？
這么做的原因，主要是利用模板偏特化來進行類型萃取，正常的function聲明的時候，比如function<int (int, int)>而不是func<int, int, int>。所以用模板的偏特化的版本
template<typename R, typename T1, typename T2> class function<R (T1, T2)>
就可以把int (int, int)萃取為R = int，T1 = int，T2 = int了。
同理，對於member類，由於一般我們將成員函數指針綁定到function的時候，比如int function(Type*, int)，其中Type是成員函數所屬類。也就是說在function中的成員ptr_的類型是base<int, Type*, int>，那么在function的構造函數中構造的member類的類型就是member<int, Type*, int>，也就是Class = Type*，但是我們需要的卻是Class = Type。所以這里得用偏特化萃取一下：
template<typename R, typename Class, typename T> class member<R, Class*, T> : public base<R, Class*, T>
這樣得到的Class模板形參就會被編譯器決議為Type，而不是Type*了。
另外提一下，在function的3種情況的構造函數是模板成員函數，而不是普通成員函數：
template<typename Class, typename _R, typename _T2>
function(_R (Class::*ptr)(_T2))
: ptr_(new member<R, T1, T2>(ptr))
{
}
template<typename _R, typename _T1, typename _T2>
function(_R (*ptr)(_T1, _T2))
: ptr_(new func<R, T1, T2>(ptr))
{
}
template<typename T>
function(const T& obj)
: ptr_(new functor<T, R, T1, T2>(obj))
{
}
前2種情況，普通函數/函數指針對應的構造函數和成員函數指針對應的構造函數實現為成員模板，主要是為了兼容參數的隱式轉換，例如聲明一個function的類型為function<int (int, int)> foo，調用的時候卻傳入兩個double類型，foo(1.1, 2.2)， double類型隱式轉換成了int類型。這樣也符合boost:function本來的兼容可轉換的調用物這一特性。
而第3種情況的成員模板，是為了獲取傳入的函數對象/boost::bind的類型，以便在存儲在functor的數據成員中，這也是為什么functor類的模板參數比其他版本多了一個的原因。
然后，我們來測試一下：
int get(int a, int b)
{
std::cout << a+b << std::endl;
return 0;
}
class Point
{
public:
int get(int a)
{
std::cout << "Point::get called: a = "<< a << std::endl;
return a;
}
int doit(int a, int b)
{
std::cout << "Point::doit called: a = "<< a+b << std::endl;
return a+b;
}
};
int main(int argc, char const *argv[])
{
function<int (int, int)> foo(get);
foo(10.1, 10.3);
function<int (Point*, int)> bar(&Point::get);
Point point;
bar(&point, 30);
function<int (int, int)> obj(boost::bind(&Point::doit, &point, _1, _2));
obj(90, 100);
}
結果為：
20
Point::get called: a = 30 Point::doit called: a = 190
可以看到，輸出的內容正是所期望的結果。
參考文獻
- boost中文手冊. Improved Function Object Adapters 改良的函數對象適配器
（完）