目錄：

C++ 下 Function 對象的實現（上）
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 &fun)
        : m_pFunBase(new Function_##n<R, TYPENAME_LIST(n), typename FunctionTraits<T>::ParamType>(fun))
    {
       
    }

    template <typename P, typename T>
    Function(P pObj, R (T::*pMemFun)(TYPENAME_LIST(n)))
        : m_pFunBase(new MemberFunction_##n<R, P, T, TYPENAME_LIST(n)>(pObj, pMemFun))
    {

    }

    ~Function()
    {
        delete m_pFunBase;
    }

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

private:
    FunctionBase_##n<R, TYPENAME_LIST(n)> *m_pFunBase;
};

當然上面這樣子的代碼是沒法跑的咯。如果我們將整段代碼定義為一個宏 BODY(n)，然后用類似剛才四個宏的方式定義宏 FUNCTION_IMPLEMENT(n)，使得它的含義為 BODY(0), BODY(1), …, BODY(n)，所有工作就都完成了。最后只需要丟下一句 FUNCTION_IMPLEMENT(20)，就可以支持 0 到 21 個參數了。

最后歸結為，如何使用宏搞出“T0, T1, …, Tn” 的形式。

暴力點，我們可以這樣：

#define T_0 T0
#define T_1 T_0, T1
#define T_2 T_1, T2
#define T_3 T_2, T3
#define T_4 T_3, T4
#define T_5 T_4, T5
#define T_6 T_5, T6
#define T_7 T_6, T7
#define T_8 T_7, T8
#define T_9 T_8, T9

#define T(n) T_##n

這樣子，對于上面四個宏可以，但是對于最后的 X(n)，人工代碼量還是太大了。嗯？X(n)？對，這個 X，必須在 _1、_2、_3 系列宏里面占據一個參數地位，這樣才有那么一點點擴展性。考慮換成這樣：

#define REP_0(macro, n) macro(0)
#define REP_1(macro, n) REP_0(macro, n), macro(1)
#define REP_2(macro, n) REP_1(macro, n), macro(2)
#define REP_3(macro, n) REP_2(macro, n), macro(3)
#define REP_4(macro, n) REP_3(macro, n), macro(4)
#define REP_5(macro, n) REP_4(macro, n), macro(5)
#define REP_6(macro, n) REP_5(macro, n), macro(6)
#define REP_7(macro, n) REP_6(macro, n), macro(7)
#define REP_8(macro, n) REP_7(macro, n), macro(8)
#define REP_9(macro, n) REP_8(macro, n), macro(9)

#define REP(macro, n)   REP_##n(macro, n)

然后：

#define TYPENAME_LIST_PATTERN(n)    T##n
#define TYPENAME_LIST(n)            REP(TYPENAME_LIST_PATTERN, n)

這個 TYPENAME_LIST 就是符合上文要求的宏。接下來如法炮制其余三個：

#define TYPENAME_DECLARE_PATTERN(n)     typename T##n
#define TYPENAME_DECLARE(n)             REP(TYPENAME_DECLARE_PATTERN, n)

#define TYPENAME_VARIABLE_PATTERN(n)    T##n v##n
#define TYPENAME_VARIABLE(n)            REP(TYPENAME_VARIABLE_PATTERN, n)

#define VARIABLE_LIST_PATTERN(n)        v##n
#define VARIABLE_LIST(n)                REP(VARIABLE_LIST_PATTERN, n)

最后，我們在 #define FUNCTION_IMPLEMENT(n)  REP(BODY, n) 中還存在一點點問題。因為 BODY 中會含有 TYPENAME_DECLARE 之類的宏的使用，而 TYPENAME_DECLARE 正是使用 REP 定義的。這涉及到宏的遞歸展開，C++預處理器的規則是，遇到這樣的情況就停止展開。比如，我們 定義 BODY(n) 為 TYPENAME_DECLARE(n)，于是 FUNCTION_IMPLEMENT(2) 會被展成：

REP(TYPENAME_DECLARE_PATTERN, 0), REP(TYPENAME_DECLARE_PATTERN, 1), REP(TYPENAME_DECLARE_PATTERN, 2)

上面的 REP 不會被繼續展開了。

為此，一個不太聰明的辦法就是，再定義一組 REP2。嗯，是個辦法，就這么辦吧。另外我們剛才的 REP 系列沒有將分隔符作為參數，默認使用逗號，而最后一不的 FUNCTION_IMPLEMENT 的重復中是不能用逗號的。考慮提取出來作為參數。最后我們的所需要的宏系統是：

#define NIL
#define COMMA ,

#define REP_0(macro, splitter, n) macro(0)
#define REP_1(macro, splitter, n) REP_0(macro, splitter, n) splitter macro(1)
#define REP_2(macro, splitter, n) REP_1(macro, splitter, n) splitter macro(2)
#define REP_3(macro, splitter, n) REP_2(macro, splitter, n) splitter macro(3)
#define REP_4(macro, splitter, n) REP_3(macro, splitter, n) splitter macro(4)
#define REP_5(macro, splitter, n) REP_4(macro, splitter, n) splitter macro(5)
#define REP_6(macro, splitter, n) REP_5(macro, splitter, n) splitter macro(6)
#define REP_7(macro, splitter, n) REP_6(macro, splitter, n) splitter macro(7)
#define REP_8(macro, splitter, n) REP_7(macro, splitter, n) splitter macro(8)
#define REP_9(macro, splitter, n) REP_8(macro, splitter, n) splitter macro(9)

#define REP(macro, splitter, n)   REP_##n(macro, splitter, n)

#define REP2_0(macro, splitter, n) macro(0)
#define REP2_1(macro, splitter, n) REP2_0(macro, splitter, n) splitter macro(1)
#define REP2_2(macro, splitter, n) REP2_1(macro, splitter, n) splitter macro(2)
#define REP2_3(macro, splitter, n) REP2_2(macro, splitter, n) splitter macro(3)
#define REP2_4(macro, splitter, n) REP2_3(macro, splitter, n) splitter macro(4)
#define REP2_5(macro, splitter, n) REP2_4(macro, splitter, n) splitter macro(5)
#define REP2_6(macro, splitter, n) REP2_5(macro, splitter, n) splitter macro(6)
#define REP2_7(macro, splitter, n) REP2_6(macro, splitter, n) splitter macro(7)
#define REP2_8(macro, splitter, n) REP2_7(macro, splitter, n) splitter macro(8)
#define REP2_9(macro, splitter, n) REP2_8(macro, splitter, n) splitter macro(9)

#define REP2(macro, splitter, n)   REP2_##n(macro, splitter, n)

#define TYPENAME_DECLARE_PATTERN(n)     typename T##n
#define TYPENAME_DECLARE(n)             REP(TYPENAME_DECLARE_PATTERN, COMMA, n)

#define TYPENAME_LIST_PATTERN(n)        T##n
#define TYPENAME_LIST(n)                REP(TYPENAME_LIST_PATTERN, COMMA, n)

#define TYPENAME_VARIABLE_PATTERN(n)    T##n v##n
#define TYPENAME_VARIABLE(n)            REP(TYPENAME_VARIABLE_PATTERN, COMMA, n)

#define VARIABLE_LIST_PATTERN(n)        v##n
#define VARIABLE_LIST(n)                REP(VARIABLE_LIST_PATTERN, COMMA, n)

#define FUNCTION_IMPLEMENT(n)  REP2(BODY, NIL, n)

最后，定義一下 FUNCTION_IMPLEMENT(5)，就可以支持到 6 個參數了。為了支持更多參數，把上面的 REP 以及 REP2 系列多定義一點，比如到 50，那么 FUNCTION_IMPLEMENT 的括號中就可以填 50 以內的任意數了。考慮到宏展開對編譯速度的影響，以及實際應用中函數參數的個數，定為 20 左右比較合適。

到這里，我們的Function已經實現了預期目標。接下來我本來想說說 TypeList 的。可是現在發現沒有 TypeList，Function 跑的通；有了 TypeList，Function 也不能寫的漂亮多少，雖說那些重復部分有一定的減少。Loki 的 Functor 的參數類型是一個返回值類型加上一個 TypeList，是由用戶直接傳入 TypeList 的，不用由散的類型組合出一個TypeList（但還是要從TypeList中萃取各個參數類型），因此用在他那里看上去美妙一點點。當然，Loki 也在 Functor 外頭包了一層 Function，以支持函數簽名作為模版參數的使用方式。有一點不算改觀的改觀是，用了 TypeList 以后，就不會再有 FunctionBase_1, FunctionBase_2 這樣的玩意兒了，取而代之的是一個統一的 FunctionBase 外加許多偏特化版本，Function* 和 MemberFunction* 可以分別統一為一個，但是每一個里頭都需要實現 N 個 Invoke。加上篇幅關系，我想這里就不說這個 TypeList 了。

代碼清單太長了，就不貼了，有意者自然能湊起來。我目前在 xlLib 中的最終實現見 xlFunction.h。

關于宏，我不知道可以怎樣改進。BOOST_PP_REPEAT 貌似可以調用自身？不知道如何實現的，求指教。另外@vczh貌似說“實現了一門可以自己遞歸自己和內置列表處理的另一個宏”，求分享呀求分享。

2010-01-18 補充：將最外層 Function 的構造函數中的 const T & 直接改為 T，并且拋棄 FunctionTraits，函數實體類型將在傳遞過程中直接退化為函數指針，這樣就能特化出正確的 FunctionHandler。同時帶來另一點影響：如果傳入 Functor，字面上將多一次拷貝動作。拋開這一點微小的性能來講，這比剛才的 FunctionTraints 要好得多了。