目錄：

上篇中，我們實現了一個支援 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 要好得多了。