超越boost: 1)tuple

写这个系列包括下列原因：

1）boost很多东西很有用，真的。

2）boost很多东西用起来却很痛苦。不出问题则以，一出问题，编译时错误信息1M算少的了；调试进入boost代码，你就等着两眼摸黑了吧。

3）boost很多东西的源码值得学习，如果你能完整的完成一个库，几乎可以吃透template绝大部分知识了。笔者完完整整实现完了的东西也就typeof,tuple还有一些比较简单的东西。

4）boost很多东西很长时间不更新了，发稿过去也爱理不理的。以这个tuple为例，别人回信说：“...虽然你的实现后端更高效，不过tuple已经列入tr1,在很多开发平台stl中实现了，没有必要更新了。我们现有的实现在经过高效编译器的优化后和你的实现效率相差不大，贸然替换我们还有海量的兼容性测试要做...”不提了。

5）boost很多东西代码风格很混乱。有一些代码过度的换行（其实就是比较垃圾的反复重载，特化代码，T1,T2,T3,T4,T5,T6,T7,T8,T9,T10....，一个参数要占一行），使得阅读一点代码不得不反复的翻屏，极难以阅读。

 

之所以要拿tuple开头，是因为它很有趣，很有用，对其他boost库的依赖性也相对比较小。而且是唯一一个笔者敢自称做的比boost好的一个库！

 

首先介绍一些背景,最好你还能看看这些：

1）tuple是一种多元数据容器，是std::pair的扩展，boost::tuple支持最多10元的容器，语义和接口几乎和python等语言的tuple等价。

2）tuple的实现类似于typelist，然而它是数据容器，所以还需要提供数据访问和本身构造的接口。

3）boost::tuple的类型系统和loki::typelist类似，内部数据结构则使用了“组合”（Composition）构建这个“虚”list（由于是组合而不是聚合，从实现上看，空间上实际是连续的），访问特定元素却需要遍历这个链（这个空间上的连续关系编译器基本上都是明白的，但c++语言不对程序员开放这个接口，所以只能寄希望于编译器优化掉这个遍历行为）。

这里的3）是什么意思呢：见下例

 

struct A0 {};

struct A1 {  A0 last_data; std::string data; const std::string &get_data1() const;};

struct A2 {  A1 last_data; int data;             const std::string &get_data1() const;};

struct A3 {  A2 last_data; double data;      const std::string &get_data1() const;};

 

这里A0可以看作是一个数据链表中的空节点，A_i+1和A_{i是组合的关系，空间上是连续的。这基本就是boost::tuple的实现的数据模型。我们接下来就可以把A3看作是一个3元的tuple,有3个data的元素，也就是boost::tuple<std::string, int, double>.}

 

对于一个A3类型的对象a3而言,他要访问第“1”个元素该怎么访问呢？

首先要说明的一点是， 实际的实现中A1， A2， A3的data类型都是范性的，所以不可以假设A1， A2， A3符合POD语义（如A1,data是非POD）.既然不能轻易使用OFFSET之类的方法访问，那自然只有唯一一种方法了：

a3.last_data.last_data.data

这对于编译器来说，3步路实际上是一步路：它很清楚我们需要访问a3首地址那块sizeof(string)的数据。

 

然而回到传统的链表：学过链表的人都知道，我们的list是不定长的，当传入一个非负整数参数N，访问链表的第N个元素时，我们显然不能把访问函数std::list::at(int)实现成

p->next->next->next...->data           //N个-〉，其中p是链表头指针，next是下一个节点的指针，然而代码是固定的呀，所以不能这样写代码。

 

tuple的长度虽然是编译时确定,但是对于范型代码本身而言,我们的tuple也将是不定长的，如果为N =1 , N =2 ,N =3, N= 4..........N=10各自特化访问，不仅代码冗长，而且还要对每个类加上额外的代码控制特化代码的产生（例如tuple 长度为5时，就不能产生N= 6--10的特化代码，因为是全特化，类一实例化函数会立即实例化。加一个控制参数是一种方法，当然开销也来了），那么产生的特化访问代码将多达10*(10-1)/2= 45种，够骇人听闻吧。

 

boost::tuple怂了，使用了连续的函数调用(当然实际的实现是用模板的范型，这里简单化问题，只需要访问第一个。这里列出所有的实例化结果) 

inline const std::string &A3::get_data1() const {return last_data.get_data1();}

inline const std::string &A2::get_data1() const {return last_data.get_data1();}

inline const std::string &A1::get_data1() const {return data;}                  //实际代码当然使用了特化来控制迭代的结束。

 

a3.get_data1()代码的语义和a3.last_data.last_data.data没有区别，问题是编译器能够这么聪明，理解咱们的意思，把3个函数甚至更多个函数不仅要inline, 而且还要合并他们, 实现a3.get_data1()转为a3.last_data.last_data.data吗？大家现在还敢保证A3类型的对象a3能一步就访问到第一个元素吗？

 

笔者试了一下gcc4以下不能，vc2008在步数多于5时不能。毕竟这已经属于很深层次的语义分析了，和一般的尾递归还有所不同，如果选择的数据类型更凌乱,更复杂一些,还有union，访问中间的元素，只怕更难。咱们也不要太过于苛求编译器,否则编译时间会让你郁闷致死....而且这里还产生了额外的多线程竞争访问的危险.

 

 

笔者在此给出了自己的优化和理解：使用继承取代组合。

 

笔者当时因为需要写一个数学运算函数式而不得不实现一个类似的东西来封装传入的多元函数变量的值，后来一看boost::tuple：不就是那么一回事嘛，效率还不如我的家伙。然后把接口名字什么的大致改的和tuple差不多，就直接投稿了。然后当然如上文所说,被别人很客气的鄙视了.

 

为什么继承好：第一，这是内部细节，加强耦合完全不是什么问题；第二，当然就是可以"一步"访问,可以理解为随机访问，random_access！

 

看下新的实现：

struct A0 {};

struct A1 : public A0  {  std::string data; const std::string &get_data1() const;};

struct A2 : public A1  {  int data;             const int  &get_data1() const;};

struct A3 : public A2  {  double data;      const double &get_data1() const;};

 

inline const std::string &A3::get_data1() const {return ((const A1*)this)->data;} //1步！

inline const std::string &A2::get_data1() const {return ((const A1*)this)->data;} //1步！

inline const std::string &A1::get_data1() const {return ((const A1*)this)->data;} //1步！

 

不仅时间效率提升了，而且代码也清爽了，用特化来终止迭代也不用了，空间效率只可能比原来高或者相等(对于正常的编译器,组合和继承产生的对象大小应该相等的) 。问题就只剩一个: 把输入的N通过模板的种种" 幻术" 映射为类型A_N, 小case! 略过不提.

 

贴上我的代码,这里提供的是不依赖任何外部头文件的实现. 所以没有提供对于std::pair的赋值和tie, 对于iostream的流操作符重载.以及没有什么大用的ignore对象, 对引用类型的存储(tuple的定位就应该是一个数据容器,别太花哨).其他接口和boost::tuple一致.有些比较必须的垃圾重载代码直接找boost拷贝了过来.

 

直接编译就可以运行,大家可以随便修改main函数,第一次用tuple的可以享受一下.已经在vc6,2005,icc10,g++等通过测试.

 

#include "stdio.h" #include <string> #include <iostream> using namespace std; #define ENABLE_TIE #define ENABLE_PARTIAL_SPECIALIZATION template <int N> struct mpl_int { enum {value = N}; char sizer[N + 5]; }; enum {type_index_begin = 0}; #ifndef ENABLE_PARTIAL_SPECIALIZATION template <typename T, int N> struct type_at { enum {back_step = N}; enum {stop_tag = type_index_begin}; typedef T this_type; template <int M> struct inner //Use it to simulate template's partial specialization! { typedef typename type_at<typename this_type::last_type, (M - 1) >::template inner< (M - 1) >::type type; }; template <> struct inner<stop_tag> { typedef this_type type; }; typedef inner<back_step>::type type; }; #else template <typename T, int N> struct type_at { enum {back_step = N}; typedef T this_type; typedef typename type_at<typename this_type::last_type, (back_step - 1) >::type type; }; template <typename T> struct type_at<T, type_index_begin> { typedef T type; }; #endif template<typename T> struct assign_to_pointee { public: explicit assign_to_pointee(T* p) : ptr(p) {} template<typename Other> assign_to_pointee& operator=(const Other& other) { *ptr = other; return *this; } private: T* ptr; }; #define AUTO_GEN / LOGIC_BINARY_OPERATOR_GEN(==, true)/ LOGIC_BINARY_OPERATOR_GEN(!=, true)/ LOGIC_BINARY_OPERATOR_GEN(>=, true)/ LOGIC_BINARY_OPERATOR_GEN(<=, true)/ LOGIC_BINARY_OPERATOR_GEN(>, true)/ LOGIC_BINARY_OPERATOR_GEN(<, true) template <typename T> struct _null_type { enum {position = (type_index_begin - 1)}; enum {length = position + 1}; typedef _null_type<T> last_type; typedef _null_type<T> this_type; inline _null_type(){} template <typename L, typename R> inline _null_type(const L&, const R&){} template <typename A> inline void copy(const A&){} #define LOGIC_BINARY_OPERATOR_GEN(_op, _null_type_value)/ template <typename A>/ inline bool operator _op (const A& ) const{return _null_type_value;} AUTO_GEN #undef LOGIC_BINARY_OPERATOR_GEN }; typedef _null_type<void> null_type; #ifndef ENABLE_PARTIAL_SPECIALIZATION template <typename D, typename L> struct cons { template<typename DD, typename LL> struct real_type : public LL { typedef DD data_type; typedef LL last_type; typedef real_type<data_type, last_type> this_type; enum {position = (last_type::position + 1)}; enum {length = position + 1}; data_type data; inline real_type(const data_type& arg1, const last_type& arg2): last_type(arg2), data(arg1){} #ifdef ENABLE_TIE template <typename A> inline this_type& operator = (const A& arg){ if((void*)(this) != (void*)(&arg)) this->copy(arg); return *this; } #endif template <typename A> inline void copy(const A& arg){ this->data = arg.data; ((last_type&)(*this)).copy ((const typename A::last_type&)arg); } template <typename A> inline real_type<this_type, A> operator <<(const A& arg) const{ return real_type<this_type, A>(*this, arg); } template<int N> inline typename type_at<this_type, N>::type::data_type const & get( ) const{ typedef typename type_at<this_type, N>::type dest_type ; return (((const dest_type *)this)->data); } template<int N> inline typename type_at<this_type, N>::type::data_type & get( ) { typedef typename type_at<this_type, N>::type dest_type ; return (((dest_type *)this)->data); } #define LOGIC_BINARY_OPERATOR_GEN(_op, _null_type_value)/ template <typename A>/ inline bool operator _op (const A& arg) const/ {return ((data _op arg.data) && (((const last_type&)(*this)) _op ((const typename A::last_type&)arg)));} AUTO_GEN #undef LOGIC_BINARY_OPERATOR_GEN }; template<> struct real_type<null_type, null_type> { typedef null_type this_type; }; typedef real_type<D, L>::this_type type; }; #else template <typename D, typename L> struct cons : public L { typedef D data_type; typedef L last_type; typedef cons<data_type, last_type> this_type; enum {position = (last_type::position + 1)}; enum {length = position + 1}; data_type data; inline cons(const data_type& arg1, const last_type& arg2): last_type(arg2), data(arg1){} #ifdef ENABLE_TIE template <typename A> inline this_type& operator = (const A& arg){ if((void*)(this) != (void*)(&arg)) this->copy(arg); return *this; } #endif template <typename A> inline void copy(const A& arg){ this->data = arg.data; ((last_type&)(*this)).copy ((const typename A::last_type&)arg); } template <typename A> inline cons<this_type, A> operator <<(const A& arg) const{ return cons<this_type, A>(*this, arg); } template<int N> inline typename type_at<this_type, N>::type::data_type const & get( ) const{ typedef typename type_at<this_type, N>::type dest_type ; return (((const dest_type *)this)->data); } template<int N> inline typename type_at<this_type, N>::type::data_type & get( ) { typedef typename type_at<this_type, N>::type dest_type ; return (((dest_type *)this)->data); } #define LOGIC_BINARY_OPERATOR_GEN(_op, _null_type_value)/ template <typename A>/ inline bool operator _op (const A& arg) const/ {return ((data _op arg.data) && (((const last_type&)(*this)) _op ((const typename A::last_type&)arg)));} AUTO_GEN #undef LOGIC_BINARY_OPERATOR_GEN typedef this_type type; }; template <typename L> struct cons<null_type, L> { typedef L type; }; #endif template <int N, typename T > inline typename type_at<T, N>::type::data_type const & get(const T& arg){ return (((const typename type_at<T, N>::type&)arg).data); } template <int N, typename T > inline typename type_at<T, N>::type::data_type & get(T& arg){ return (((typename type_at<T, N>::type&)arg).data); } template <typename L, typename R > inline typename cons<L, R>::type tuple_add(const L& lhs, const R& rhs){ return cons<L, R>::type(lhs, rhs); } template <typename T1, typename T2 = null_type, typename T3 = null_type, typename T4 = null_type,typename T5 = null_type, typename T6 = null_type, typename T7 = null_type, typename T8 = null_type, typename T9 = null_type, typename T10 = null_type > struct map_tuple_to_cons { typedef typename cons<T10, null_type>::type cons10; typedef typename cons<T9, cons10>::type cons9; typedef typename cons<T8, cons9>::type cons8; typedef typename cons<T7, cons8>::type cons7; typedef typename cons<T6, cons7>::type cons6; typedef typename cons<T5, cons6>::type cons5; typedef typename cons<T4, cons5>::type cons4; typedef typename cons<T3, cons4>::type cons3; typedef typename cons<T2, cons3>::type cons2; typedef typename cons<T1, cons2>::type cons1; }; template <typename T1 = null_type, typename T2 = null_type, typename T3 = null_type, typename T4 = null_type,typename T5 = null_type, typename T6 = null_type, typename T7 = null_type, typename T8 = null_type, typename T9 = null_type, typename T10 = null_type > class tuple : public map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1 { public: typedef map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple; typedef typename mapped_tuple::cons10 cons10; typedef typename mapped_tuple::cons9 cons9; typedef typename mapped_tuple::cons8 cons8; typedef typename mapped_tuple::cons7 cons7; typedef typename mapped_tuple::cons6 cons6; typedef typename mapped_tuple::cons5 cons5; typedef typename mapped_tuple::cons4 cons4; typedef typename mapped_tuple::cons3 cons3; typedef typename mapped_tuple::cons2 cons2; typedef typename mapped_tuple::cons1 cons1; typedef cons1 this_type; typedef tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type; tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10(), null_type())))))))))) {} tuple(const T1& t1, const T2& t2, const T3& t3 = T3(), const T4& t4 = T4(), const T5& t5 = T5(), const T6& t6 = T6(), const T7& t7 = T7(), const T8& t8 = T8(), const T9& t9 = T9(), const T10& t10 = T10()) : cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6, cons7(t7, cons8(t8, cons9(t9, cons10(t10, null_type())))))))))) {} tuple( T1& t1, T2& t2, T3& t3 = T3(), T4& t4 = T4(), T5& t5 = T5(), T6& t6 = T6(), T7& t7 = T7(), T8& t8 = T8(), T9& t9 = T9(), T10& t10 = T10()) : cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6, cons7(t7, cons8(t8, cons9(t9, cons10(t10, null_type())))))))))) {} explicit tuple(const T1& t1) : cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(), cons7(T7(), cons8(T8(), cons9(T9(), cons10(T10(), null_type())))))))))) {} #ifdef ENABLE_TIE template <typename A> inline type& operator = (const A& arg){ (this_type&)(*this) = arg; return (*this); } #endif }; template<class T0> inline tuple<T0> make_tuple(const T0& t0) { return tuple<T0>(t0); } template<class T0, class T1> inline tuple<T0, T1> make_tuple(const T0& t0, const T1& t1) { typedef tuple<T0, T1> t; return t(t0, t1); } template<class T0, class T1, class T2> inline tuple<T0, T1, T2> make_tuple(const T0& t0, const T1& t1, const T2& t2) { typedef tuple<T0, T1, T2> t; return t(t0, t1, t2); } template<class T0, class T1, class T2, class T3> inline tuple<T0, T1, T2, T3> make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) { typedef tuple<T0, T1, T2, T3> t; return t(t0, t1, t2, t3); } template<class T0, class T1, class T2, class T3, class T4> inline tuple<T0, T1, T2, T3, T4> make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4) { typedef tuple<T0, T1, T2, T3, T4> t; return t(t0, t1, t2, t3, t4); } template<class T0, class T1, class T2, class T3, class T4, class T5> inline tuple<T0, T1, T2, T3, T4, T5> make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) { typedef tuple<T0, T1, T2, T3, T4, T5> t; return t(t0, t1, t2, t3, t4, t5); } template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline tuple<T0, T1, T2, T3, T4, T5, T6> make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) { typedef tuple<T0, T1, T2, T3, T4, T5, T6> t; return t(t0, t1, t2, t3, t4, t5, t6); } template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7> inline tuple<T0, T1, T2, T3, T4, T5, T6, T7> make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) { typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7> t; return t(t0, t1, t2, t3, t4, t5, t6, t7); } template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> inline tuple <T0, T1, T2, T3, T4, T5, T6, T7, T8> make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8) { typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> t; return t(t0, t1, t2, t3, t4, t5, t6, t7, t8); } template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9> inline tuple <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9) { typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> t; return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); } template<typename T1> inline tuple<assign_to_pointee<T1> > tie(T1& t1){ return make_tuple(assign_to_pointee<T1>(&t1)); } template<typename T1, typename T2> inline tuple<assign_to_pointee<T1>, assign_to_pointee<T2> > tie(T1& t1, T2& t2){ return make_tuple(assign_to_pointee<T1>(&t1), assign_to_pointee<T2>(&t2)); } template<typename T1, typename T2, typename T3> inline tuple<assign_to_pointee<T1>, assign_to_pointee<T2>, assign_to_pointee<T3> > tie(T1& t1, T2& t2, T3& t3){ return make_tuple(assign_to_pointee<T1>(&t1), assign_to_pointee<T2>(&t2), assign_to_pointee<T3>(&t3)); } template<typename T1, typename T2, typename T3, typename T4> inline tuple<assign_to_pointee<T1>, assign_to_pointee<T2>, assign_to_pointee<T3>, assign_to_pointee<T4> > tie(T1& t1, T2& t2, T3& t3, T4& t4){ return make_tuple(assign_to_pointee<T1>(&t1), assign_to_pointee<T2>(&t2), assign_to_pointee<T3>(&t3), assign_to_pointee<T4>(&t4)); } template<typename T1, typename T2, typename T3, typename T4, typename T5> inline tuple<assign_to_pointee<T1>, assign_to_pointee<T2>, assign_to_pointee<T3>, assign_to_pointee<T4>, assign_to_pointee<T5> > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5){ return make_tuple(assign_to_pointee<T1>(&t1), assign_to_pointee<T2>(&t2), assign_to_pointee<T3>(&t3), assign_to_pointee<T4>(&t4), assign_to_pointee<T5>(&t5)); } template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> inline tuple<assign_to_pointee<T1>, assign_to_pointee<T2>,assign_to_pointee<T3>, assign_to_pointee<T4>, assign_to_pointee<T5>, assign_to_pointee<T6> > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6) { return make_tuple(assign_to_pointee<T1>(&t1), assign_to_pointee<T2>(&t2), assign_to_pointee<T3>(&t3), assign_to_pointee<T4>(&t4), assign_to_pointee<T5>(&t5), assign_to_pointee<T6>(&t6)); } template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> inline tuple<assign_to_pointee<T1>, assign_to_pointee<T2>,assign_to_pointee<T3>, assign_to_pointee<T4>, assign_to_pointee<T5>, assign_to_pointee<T6>, assign_to_pointee<T7> > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7) { return make_tuple(assign_to_pointee<T1>(&t1), assign_to_pointee<T2>(&t2), assign_to_pointee<T3>(&t3), assign_to_pointee<T4>(&t4), assign_to_pointee<T5>(&t5), assign_to_pointee<T6>(&t6), assign_to_pointee<T7>(&t7)); } template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> inline tuple<assign_to_pointee<T1>, assign_to_pointee<T2>,assign_to_pointee<T3>, assign_to_pointee<T4>, assign_to_pointee<T5>, assign_to_pointee<T6>, assign_to_pointee<T7>, assign_to_pointee<T8> > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8) { return make_tuple(assign_to_pointee<T1>(&t1), assign_to_pointee<T2>(&t2), assign_to_pointee<T3>(&t3), assign_to_pointee<T4>(&t4), assign_to_pointee<T5>(&t5), assign_to_pointee<T6>(&t6), assign_to_pointee<T7>(&t7), assign_to_pointee<T8>(&t8)); } template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> inline tuple<assign_to_pointee<T1>, assign_to_pointee<T2>,assign_to_pointee<T3>, assign_to_pointee<T4>, assign_to_pointee<T5>, assign_to_pointee<T6>, assign_to_pointee<T7>, assign_to_pointee<T8>, assign_to_pointee<T9> > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9) { return make_tuple(assign_to_pointee<T1>(&t1), assign_to_pointee<T2>(&t2), assign_to_pointee<T3>(&t3), assign_to_pointee<T4>(&t4), assign_to_pointee<T5>(&t5), assign_to_pointee<T6>(&t6), assign_to_pointee<T7>(&t7), assign_to_pointee<T8>(&t8), assign_to_pointee<T9>(&t9)); } template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> inline tuple<assign_to_pointee<T1>, assign_to_pointee<T2>,assign_to_pointee<T3>, assign_to_pointee<T4>, assign_to_pointee<T5>, assign_to_pointee<T6>, assign_to_pointee<T7>, assign_to_pointee<T8>, assign_to_pointee<T9>, assign_to_pointee<T10> > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10) { return make_tuple(assign_to_pointee<T1>(&t1), assign_to_pointee<T2>(&t2), assign_to_pointee<T3>(&t3), assign_to_pointee<T4>(&t4), assign_to_pointee<T5>(&t5), assign_to_pointee<T6>(&t6), assign_to_pointee<T7>(&t7), assign_to_pointee<T8>(&t8), assign_to_pointee<T9>(&t9), assign_to_pointee<T10>(&t10)); } int main(int argc, char* argv[]) { tuple<int, string, int, int,int,int,int,int,int,int> d; int n = tuple<int, int, int, int,int,int,int,int,int,int>::length; int m = sizeof(tuple<int, int>); n = sizeof(tuple<int, int, int, int,int,int,int,int,int,int>); get<0>(d) = 1; get<1>(d) = 2; get<2>(d) = 3; d = (make_tuple(1, string("123456"),3,4,5,6,7,8,9, 10)); cout<<get<9>(d)<<endl; tuple<int, string, int, int,int,int,int,int,int,int> xx = make_tuple(1, string("123456"),3,4,5,6,7,8,9, 10); const string& d1 = get<1>(xx); const string& d2 = get<1>(d); cout << &(get<1>(xx)) <<endl; cout << get<1>(d) <<endl; bool dd = d>xx; cout <<boolalpha<<dd<<noboolalpha<< endl; int a1=1,a2=2,a3=3; tie(a1,a2,a3); tie(a1,a2,a3) = make_tuple(3,4,5); cout<<a1<<a2<<a3<<endl; return 0; }

 

控制宏: 

ENABLE_TIE,如果你不需要tie操作,  注释掉它. tie会给整体的代码带来一些小开销.笔者也觉得这个东西比较花腔,没有多大价值.

ENABLE_PARTIAL_SPECIALIZATION 如果你的编译器(如vc6)不支持偏特化, 注释掉它.笔者另外利用内部类来帮你模拟.

 

注意请不要在vc6里面编译调试版,好像是调试导出的symbol过长产生了溢出或者截断,然后会产生莫名其妙的编译错误.release版编译没有问题,为了提高编译速度,请关闭所有警告.

 

题外话: 笔者在这里的typelist实现中玩弄了一个类似c++ 0x的右值引用"类型折叠"的技巧(确实是受了右值引用这个设计思想的影响), 自动清除和合并typelist中的多余的空白节点null_type,一时颇为自傲,瞧不起boost::tuple. 后来某次再仔细瞅了瞅boost::tuple的实现, 原来别人也有独立实现的嘛(确实boost源码可读性不高).一种英雄惜英雄, 码农惜码农的感觉不由得油然而生....