目錄：
C++ 下 Function 對象的實(shí)現(xiàn)（上）
C++ 下 Function 對象的實(shí)現(xiàn)（下）
上篇中，我們實(shí)現(xiàn)了一個(gè)支持 R () 型函數(shù)的 Function。補(bǔ)充說明一下，在我們對成員函數(shù)的支持中，我們是這樣定義的：
template <typename R, typename T>
class MemberFunction0 : public FunctionBase0<R>
{
private:
R (T::*m_pMemFun)();
T *m_pObj;
};
Loki 特意在著作中提醒我們，這里的 T 最好不要是函數(shù)類型，改為函數(shù)指針類型，如此該類的支持范圍將擴(kuò)大。如下：
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 的關(guān)系不那么緊密了，P 不一定非要 T* 不可，也可以是諸如 SmartPtr<T> 之類的玩意兒。原本只支持傳入一個(gè)對象和該對象的成員函數(shù)的，現(xiàn)在變成傳入一個(gè)具有指針概念的東東和一個(gè)成員函數(shù)，只要這個(gè)“指針”使用運(yùn)算符 –> 去調(diào)用那個(gè)成員函數(shù)合乎語法即可。
接下來，我們來擴(kuò)展這個(gè) Function，以支持擁有數(shù)目在給定上限內(nèi)的任意參數(shù)的函數(shù)。
我們先來手工寫一下，看看如何支持帶一個(gè)參數(shù)的函數(shù)。首先定義一個(gè)虛基類：
template <typename R, typename T0>
class FunctionBase1
{
public:
virtual R Invoke(T0) = 0;
virtual ~FunctionBase1() {}
};
實(shí)現(xiàn)兩個(gè)版本，分別支持非成員函數(shù)和成員函數(shù)：
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;
};
增加一個(gè)函數(shù)引用萃取的偏特化版本：
template <typename RetType, typename T0>
struct FunctionTraits<RetType (T0)>
{
typedef RetType (&ParamType)(T0);
};
增加一個(gè) 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;
};
現(xiàn)在，我們可以跑一下測試代碼了：
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);
當(dāng)然，void 函數(shù)也是支持的。
觀察上面的這些代碼，和我們在上一篇中的代碼高度一致，不同的是那些模版參數(shù)、偏特化參數(shù)、函數(shù)調(diào)用參數(shù)等地方。
假如有這么一組宏：
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
那么我們可以使用一個(gè) n 就寫出支持所有具有參數(shù)的函數(shù)的 Function 了。我們拋棄掉上面的 1 系列的所有類，僅保持上篇留下來的代碼，然后利用上面 4 個(gè)宏將所有數(shù)字尾巴去掉，于是代碼變成：
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;
};
當(dāng)然上面這樣子的代碼是沒法跑的咯。如果我們將整段代碼定義為一個(gè)宏 BODY(n)，然后用類似剛才四個(gè)宏的方式定義宏 FUNCTION_IMPLEMENT(n)，使得它的含義為 BODY(0), BODY(1), …, BODY(n)，所有工作就都完成了。最后只需要丟下一句 FUNCTION_IMPLEMENT(20)，就可以支持 0 到 21 個(gè)參數(shù)了。
最后歸結(jié)為，如何使用宏搞出“T0, T1, …, Tn” 的形式。
暴力點(diǎn)，我們可以這樣：
#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
這樣子，對于上面四個(gè)宏可以，但是對于最后的 X(n)，人工代碼量還是太大了。嗯？X(n)？對，這個(gè) X，必須在 _1、_2、_3 系列宏里面占據(jù)一個(gè)參數(shù)地位，這樣才有那么一點(diǎn)點(diǎn)擴(kuò)展性。考慮換成這樣：
#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)
這個(gè) TYPENAME_LIST 就是符合上文要求的宏。接下來如法炮制其余三個(gè)：
#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) 中還存在一點(diǎn)點(diǎn)問題。因?yàn)?BODY 中會含有 TYPENAME_DECLARE 之類的宏的使用，而 TYPENAME_DECLARE 正是使用 REP 定義的。這涉及到宏的遞歸展開，C++預(yù)處理器的規(guī)則是，遇到這樣的情況就停止展開。比如，我們 定義 BODY(n) 為 TYPENAME_DECLARE(n)，于是 FUNCTION_IMPLEMENT(2) 會被展成：
REP(TYPENAME_DECLARE_PATTERN, 0), REP(TYPENAME_DECLARE_PATTERN, 1), REP(TYPENAME_DECLARE_PATTERN, 2)
上面的 REP 不會被繼續(xù)展開了。
為此，一個(gè)不太聰明的辦法就是，再定義一組 REP2。嗯，是個(gè)辦法，就這么辦吧。另外我們剛才的 REP 系列沒有將分隔符作為參數(shù)，默認(rèn)使用逗號，而最后一不的 FUNCTION_IMPLEMENT 的重復(fù)中是不能用逗號的。考慮提取出來作為參數(shù)。最后我們的所需要的宏系統(tǒng)是：
#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 個(gè)參數(shù)了。為了支持更多參數(shù)，把上面的 REP 以及 REP2 系列多定義一點(diǎn)，比如到 50，那么 FUNCTION_IMPLEMENT 的括號中就可以填 50 以內(nèi)的任意數(shù)了。考慮到宏展開對編譯速度的影響，以及實(shí)際應(yīng)用中函數(shù)參數(shù)的個(gè)數(shù)，定為 20 左右比較合適。
到這里，我們的Function已經(jīng)實(shí)現(xiàn)了預(yù)期目標(biāo)。接下來我本來想說說 TypeList 的。可是現(xiàn)在發(fā)現(xiàn)沒有 TypeList，F(xiàn)unction 跑的通；有了 TypeList，F(xiàn)unction 也不能寫的漂亮多少，雖說那些重復(fù)部分有一定的減少。Loki 的 Functor 的參數(shù)類型是一個(gè)返回值類型加上一個(gè) TypeList，是由用戶直接傳入 TypeList 的，不用由散的類型組合出一個(gè)TypeList（但還是要從TypeList中萃取各個(gè)參數(shù)類型），因此用在他那里看上去美妙一點(diǎn)點(diǎn)。當(dāng)然，Loki 也在 Functor 外頭包了一層 Function，以支持函數(shù)簽名作為模版參數(shù)的使用方式。有一點(diǎn)不算改觀的改觀是，用了 TypeList 以后，就不會再有 FunctionBase_1, FunctionBase_2 這樣的玩意兒了，取而代之的是一個(gè)統(tǒng)一的 FunctionBase 外加許多偏特化版本，F(xiàn)unction* 和 MemberFunction* 可以分別統(tǒng)一為一個(gè)，但是每一個(gè)里頭都需要實(shí)現(xiàn) N 個(gè) Invoke。加上篇幅關(guān)系，我想這里就不說這個(gè) TypeList 了。
代碼清單太長了，就不貼了，有意者自然能湊起來。我目前在 xlLib 中的最終實(shí)現(xiàn)見 xlFunction.h。
關(guān)于宏，我不知道可以怎樣改進(jìn)。BOOST_PP_REPEAT 貌似可以調(diào)用自身？不知道如何實(shí)現(xiàn)的，求指教。另外@vczh貌似說“實(shí)現(xiàn)了一門可以自己遞歸自己和內(nèi)置列表處理的另一個(gè)宏”，求分享呀求分享。
2010-01-18 補(bǔ)充：將最外層 Function 的構(gòu)造函數(shù)中的 const T & 直接改為 T，并且拋棄 FunctionTraits，函數(shù)實(shí)體類型將在傳遞過程中直接退化為函數(shù)指針，這樣就能特化出正確的 FunctionHandler。同時(shí)帶來另一點(diǎn)影響：如果傳入 Functor，字面上將多一次拷貝動作。拋開這一點(diǎn)微小的性能來講，這比剛才的 FunctionTraints 要好得多了。
posted on 2011-01-17 21:59
溪流 閱讀(4191)
評論(5) 編輯 收藏 引用 所屬分類:
C++