標題中說的 Tuple 是指類似 boost::tuple 這樣的設施。

很多時候我們需要返回/傳入一堆參數(shù)，所以不得不每次定義一些為了數(shù)據(jù)傳輸?shù)慕Y構。Tuple 就是用來解決這一問題的，它提供即時構造一個這樣的結構體的功能。而所付出的代價是，喪失各個成員的明確含義，只留下成員的序號。

兩個元素的 Tuple 就是 Pair，如 std::pair。下面我們來建立針對有限個元素的 Tuple。對于一個元素、兩個元素、三個元素，我們可以分別如下實現(xiàn)：

template <typename T0>
struct Tuple
{
    T0 _0;
};

template <typename T0, typename T1>
struct Tuple
{
    T0 _1;
    T1 _1;
};

template <typename T0, typename T1, typename T2>
struct Tuple
{
    T0 _1;
    T1 _1;
    T2 _2;
};

但是這三個寫在一起，就會出錯。為此，我們可以先定義一個含足夠多模版參數(shù)的 Tuple，然后上面三個分別作為偏特化版本：

template <typename T0 = NullType, typename T1= NullType, typename T2= NullType, typename T3= NullType, typename T4= NullType>
struct Tuple;

template <typename T0>
struct Tuple<T0>
{
    T0 _0;
};

template <typename T0, typename T1>
struct Tuple<T0, T1>
{
    T0 _1;
    T1 _1;
};

template <typename T0, typename T1, typename T2>
struct Tuple<T0, T1, T2>
{
    T0 _1;
    T1 _1;
    T2 _2;
};

如果手寫的話，這也可以。如果不手寫，我們可以繼續(xù)用之前《C++ 下 Function 對象的實現(xiàn)（下）》中的宏循環(huán)方案。此方案的一個正式版本見 xlMacros.h。

定義帶默認值 NullType 的模版參數(shù)聲明序列如下：

#define XL_TUPLE_TYPENAME_DECLARE_NT_PATTERN(n)     typename T##n = NullType
#define XL_TUPLE_TYPENAME_DECLARE_NT(n)             XL_REPZ(XL_TUPLE_TYPENAME_DECLARE_NT_PATTERN, n, XL_COMMA)

它將被展開為： typename T0 = NullType, typename T1 = NullType, typename T2 = NullType, …, typename Tn = NullType

定義不帶默認值的模版參數(shù)聲明序列如下：

#define XL_TUPLE_TYPENAME_DECLARE_PATTERN(n)        typename T##n
#define XL_TUPLE_TYPENAME_DECLARE(n)                XL_REPZ(XL_TUPLE_TYPENAME_DECLARE_PATTERN, n, XL_COMMA)

它將被展開為：typename T0, typename T1, typename T2, …, typename Tn

定義模版參數(shù)使用序列如下：

#define XL_TUPLE_TYPENAME_LIST_PATTERN(n)           T##n
#define XL_TUPLE_TYPENAME_LIST(n)                   XL_REPZ(XL_TUPLE_TYPENAME_LIST_PATTERN, n, XL_COMMA)

它將被展開為 T0, T1, T2, …, Tn

定義成員變量聲明序列如下：

#define XL_TUPLE_MEMBER_DECLARE_PATTERN(n)          T##n _##n;
#define XL_TUPLE_MEMBER_DECLARE(n)                  XL_REPZ(XL_TUPLE_MEMBER_DECLARE_PATTERN, n, XL_NIL)

它將被展開為：T0 _0; T1 _1; T2 _2; … Tn _n;

現(xiàn)在我們開始組裝：

#ifndef XL_TUPLE_DEFINE_MAX
#define XL_TUPLE_DEFINE_MAX  20
#endif

template <XL_TUPLE_TYPENAME_DECLARE_NT(XL_INC(XL_TUPLE_DEFINE_MAX))>
struct Tuple;

template <XL_TUPLE_TYPENAME_DECLARE(n)>
struct Tuple<XL_TUPLE_TYPENAME_LIST(n)>
{
    XL_TUPLE_MEMBER_DECLARE(n)
};

其中后一個還帶有宏參數(shù) n。我們將這整一個定義成宏，然后進行宏循環(huán)：

#define XL_TUPLE_IMPLEMENT_PATTERN(n)   \
                                        \
template <XL_TUPLE_TYPENAME_DECLARE(n)> \
struct Tuple<XL_TUPLE_TYPENAME_LIST(n)> \
{                                       \
    XL_TUPLE_MEMBER_DECLARE(n)          \
};                                      \

#define XL_TUPLE_IMPLEMENT(n)    XL_REPY(XL_TUPLE_IMPLEMENT_PATTERN, n, XL_NIL)

之后再使用這個宏：

XL_TUPLE_IMPLEMENT(XL_TUPLE_DEFINE_MAX)

到此為止，上文一開始提出的 Tuple 已經(jīng)實現(xiàn)，并支持到最大約 20 個元素左右。

然后我們可以考慮增加各種方便使用的功能。

1. 默認構造函數(shù)。
   
2. 帶有 n 個參數(shù)的構造函數(shù)。相關宏定義：
   #define XL_TUPLE_INITIALIZE_LIST_PATTERN(n)         _##n(_##n)
   #define XL_TUPLE_INITIALIZE_LIST(n)                 XL_REPZ(XL_TUPLE_INITIALIZE_LIST_PATTERN, n, XL_COMMA)
   
3. 拷貝構造函數(shù)。相關宏定義：
   #define XL_TUPLE_INITIALIZE_LIST_COPY_PATTERN(n)    _##n(that._##n)
   #define XL_TUPLE_INITIALIZE_LIST_COPY(n)            XL_REPZ(XL_TUPLE_INITIALIZE_LIST_COPY_PATTERN, n, XL_COMMA)
   
4. 賦值函數(shù)：
   #define XL_TUPLE_ASSIGN_PATTERN(n)                  this->_##n = that._##n;
   #define XL_TUPLE_ASSIGN(n)                          XL_REPZ(XL_TUPLE_ASSIGN_PATTERN, n, XL_NIL)
   
5. 各種比較函數(shù)。請注意對各元素的相應比較運算符的依賴。這里定義成，Tuple 的 < 只依賴于各元素的 <，Tuple 的 != 也只依賴于各元素的 !=，如此類推。
   
   #define XL_TUPLE_EQUAL_PATTERN(n)                   this->_##n == that._##n
   #define XL_TUPLE_EQUAL(n)                           XL_REPZ(XL_TUPLE_EQUAL_PATTERN, n, &&)

#define XL_TUPLE_NOT_EQUAL_PATTERN(n)               this->_##n != that._##n
#define XL_TUPLE_NOT_EQUAL(n)                       XL_REPZ(XL_TUPLE_NOT_EQUAL_PATTERN, n, ||)

#define XL_TUPLE_LITTER_PATTERN(n)                  if (this->_##n < that._##n)         \
                                                    {                                   \
                                                        return true;                    \
                                                    }                                   \
                                                    else if (that._##n < this->_##n)    \
                                                    {                                   \
                                                        return false;                   \
                                                    }
#define XL_TUPLE_LITTER(n)                          XL_REPZ(XL_TUPLE_LITTER_PATTERN, n, XL_NIL)

#define XL_TUPLE_GREATER_PATTERN(n)                 if (this->_##n > that._##n)         \
                                                    {                                   \
                                                        return true;                    \
                                                    }                                   \
                                                    else if (that._##n > this->_##n)    \
                                                    {                                   \
                                                        return false;                   \
                                                    }
#define XL_TUPLE_GREATER(n)                         XL_REPZ(XL_TUPLE_GREATER_PATTERN, n, XL_NIL)

同時 Tuple 中也增加相應的函數(shù)，即可。

最終代碼見 xlTuple.h，這里不貼了。

請多多指正。