C++ 下 Function 对象的实现（上） - c++编程基础

本文的目标是，让以下代码能顺利跑起来：

int intfun0()
{
return 1;
}

struct _intfunctor0
{
int operator()()
{
return 2;
}

} intfunctor0;

struct Test
{
int intmem0()
{
return 3;
}

} test;

int main()
{
Function f1(&intfun0);
Function f1_(intfun0);
Function f2(intfunctor0);
Function f3(&test, &Test::intmem0);

f1();
f1_();
f2();
f3();

return 0;
}

除了上述例子中显示的，还要支持有返回值的函数和没返回值的函数，以及有0个、1个、2个、……、MAX 个参数的函数，参数类型无限制。最后实现的 Function 对象仅仅可以执行就好。（至于是否可拷贝、是否可判断相等等问题，都是小事，本文暂不考虑。）最后，Bind 概念也不在本文讨论范围之内。

对于这个问题，我们一开始考虑的可能是怎样统一三种不同形式。有两个选择，第一，使用 C++ 的多态机制，最后统一到基类指针的类型；第二，允许类内部有冗余变量以及必要的 Flag，用于判断是哪种形式的函数，要如何执行。这样看起来，第一种方案比第二种爽一点。于是，最初想到的实现有可能是这样的：

先定义一个虚基类：

template
class FunctionBase0
{
public:
virtual R Invoke() = 0;
virtual ~FunctionBase0() {}
};

然后实现一个普通函数/仿函数的版本：

template
class Function0 : public FunctionBase0
{
public:
R Invoke()
{
return m_Fun();
}

public:
Function0(const T &fun)
: m_Fun(fun)
{

}

private:
T m_Fun;
};

这里需要说明的是，如果是普通函数，T会被特化成 R() 或者 R (&)() 或者 R(*)()，取决于使用的时候传入 fun 还是传入 &fun。所以不必另外实现针对 R(*)() 的版本。Loki （姑且就以作品名称乎 Loki 的作者吧，他那个真名实在是太长）在他的书中称之为“做一个，送一个”。不过对于他书中所说的，我有一个疑惑。Loki 说传入 fun，模版参数 T 会被特化成 R (&)()，于是一切顺利。可是我在操作过程中发现 T 一直被特化成 R ()，于是上述 class 中的 m_Fun 被认为是成员函数而不是成员变量。不知道是为什么，有知道者请不吝指教哈。因为以上原因，本文中我一直用 &fun 的形式对待普通函数。

再实现一个成员函数的版本：

template
class MemberFunction0 : public FunctionBase0
{
public:
R Invoke()
{
return (m_pObj->*m_pMemFun)();
}

public:
MemberFunction0(T *pObj, R (T::*pMemFun)())
: m_pObj(pObj), m_pMemFun(pMemFun)
{

}

private:
R (T::*m_pMemFun)();
T *m_pObj;
};

最后是一个包装类。如果你可以接受 Function 表示 int()， Function 表示 int (int)，…，那么这里没有多少技巧可言。boost 的那个 function 使用的是函数签名作为模版参数，即 Function，Function 等形式。如果不太研究语法，可能会像我一样，一开始会对尖括号里的 int (int) 之类的玩意儿不太熟悉，觉得很牛逼。可是了解了以后，不过是个函数类型而已，没什么大不了的。Loki 的 Functor 的使用方式是 Functor，Functor。其中第一个模版参数始终是返回值，第二个模版参数是参数类型列表，Loki 使用了他创造的玩意儿 TypeList 使得所有函数参数只占一个坑，这在等下的支持多参数的扩展中能够带来一些美观。我比较喜欢 boost 的使用方式，让使用者直接以语言规定的形式填入函数签名，而不是一些额外的约定（“第一个模版参数表示返回值”，“第二个到最后的模版参数表示参数”，“第二个模版参数以 TypeList 形式表示函数参数”等）。

为了达到这个目标，我们要玩一些偏特化技巧。关于偏特化，我一直以来的肤浅认识都是错误的。我原以为，对于模版类：

template
class Foo;

我如果特化其中一个参数 T1：

template
class Foo
{

}

我以为只有这样才叫偏特化，以为偏特化的过程总是减少模版参数的。而实际上，只要用某个/些类型占据原始模版参数的位置，就可以了。比如，对于上述 Foo，我可以特化一个 class>，消去一个 T1，而新增 U0、U1：

template
class Foo>
{

}

原来 T1 的位置被 std::map 占据了，这也是偏特化。当然最后的模版参数数量也可以不变，如：

template
class Foo>
{

}

以及

template
class Foo
{

}

其中后者是实现类型萃取的主要方式。只要特化以后，这个类依然带有至少一个模版参数，就是偏特化。如果最后产生了 template<> 的形式，那就是完全特化。

回到我们刚才的主题，我们要提供给用户的是这样一个类：

template
class Function;

其中参数 Signature 会被实际的函数类型所特化。但是我们只知道整体的一个 Signature 并没有用，我们必须知道被分解开来的返回值类型、参数类型。于是，引入一个偏特化版本：

template
class Function

这里使用 R () 特化原始的 Signature，引入一个新的参数 R。于是返回值类型 R 就被萃取出来了。实现如下：

template
class Function
{
public:
template
Function(const T &fun)
: m_pFunBase(new Function0(fun))
{

}

template
Function(T *pObj, R (T::*pMemFun)())
: m_pFunBase(new MemberFunction0(pObj, pMemFun))
{

}

~Function()
{
delete m_pFunBase;
}

R operator ()()
{
return m_pFunBase->Invoke();
}

private:
FunctionBase0 *m_pFunBase;
};

如果对上面说的“普通函数的使用方式必须是函数指针而不是函数本身”耿耿于怀，可以再引入一个的构造函数：

typedef R (F