C++ 下 Function 对象的实现（下）
上篇中，我们实现了一个支持 R () 型函数的 Function。补充说明一下，在我们对成员函数的支持中，我们是这样定义的：
template <typename R, typename T>
class MemberFunction0 : public FunctionBase0<R>
{private:
R (T::*m_pMemFun)();
T *m_pObj;
};Loki 特意在著作中提醒我们，这里的 T 最好不要是函数类型，改为函数指针类型，如此该类的支持范围将扩大。如下：
template <typename R, typename P, typename T>
class MemberFunction0 : public FunctionBase0<R>
{
public:
R Invoke()
{
return (m_pObj->*m_pMemFun)();
}public:
MemberFunction0(P pObj, R (T::*pMemFun)())
: m_pObj(pObj), m_pMemFun(pMemFun)
{}
private:
R (T::*m_pMemFun)();
P m_pObj;
};于是，P 和 T 的关系不那么紧密了，P 不一定非要 T* 不可，也可以是诸如 SmartPtr<T> 之类的玩意儿。原本只支持传入一个对象和该对象的成员函数的，现在变成传入一个具有指针概念的东东和一个成员函数，只要这个“指针”使用运算符 –> 去调用那个成员函数合乎语法即可。
接下来，我们来扩展这个 Function，以支持拥有数目在给定上限内的任意参数的函数。
我们先来手工写一下，看看如何支持带一个参数的函数。首先定义一个虚基类：
template <typename R, typename T0>
class FunctionBase1
{
public:
virtual R Invoke(T0) = 0;
virtual ~FunctionBase1() {}
};实现两个版本，分别支持非成员函数和成员函数：
template <typename R, typename T0, typename T>
class Function1 : public FunctionBase1<R, T0>
{
public:
R Invoke(T0 v0)
{
return m_Fun(v0);
}public:
Function1(const T &fun)
: m_Fun(fun)
{}
private:
T m_Fun;
};template <typename R, typename P, typename T, typename T0>
class MemberFunction1 : public FunctionBase1<R, T0>
{
public:
R Invoke(T0 v0)
{
return (m_pObj->*m_pMemFun)(v0);
}public:
MemberFunction1(P pObj, R (T::*pMemFun)(T0))
: m_pObj(pObj), m_pMemFun(pMemFun)
{}
private:
R (T::*m_pMemFun)(T0);
P m_pObj;
};增加一个函数引用萃取的偏特化版本：
template <typename RetType, typename T0>
struct FunctionTraits<RetType (T0)>
{
typedef RetType (&ParamType)(T0);
};增加一个 Function 类的偏特化版本：
template <typename R, typename T0>
class Function<R (T0)>
{
public:
template <typename T>
Function(const T &fun)
: m_pFunBase(new Function1<R, T0, typename FunctionTraits<T>::ParamType>(fun))
{
}template <typename P, typename T>
Function(P pObj, R (T::*pMemFun)(T0))
: m_pFunBase(new MemberFunction1<R, P, T, T0>(pObj, pMemFun))
{}
~Function()
{
delete m_pFunBase;
}R operator ()(T0 v0)
{
return m_pFunBase->Invoke(v0);
}private:
FunctionBase1<R, T0> *m_pFunBase;
};现在，我们可以跑一下测试代码了：
Function<int (int)> f1(&intfun1);
Function<int (int)> f1_(intfun1);
Function<int (int)> f2(intfunctor1);
Function<int (int)> f3(&test, &Test::intmem1);f1(1);
f1_(1);
f2(2);
f3(3);当然，void 函数也是支持的。
观察上面的这些代码，和我们在上一篇中的代码高度一致，不同的是那些模版参数、偏特化参数、函数调用参数等地方。
假如有这么一组宏：
TYPENAME_DECLARE(n) 被定义为 typename T0, typename T1, …, typename Tn
TYPENAME_LIST(n) 被定义为 T0, T1, …, Tn
TYPENAME_VARIABLE(n) 被定义为 T0 v0, T1 v1, …, Tn vn
VARIABLE_LIST(n) 被定义为 v0, v1, …, vn那么我们可以使用一个 n 就写出支持所有具有参数的函数的 Function 了。我们抛弃掉上面的 1 系列的所有类，仅保持上篇留下来的代码，然后利用上面 4 个宏将所有数字尾巴去掉，于是代码变成：
template <typename R, TYPENAME_DECLARE(n)>
class FunctionBase_##n
{
public:
virtual R Invoke(TYPENAME_LIST(n)) = 0;
virtual ~FunctionBase_##n() {}
};
template <typename R, TYPENAME_DECLARE(n), typename T>
class Function_##n : public FunctionBase_##n<R, TYPENAME_LIST(n)>
{
public:
R Invoke(TYPENAME_VARIABLE(n))
{
return m_Fun(VARIABLE_LIST(n));
}public:
Function_##n(const T &fun)
: m_Fun(fun)
{}
private:
T m_Fun;
};template <typename R, typename P, typename T, TYPENAME_DECLARE(n)>
class MemberFunction_##n : public FunctionBase_##n<R, TYPENAME_LIST(n)>
{
public:
R Invoke(TYPENAME_VARIABLE(n))
{
return (m_pObj->*m_pMemFun)(VARIABLE_LIST(n));
}public:
MemberFunction_##n(P pObj, R (T::*pMemFun)(TYPENAME_LIST(n)))
: m_pObj(pObj), m_pMemFun(pMemFun)
{}
private:
R (T::*m_pMemFun)(TYPENAME_LIST(n));
P m_pObj;
};template <typename RetType, TYPENAME_DECLARE(n)>
struct FunctionTraits<RetType (TYPENAME_LIST(n))>
{
typedef RetType (&ParamType)(TYPENAME_LIST(n));
};template <typename R, TYPENAME_DECLARE(n)>
class Function<R (TYPENAME_LIST(n))>
{
public:
template <typename T>
Function(const T &f
补充：软件开发 , C++ ,
