一个判断一组类型中谁的sizeof值最大?

[tangshuiling]

下面的代码要是读过<<Modern C++ Design>>兴许能看懂，但能想到这种设计就
绝对是功力的问题。
#include <iostream>
using namespace std;
struct NullType;
template <class T,class U>
struct typelist
{
	typedef T head;
	typedef U tail;
};
#define typelist_1(T1) typelist<T1,NullType>
#define typelist_2(T1,T2) typelist<T1,typelist_1(T2)>
#define typelist_3(T1,T2,T3) typelist<T1,typelist_2(T2,T3)>
#define typelist_4(T1,T2,T3,T4) typelist<T1,typelist_3(T1,T2,T3)>
template <class Tlist> struct MaxType;
template <>
struct MaxType<NullType>  //全特化,空类型时令Max为-1
{
	enum{Max=-1};
 
};
template <class Head,class Tail>
struct MaxType<typelist<Head,Tail> > //偏特化
{
	enum {size=sizeof(Head)};
	enum { Max=( size > MaxType<Tail>::Max  )  ?   size : MaxType<Tail>::Max }; //前面是size
                                                                   //而比较的后面又是Max,谁能讲讲？
};
int _tmain(int argc, _TCHAR* argv[])
{
	typedef typelist_4(char,float,double,char) types_4;
	cout<<MaxType<types_4>::Max<<endl; //求得double类型sizeof值是最大的为8
	return 0;
}
能谈谈各自的看法和理解，再此谢谢了！ （附：在vs2005中调试通过)

[kingstarer]

前面的max跟后面的max不一样啊

template <class Head,class Tail>
struct MaxType<typelist<Head,Tail> > //偏特化
{
enum {size=sizeof(Head)};
enum { Max=( size > MaxType<Tail>::Max ) ? size : MaxType<Tail>::Max }; //前面是size
//而比较的后面又是Max,谁能讲讲？
//将Max赋值为size和MaxType<Tail>::Max中较大的一个
};

以tail为MaxType<NullType>

以head为char

为例

则
enum { Max=( size > MaxType<Tail>::Max ) ? size : MaxType<Tail>::Max };

<=>
enum { Max=(1 > -1) ? 1 : -1 };

<=>

enum { Max=1; }

[kingstarer]

#define Max(p, q) (p > q ? p : q)
#define MaxSizeType_1(p) (sizeof(p))
#define MaxSizeType_2(p, q) Max(sizeof(p), MaxSizeType_1(p))
#define MaxSizeType_3(p, q, m) Max(sizeof(m), MaxSizeType_2(p, q))
#define MaxSizeType_4(p, q, m, n) Max(sizeof(n), MaxSizeType_3(p, q, m))

这个也能达到差不多的效果　不过相对似乎更容易理解

[lsupper]

up~~~~~~~~~~~

[kingstarer]

typedef struct { enum {Max = MaxSizeType_4(char,float,double,char)}; } types_4;

[光宇广贞]

这个，MAX最后递归返回的是-1，和size是一个型的。都是enum:int型。

这个就是返回比较列表里面，字节最长的那个类型的字节长度。

[deerwin1986]

不错。。。

[猫已经找不回了]

不错不错。收藏

[hityct1]

好贴。

[hityct1]

不过也许编译器会递归两次。这样写：

template <class Head,class Tail>
struct MaxType<typelist<Head,Tail> > //偏特化
{
 private:
	enum { size1=MaxType<Tail>::Max}; 
 public:
	enum {size=sizeof(Head)};
    enum { Max=( size > size1  )  ?   size : size1 }; 

};

[tangshuiling]

纠正一个错误：
#define typelist_4(T1,T2,T3,T4) typelist<T1,typelist_3(T1,T2,T3)>
改为：
#define typelist_4(T1,T2,T3,T4) typelist<T1,typelist_3(T2,T3,T4)>

顺便建议没看过<<Modern C++ Design>>这本书的老鸟们，怎么也得抽时间看看，
感觉里面的一些思维方式犹如醍醐灌顶，给人一种全新的境界，template泛型的使用
也是到达了登峰造极的程度，能把c/c++的型别玩到随心所欲的地步，本人一直就认为
要成为c/c++程序员必须对c/c++的类型和内存数据操作理解到一定的高度，才能算作
进入门槛了

[yshuise]

这个东西是基础，boost关于模板特化，而造成的递归，如果没有这个做为基础，肯定看不懂。
我已经跨过这个坎了。哈哈哈！

[yshuise]

boost里面的有些库比较有新意。对知识要求非常的扎实。只要对某一个方面的
问题研究不透，就走不下了。比如预处理，模板递归要求都比较高。

[yshuise]

是书上的代码吗？我觉得你的程序有bug
想问一下你的代码是想做什么？

template <class Head,class Tail>
struct MaxType<typelist<Head,Tail> > //偏特化
{
    enum {size=sizeof(Head)};
    enum { Max=( size > MaxType<Tail>::Max  )  ?   size : MaxType<Tail>::Max }; //前面是size
                                                                   //而比较的后面又是Max,谁能讲讲？
};

[hjjdebug]

vc6 下编不过，不看了，简单就是一种美！

[yshuise]

求类型的最大字节数吧.
  typedef typelist_4(char,float,double,char) types_4;

把这个条件改为小一些这样推导更方便：
typedef   typelist<char, typelist<double, typelist<float, NULLType> > > type; 

template <class Head,class Tail>
struct MaxType<typelist<Head,Tail> > //偏特化
{
    enum {size=sizeof(Head)};
    enum { Max=( size > MaxType<Tail>::Max  )  ?   size : MaxType<Tail>::Max }; //前面是size
                                                                   //而比较的后面又是Max,谁能讲讲？
};
首先：
struct  MaxType<typelist<char, typelist<double, typelist<float, NULLType> > > >
{ 
 //Head = char;
 //Tail  = typelist<double, typelist<float, NULLType> > >;
 enum {size = sizeof(char)}; //size = 1;
 enum {Max = (1 > MaxType<typelist<double, typelist<float, NULLType> >>::Max)? 1 :  MaxType<typelist<double, typelist<float, NULLType> >>::Max
 };
因为：MaxType<typelist<double, typelist<float, NULLType> >>::Max的值不知道，所以要继续特化（递归）：
struct MaxType<typelist<double, typelist<float, NULLType> >>
{
   //Head = double;
   //Tail = typelist<float, NULLType>;
   enum{size = sizeof(double)} //size = 8 
   enum{Max = (8 > MaxType<typelist<float, NULLType>>::Max)? 8: MaxType<typelist<float, NULLType>>::Max
};
还要求：MaxType<typelist<float, NULLType>>::Max
struct MaxType<typelist<float, NULLType>>{
  //Head = float;
  //Tail = NULLType;
  enum{size = sizeof(float)};
  enum {Max = size > MaxTpe<NULLType>::Max ?.....}//这儿再也不需要特化了，

};

[hiboys]

关键部分是对部分特化的认识。

对部分特化的通常理解为：
template <typename A,typename B> class someTemplateClass;
其部分特化形式：
template <typename A> class someTemplateClass<A,int>;


LZ的部分特化从一个参数类型至二个参数类型。(理解：加一参数也是特化了 ? 推导：和声明不同就是特化了?)

template <class Tlist> struct MaxType;//这个是声明吧
==>
template <class Head,class Tail>
struct MaxType<typelist<Head,Tail> > //偏特化

[tangshuiling]

感谢yshuise 的回复，如你所说这个东西是基础

同时恭喜你“我已经跨过这个坎了”，我正在迈！...

[zhujun2006un]

看不懂了，看来要学的东西还很多啊！

[pengzhixi]

标记下

[fairchild811]

学习一下，收藏了慢慢看