一个简单的 Tuple 实现

标题中说的 Tuple 是指类似 boost::tuple 这样的设施。

很多时候我们需要返回/传入一堆参数，所以不得不每次定义一些为了数据传输的结构。Tuple 就是用来解决这一问题的，它提供即时构造一个这样的结构体的功能。而所付出的代价是，丧失各个成员的明确含义，只留下成员的序号。

两个元素的 Tuple 就是 Pair，如 std::pair。下面我们来建立针对有限个元素的 Tuple。对于一个元素、两个元素、三个元素，我们可以分别如下实现：

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;
};

但是这三个写在一起，就会出错。为此，我们可以先定义一个含足够多模版参数的 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;
};

如果手写的话，这也可以。如果不手写，我们可以继续用之前《C++ 下 Function 对象的实现（下）》中的宏循环方案。此方案的一个正式版本见 xlMacros.h。

定义带默认值 NullType 的模版参数声明序列如下：

#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

定义不带默认值的模版参数声明序列如下：

#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

定义模版参数使用序列如下：

#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;

现在我们开始组装：

#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)
};

其中后一个还带有宏参数 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 已经实现，并支持到最大约 20 个元素左右。

然后我们可以考虑增加各种方便使用的功能。

1. 默认构造函数。
   
2. 带有 n 个参数的构造函数。相关宏定义：
   #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. 拷贝构造函数。相关宏定义：
   #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. 赋值函数：
   #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. 各种比较函数。请注意对各元素的相应比较运算符的依赖。这里定义成，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 中也增加相应的函数，即可。

最终代码见 xlTuple.h，这里不贴了。

请多多指正。