c++ 泛型编程之 TypeLists

关于 C++ 泛型中的 TypeTraits ，参考 c++ 泛型编程之 TypeTraits

#ifndef TYPE_LISTS_H_
#define TYPE_LISTS_H_


#include 
  
   
#include 
   
     #include typetraits.h /* TypeLists 内部没有任何数值（value)，他们的实体是空的，不含有任何状态，也未定义任何函数。 执行期间TypeLists也不带任何数值，他们存在的理由只是为了携带型别信息。TypeLists 并未打算被具 现化。因此，当我们说“a TypeListL”，实际指的是一个typelist型别，不是一个typelist 对象。 规定 typelist 必须以NullType(类）结尾，NullType可被视为一个结束符号，类似于c字符串的功能， 定义一个只有一个元素的typelist如下： typedef Typelist
    
      OneTypeOnly. */ template
     
       struct Typelist { typedef T Head; typedef U Tail; }; //通过定义宏 将typelist线性化 #define TYPELIST_0() NullType #define TYPELIST_1(T1) Typelist
      
        #define TYPELIST_2(T1,T2) Typelist
       
         #define TYPELIST_3(T1,T2,T3) Typelist
        
          #define TYPELIST_4(T1,T2,T3,T4) Typelist
         
           #define TYPELIST_5(T1,T2,T3,T4,T5) Typelist
          
            //计算TypeList长度 //大多数Typelist的操作都是基于递归，递归终止条件通过模板特化实现。 template
           
            struct Length; template<>struct Length
            
             //Length的全特化，即，只匹配NullType。 { enum{value = 0}; }; template
             
               struct Length
              
                >//Length的扁特化，可匹配任何TypeList
               
                类型，包括U同时也是Typelist的复合情况。 { enum{value = 1+Length
                ::value}; }; //2 索引式访问 template 
                 
                   struct TypeAt; template
                  
                    struct TypeAt
                   
                    ,0> { typedef Head Result; }; template
                    
                      struct TypeAt
                     
                       ,i> { typedef typename TypeAt
                      
                       ::Result Result; }; //类似TypeAt功能，不过TypeAtNonStrict对逾界访问更加宽容。 //比如TypeList的个数是3，那么你不能使用TypeAt
                       
                        ::Result，这样会编译错误。 //但是TypeAtNonStrict
                        
                         ::Result可以，如果不存在索引为3的type，那么结果是第三个引数即NullType template 
                         
                           struct TypeAtNonStrict { typedef DefType Result; }; template 
                          
                            struct TypeAtNonStrict< Typelist
                           
                            , 0, DefType > { typedef T Result; }; template 
                            
                              struct TypeAtNonStrict< Typelist
                             
                              , i, DefType > { typedef typename TypeAtNonStrict
                              
                               ::Result Result; }; //3 查找TypeList template
                               
                                 struct IndexOf;//声明 template
                                
                                  struct IndexOf
                                 
                                  //如果TList为NullType，那么令value = -1； { enum{value = -1}; }; template
                                  
                                    struct IndexOf
                                   
                                     ,T>//如果T是TList中的头端，那么令value= 0； { enum{value = 0}; }; template
                                    
                                     //将IndexOf施于TList尾端和T，并将结果置于一个临时变量temp struct IndexOf
                                     
                                       ,T>//如果temp为-1，令value为-1，否则令value为1+temp { private: enum{temp = IndexOf
                                      
                                       ::value};//temp要先于value声明定义。 public: enum{value = temp == -1 ? -1 : temp + 1}; }; //4 附加元素到typelist template 
                                       
                                        struct Append;//声明 template<>struct Append
                                        
                                         //如果TList是NULL而且T是NULL，那么令Result为NullType { typedef NullType Result; }; template 
                                         
                                           struct Append
                                          
                                            //如果TList是NullType，且T是type(非typelist), { //那么Result将是只含有唯一元素的T; typedef TYPELIST_1(T) Result; }; template 
                                           
                                             struct Append
                                            
                                              >// 如果TList是NullType，且T是一个typelist，那么Result便是T本身 { typedef Typelist
                                             
                                               Result; }; template
                                              
                                               //否则，如果Tlist是non-null，那么result将是个typelist，以TList::Head struct Append
                                               
                                                ,T> //为起头端，并以T附加到TList::Tail的结果为其尾端。 { typedef Typelist
                                                
                                                 ::Result> Result; }; //5 Reverse template 
                                                 
                                                   struct Reverse; template <>struct Reverse
                                                  
                                                    { typedef NullType Result; }; template 
                                                   
                                                     struct Reverse< Typelist
                                                    
                                                      > { typedef typename Append< typename Reverse
                                                     
                                                      ::Result, Head>::Result Result; }; #endif

测试

void typelists_test()
{
	typedef TYPELIST_0() TL0;
	typedef TYPELIST_3(char,int,double) TL3;
	typedef TYPELIST_3(char,int,double) TL3_1;
	//Length
	std::cout<
   
    ::value<
    
     ::value<
     
      ::Result Parm1; typedef TypeAt
      
       ::Result Parm2; typedef TypeAt
       
        ::Result Parm3; typedef TypeAtNonStrict
        
         ::Result TEST_TYPE; std::cout<
         
          ::value<
          
           ::value<
           
            ::value<
            
              TL4;//TL4不是一个TypeList typedef Append
             
               TL5; std::cout<
              
               ::value<
               
                ::value<
                
                 ::Result).name()<
                 
                  ?
                  ?

c++ 泛型编程 之 TypeLists