作者:刘未鹏 来源:C++的罗浮宫   酷勤网收集 2007-10-20

摘要
  本文试图从最单纯的世界开始,一步一步带领你进入源码的世界,去探究boost::function(下文简称function)内部的精微结构。

前奏

如你所知,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)与函数指针相比应该有以下一些优势:

 

1. 同一个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)

 

2. function应能够和参数绑定以及其它function-construction库协同工作。例如,function应该也能够接受std::bind1st返回的仿函数。这一点其实由第一点已经有所保证。

 

3. 当接受的一个空的仿函数对象被调用的时候function应该有可预期的行为。

 

显然,第一点是我们的重点,所谓形式兼容,就是说,对于:

 

R1 (T0,T1,T2,...,TN) => FunctionType1

R2 (P0,P1,P2,...,PN) => FunctionType2

 

两种类型的函数(广义),只要满足:

 

R2能够隐式转换为R1

所有Ti都能够隐式转换为Pi (i0,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) // 按值传递,类型退化

{

// 故意引发编译错误,在错误信息里看出ft的类型为退化后的函数指针类型

static_cast<int>(ft);

}

 

int g(int); // g确切类型为int(int)

 

test_func_type(g);  // g的类型将会退化为函数指针类型

 

int (&ref_f)(int) = 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:

// 模板化的构造函数,为了能够接受形式兼容的仿函数对象。

// 这个构造函数的作用在下面解释

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() {}

   

...

};

 

boost::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可能为012...,说具体一点就是:根据用户使用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;   //返回类型