Boost源码剖析：泛型函数指针类boost::function(修订版)
刘未鹏 /文
C++的罗浮宫 (http://blog.csdn.net/pongba)
声明:2003年9月发表于《程序员》,本文较之有极大改动，特别在中后部分:-)
前奏
如你所知，Boost库是个特性完备，且具备工业强度的库，众多C++权威的参与使其达到了登峰造极的程度。尤其泛型的强大威力在其中被发挥得淋漓尽致，令人瞠目结舌。
然而弱水三千，我们只取一瓢饮。下面，我试图从最单纯的世界开始，一步一步带领你进入源码的世界，去探究boost::function(下文简称function)内部的精微结构。
通常 ，在单纯的情况下，对函数的调用简单而且直观，像这样：
int fun(int someVal);
int main(){
fun(10);
}
然而你可能需要在某个时刻将函数指针保存下来，并在以后的另一个时刻调用它，像这样：
int fun(int);
typedef int (*func_handle)(int);
int main(){
func_handle fh=fun;
... //do something
fh(10);
}
但是，如果fun形式为void fun(int)呢？如你所见，fun可能有无数种形式，如果对fun的每一个形式都typedef一个对应的func_handle，则程序员会焦头烂额，不胜其扰，代码也可能变得臃肿和丑陋不堪，甚至如果fun是仿函数呢？
幸运的是C++泛型可以使代码变得优雅精致，面对无数种的可能，泛型是最好的选择。
因此，你只是需要一个能够保存函数指针的泛型模板类(对应于Command模式)，因为泛型编程有一个先天性的优势——可以借助编译器的力量在编译期根据用户提供的型别信息化身千万(具现化)，所以一个泛型的类可以有无限个具现体，也就是说可以保存无限多种可能型别的函数或类似函数的东西(如，仿函数)。这个类(在Boost库中的类名为function)与函数指针相比应该有以下一些优势：
¨ 同一个function对象应能够接受与它形式兼容的所有函数和仿函数,例如：
int f1(int); //这是个函数，形式为 int(int)
short f2(double); //这个函数形式为 short(double)
struct functor //这是个仿函数类，形式为int(int)
{
int operator()(int){}
};
functor f3; //创建仿函数对象
boost::function<int(int)> func; // int(int)型的函数或仿函数
func = f1; //接受f1
func(10); //调用f1(10)
func = f2; //也能接受short(double)型的f2
func(10); //调用f2(10)
func = f3; //也能接受仿函数f3
func(10); //调用f3(10)
¨ function应能够和参数绑定以及其它function-construction库协同工作。例如，function应该也能够接受std::bind1st返回的仿函数。这一点其实由第一点已经有所保证。
¨ 当接受的一个空的仿函数对象被调用的时候function应该有可预期的行为。
显然，第一点是我们的重点，所谓形式兼容，就是说，对于：
R1 (T0,T1,T2,...,TN) => FunctionType1
R2 (P0,P1,P2,...,PN) => FunctionType2
两种类型的函数（广义），只要满足：
1. R2能够隐式转换为R1
2. 所有Ti都能够隐式转换为Pi (i取0,1,2,...)
那么就说，boost::function<FunctionType1>可以接受FunctionType2类型的函数(注意，反之不行)。支持这一论断的理由是，只要Ti能够隐式转型为Pi，那么参数被转发给真实的函数调用就是安全的，并且如果R2能够隐式转型为R1，那么返回真实函数调用所返回的值就是安全的。这里安全的含义是，C++类型系统认为隐式转换不会丢失信息，或者会给出编译警告，但能够通过编译。
后面你会看到，boost::function通过所谓的invoker非常巧妙地实现了这点，并且阻止了被形式不兼容的函数赋值的操作。
探险
好吧，准备好，我们要出发了，进行深入源码世界的探险。
先看一个function的最简单的使用：
int g(int); //为了让代码简单，假设g有定义，以后的代码都会如此
function<int(int)> f(g);
f(0);
间奏——R(T1,T2,...)函数类型
虽然这个间奏未免早了点儿，但是为了让你以后不会带着迷惑，这显然是必要的。请保持耐心。
或许你会对模板参数int(int)感到陌生，其实它是个函数型别——函数g的确切型别就是int(int)，而我们通常所看到的函数指针型别int (*)(int)则是&g的型别。它们的区别与联系在于：当把g作为一个值进行拷贝的时候（例如，按值传参），其类型就会由int(int)退化为int(*)(int)，即从函数类型退化为函数指针类型——因为从语义上说，函数不能被“按值拷贝”，但身为函数指针的地址值则是可以被拷贝的。另一方面，如果g被绑定到引用，则其类型不会退化，仍保持函数类型。例如：
template<class T>
void test_func_type(T ft) //按值传递，类型退化
{
static_cast<int>(ft); //引发编译错误，从而看出ft的类型为退化后的函数指针
}
int g(int); //函数g，名字g的类型为int(int)
test_func_type(g); //注意，并非&g，参数g的类型将会退化为函数指针类型
int (&ref_f)(int) = g; //注意，并非“= &g”，因为绑定到引用，类型并不退化
当然，这样的代码不能通过编译，因为static_cast<>显然不会让一个函数指针转换为int，然而我们就是要它通不过编译，这样我们才能窥视到按值传递的参数ft的类型到底是什么，从编译错误中我们看出，ft的类型是int(*)(int)，也就是说，在按值传递的过程中，g的类型退化为函数指针类型，变得和&g的类型一样了。而ref_t的类型则是引用，引用绑定则没有引起类型退化。
请注意，函数类型乃是个极其特殊的类型，在大多数时候它都会退化为函数指针类型，以便满足拷贝语义，只有面对引用绑定的时候，能够维持原来的类型。当然，对于boost::function，总是按值拷贝。
继续旅程
好吧，回过神来，我们还有更多地带要去探究。
function<int(int)>实际上进行了模板偏特化，Boost库给function的类声明为：
template<typename Signature, //函数类型
typename Allocator = ...
> //Allocator并非重点，故不作介绍
class function;
事实上function类只是个薄薄的外覆（wrapper），真正起作用的是偏特化版本。
对于function<R(T0)>形式，偏特化版本的function源码像这样(实际上在boost源代码中你看不到模板参数T0的声明，也看不到function1，它们被宏替换掉了，那些精巧的宏是为了减小可见的代码量，至于它们的细节则又是一个世界，以下代码可看作对将那些令人眼花缭乱的宏展开后所得到的代码，具有更好的可读性)：
摘自：”boost/function/function_template.hpp”
template<typename R,typename T0,typename Allocator>
class function<R(T0),Allocator> //对R(T0)函数类型的偏特化版本
:public function1<R,T0,Allocator> //为R(T0)形式的函数准备的基类，在下面讨论
{
typedef function1<R,T0,Allocator> base_type;
typedef function selftype;
struct clear_type{}; //马上你会看到这个蹊跷的类型定义的作用
public:
function() : base_type() {} //默认构造
template<typename Functor> //模板化的构造函数，为了能够接受形式兼容的仿函数对象
function(Functor f, typename enable_if<
(ice_not<(is_same<Functor, int>::value)>::value),
int
>::type = 0) ：base_type(f){}
function(clear_type*) : base_type() {} //这个构造函数的作用在下面解释
self_type& operator=(const self_type& f) //同类型function对象之间应该能够赋值
{
self_type(f).swap(*this); //swap技巧，细节见《Effective STL》
return *this;
}
...
};
enable_if
你一定对模板构造函数中出现的那个冗长的enable_if<...>的作用心存疑惑，其实它的作用说穿了很简单，就是：当用户构造：
function<int(int)> f(0);
的时候，将该（带有enable_if的）构造函数从重载决议的候选集中踢掉。使重载决议的结果为选中第三个构造函数：
function(clear_type*):base_type(){}
从而进行缺省构造。
而说得冗长一点就是：当f的类型——Functor——不是int时，该构造函数就是“有效（enable）”的，会被重载决议选中。但如果用户提供了一个0，用意是构造一个空(null)的函数指针，那么该函数就会由于“SFINAE”原则而被从重载决议的候选函数中踢掉。为什么要这样呢？因为该构造函数负责把确切的f保存起来，它假定f并非0。那应该选择谁呢？第三个构造函数！其参数类型是clear_type*，当然，0可以被赋给任何指针，所以它被选出，执行缺省的构造行为。
基类 functionN
function的骨架就这些。也许你会问，function作为一个仿函数类，怎么没有重载operator()——这可是身为仿函数的标志啊！别急，function把这些烦人的任务都丢给了它的基类functionN，根据情况不同，N可能为0，1，2...，说具体一点就是：根据用户使用function时给出的函数类型，function将会继承自不同的基类——如果用户给出的函数类型为“R()”形式的，即仅有一个参数，则function继承自function0，而对于R(T0)形式的函数类型，则继承自function1，依此类推。前面说过，function只是一层外覆，而所有的秘密都在其基类functionN中！
不知道你有没有发现，function的骨架中也几乎没有用到函数类型的信息，事实上，它也将这些信息一股脑儿抛给了基类。在这过程中，混沌一团的int(int)型别被拆解为两个单独的模板参数传给基类:
template<typename R,typename T0,typename Allocator>
class function<R(T0),Allocator> //R(T0)整个为一型别
:public function1<R,T0,Allocator> //拆解为两个模板参数R,T0传给基类
好了，下面我们深入基类function1。真正丰富的宝藏在里面。
function1
function1的源代码像这样(与上面一样，事实上有些代码你是看不到的，为了不让你迷惑，我给出的是将宏展开后得到的代码):
摘自：”boost/function/function_template.hpp”
template<typename R,typename T0,class Allocator = ...>
class function1:public function_base //function_base负责管理内存
{
...
public:
typedef R result_type; //返回类型
typedef function1 self_type;
function1() : function_base(),invoker(0){}//默认构造
template<typename Functor>
function1(Functor const & f, //模板构造函数
typename enable_if<...>::type = 0) :
function_base(),
invoker(0)
{
this->assign_to(f); //这儿真正进行赋值，assign_to的代码在下面列出
}
function1(clear_type*) : function_base(), invoker(0){} //该构造函数上面解释过
function1(const function& f) : //拷贝构造函数
function_base(),
invoker(0){
this->assign_to_own(f); //专用于在function之间赋值的assignment
}
Ø result_type operator()(T0 a0) const //身为仿函数的标志！
{ //下面负责调用指向的函数
if (this->empty())
boost::throw_exception(bad_function_call());
//这里进行真正的函数调用，使用invoker
internal_result_type result = invoker(function_base::functor,a0);
return static_cast<result_type>(result);
}
template<typename Functor>
void assign_to(Functor f) //所有的构造函数都调用它！具有多个重载版本。
{
//以一个get_function_tag萃取出Functor的类别(category)!
typedef typename detail::function::get_function_tag<Functor>::type tag;