问个模板类的实现

[kouji_aiba]

我要做个物件，假设现在有这么一个class
template<class T1,class T2,class T3,...>
class IHaveALotOfClass {...}
1.做一个成员函数
template<class T1>
void function()
{
//以下希望在编译期
//if T1==T2
ooxx
//else
xxoo
}
2.做一个能计数T1-Tn的计数器，可以计数非nulltype(比如)和计数class的种类(比如T1==T2那么就算一个)

[taodm]

去看《Modern C++ Design》,能得到思路。

不过，这问题2纯属脑力过剩游戏，就别折腾了。

[whg01]

为每个类创建一个实例，然后用typeid获取类的名称。但n的个数是要写死的，不可能是变长度的。
大概代码如下：
const char * strName[N];
strName[0] = typeid(T1).name();
strName[1] = typeid(T2).name();
...
...
然后对strName排序，最后统计。

[wanghao111]

学习 帮顶

[yshuise]

如果是在编译期间，是不可能用if,else这些在执行期间的语句了。
一个合理的选择是用模板特化可以很容易的做到这点：

template<typename T1, typename T2>
struct select{
};

template<>
struct select<T1,T1> //当T1=T2时选择这个分支。实用的时候：select<T1,T2>::type
{
typedef T1 type;

};

[whg01]

编译期？

[thy38]

用运行时吧。

[lin_style]

第一个不会。。。

[cphj]

两个我都不会

[kouji_aiba]

自己顶一下，没有人会吗？

[papaofdoudou]

budong

[Dave888Zhou]

1、判断一个类是否是类类型（即class,struct,union定义的类型）：

//isclasst.hpp：辨别类类型(class,struct,union)
#ifndef IS_CLASST_HPP
#define IS_CLASST_HPP
template<typename T>
class IsClassT{  //确定某个类型是否为类类型
private:
	typedef char One;
	typedef struct{
		char a[2];
	} Two;
	template<typename C>
	static One test(int C::*); //C是类类型时使用这个版本，函数参数是一个C的成员指针
	template<typename C>
	static Two test(...); //C是非类类型时使用这个版本
public:
	enum { Yes=sizeof(test<T>(0))==1 }; //是类类型则Yes为1，不是类类型时Yes为0
	enum { No=!Yes };
};
#endif

2、根据一个bool值来选择类型T1或T2：

//ifthenelse.hpp:根据bool值来选择类型T1或T2
#ifndef IFTHENELSE_HPP
#define IFTHENELSE_HPP
template<bool C,typename Ta,typename Tb>
class IfThenElse;   //基本模板，根据第1个实参来决定是选择第2个实参还是第3个实参
template<typename Ta,typename Tb>
class IfThenElse<true,Ta,Tb>{ //局部特化：true的话选择第2个实参
public:
	typedef Ta ResultT;
};
template<typename Ta,typename Tb>
class IfThenElse<false,Ta,Tb>{ //局部特化，false的话选择第3个参数
public:
	typedef Tb ResultT;
};
#endif

还有辨别其他各种类型的模板，看我博客上的文章“一个完整的类型区分框架”和“类型萃取技术”，正是你想要的。

3、判断T1是否等于T2，用typeid(T1).name()==typeid(T2).name()就可以了。

你的代码可以像下面这样的来写：

template<typename T1,typename T2,typename T3>
class LotOfClass{
	int sumClass,sumBuildin,sumFunc;
public
	LotOfClass():sum1(0),sum2(0),sum3(0){
	}
	void function(){
		if(IsClassT<T1>::Yes)
			sumClass++;
		//...
	}
	//...
};
   当然也可以直接用我博客中的那个Type<T>模板，更方便。

[yshuise]

函数一般用重载，而不是特化，这是规矩。类可以用特化。楼主有些基本概念
可以看看《exceptional c++ style》，关于函数特化的问题。

[fallening]

看LOKI去

[yshuise]

[Quote=引用 18 楼 fallening 的回复:]
看LOKI去
[/Quote]
loki太花哨了，还不如看boost

[caolei_kunming]

//第一问
#include <iostream>
using namespace std;
template <class T1,class T2>
class EqualOrNot{
putlic:
      EqualOrNot(int);
      ~EqualOrNot();
      
      bool equal(T1,T2)
      {
         if(T1==T2)
         return true;
         else 
         return false;
      }
private:
      };
//第二问
#include <typeinfo.h>
using namespace std;
template <class T1,class T2,class T3>
class Count{
public:
      judge(T1,T2,T3){
      if(
          if(typeid(T1)==typeid(T2)&&typeid(T2)==typeid(T3))
             count=1;
          if(typeid(T1)!=typeid(T2)&&typeid(T2)!=typeid(T3))
             count=3;
        )
      else count=2;
private:
      int count;
}

[yshuise]

函数参数传入必须是实参，而不是传入类型。

[yshuise]

bool equal(T1,T2)
{
if(T1==T2)
return true;
else
return false;
}
这肯定是错误的。

[yshuise]

#include "stdafx.h"
#include <iostream>
//#include <boost/pool/object_pool.hpp>
using namespace std;


template<typename T1, typename T2>
struct equal_{
	enum {vaule = false};
};
template<typename T1>
struct equal_<T1,T1>{
	enum {vaule = true};
};


int _tmain(int argc, _TCHAR* argv[])
{  
	cout<<equal_<int,int>::vaule<<endl;
	cout<<equal_<int,double>::vaule<<endl;
	return 0;
	
}

结果如下：

1
0
请按任意键继续. . .

[leewon1988]

[Quote=引用 15 楼 zhoudaxia 的回复:]
  1、判断一个类是否是类类型（即class,struct,union定义的类型）：
C/C++ code//isclasst.hpp：辨别类类型(class,struct,union)#ifndef IS_CLASST_HPP#define IS_CLASST_HPP
template<typename T>class IsClassT{//确定某个类型是否为类类型private:
typedefchar One;
typedefstruct{char a[2];
} Two;
template<typename C>static One test(int C::*);//C是类类型时使用这个版本，函数参数是一个C的成员指针 template<typename C>static Two test(...);//C是非类类型时使用这个版本public:enum { Yes=sizeof(test<T>(0))==1 };//是类类型则Yes为1，不是类类型时Yes为0enum { No=!Yes };
};#endif

  2、根据一个bool值来选择类型T1或T2：
C/C++ code//ifthenelse.hpp:根据bool值来选择类型T1或T2#ifndef IFTHENELSE_HPP#define IFTHENELSE_HPP
template<bool C,typename Ta,typename Tb>class IfThenElse;//基本模板，根据第1个实参来决定是选择第2个实参还是第3个实参template<typename Ta,typename Tb>class IfThenElse<true,Ta,Tb>{//局部特化：true的话选择第2个实参public:
typedef Ta ResultT;
};
template<typename Ta,typename Tb>class IfThenElse<false,Ta,Tb>{//局部特化，false的话选择第3个参数public:
typedef Tb ResultT;
};#endif
  还有辨别其他各种类型的模板，看我博客上的文章“一个完整的类型区分框架”和“类型萃取技术”，正是你想要的。

  3、判断T1是否等于T2，用typeid(T1).name()==typeid(T2).name()就可以了。

  你的代码可以像下面这样的来写：
C/C++ code
template<typename T1,typename T2,typename T3>class LotOfClass{int sumClass,sumBuildin,sumFunc;public
LotOfClass():sum1(0),sum2(0),sum3(0){
}void function(){if(IsClassT<T1>::Yes)
sumClass++;//... }//...};
当然也可以直接用我博客中的那个Type<T>模板，更方便。
[/Quote]

哇。。。这个研究STL很深入啊
看来我的路还很长啊

[kouji_aiba]

[Quote=引用 15 楼 zhoudaxia 的回复:]
  1、判断一个类是否是类类型（即class,struct,union定义的类型）：
C/C++ code//isclasst.hpp：辨别类类型(class,struct,union)#ifndef IS_CLASST_HPP#define IS_CLASST_HPP
template<typename T>class IsClassT{//确定某个类型是否为类类型private:
typedefchar One;
typedefstruct{char a[2];
} Two;
template<typename C>static One test(int C::*);//C是类类型时使用这个版本，函数参数是一个C的成员指针 template<typename C>static Two test(...);//C是非类类型时使用这个版本public:enum { Yes=sizeof(test<T>(0))==1 };//是类类型则Yes为1，不是类类型时Yes为0enum { No=!Yes };
};#endif

  2、根据一个bool值来选择类型T1或T2：
C/C++ code//ifthenelse.hpp:根据bool值来选择类型T1或T2#ifndef IFTHENELSE_HPP#define IFTHENELSE_HPP
template<bool C,typename Ta,typename Tb>class IfThenElse;//基本模板，根据第1个实参来决定是选择第2个实参还是第3个实参template<typename Ta,typename Tb>class IfThenElse<true,Ta,Tb>{//局部特化：true的话选择第2个实参public:
typedef Ta ResultT;
};
template<typename Ta,typename Tb>class IfThenElse<false,Ta,Tb>{//局部特化，false的话选择第3个参数public:
typedef Tb ResultT;
};#endif
  还有辨别其他各种类型的模板，看我博客上的文章“一个完整的类型区分框架”和“类型萃取技术”，正是你想要的。

  3、判断T1是否等于T2，用typeid(T1).name()==typeid(T2).name()就可以了。

  你的代码可以像下面这样的来写：
C/C++ code
template<typename T1,typename T2,typename T3>class LotOfClass{int sumClass,sumBuildin,sumFunc;public
LotOfClass():sum1(0),sum2(0),sum3(0){
}void function(){if(IsClassT<T1>::Yes)
sumClass++;//... }//...};
当然也可以直接用我博客中的那个Type<T>模板，更方便。
[/Quote]
type_traits我明白，第一条我已经解决了，原来函数模板不支持偏特化
3那个需要开启RTTI支持，并不是编译时型别检测
sumClass并不是我要的，我要的是“模板参数确切都是类型，我需要得到unique的型别数量”

现在还遇到个问题
我在这个class里面定义一个模板函数
template<typename T>
void foo();
然后特化
template<>
void foo<T1>();
template<>
void foo<T2>();
现在问题在于T1==T2的话 就会变成第二个特化重定义了