c++ 模板 指针类型偏特化

一步步来,先简单点.

目标:我们要实现一个模板类,例化后,可以通过get_val获取到值,通过get_ptr获取到指针.具体什么意思结合例子来看看吧.

例子:

struct A{
    int data;
    A(int _data = 0):data(_data){}
};
template <typename T>
 class heap_node{
 public:
 	 typedef T  val_type;
	 typedef T* ptr_type;
	 typedef T& ref_type;
	 ptr_type data;
	 ref_type get_val() { return *data; }
	 ptr_type get_ptr() { return data; }
	 heap_node(ptr_type d) :data(d){
		 printf("<T> (T*)\n");
	 }
	 heap_node(ref_type d) :data(&d){
		 printf("<T> (T)\n");
	 }
 };

 int main() {
	 A a(10);
	 printf("ptr=%p\n",&a);
	 heap_node<A> p0(a);
	 printf("ptr=%p val=%d\n", p0.get_ptr(),p0.get_val().data);
	 heap_node<A> p1(&a);
	 printf("ptr=%p val=%d\n", p1.get_ptr(), p1.get_val().data);
	/*
	 heap_node<A*> p2(a);
	 printf("ptr=%p val=%d\n", p2.get_ptr(), p2.get_val().data);
	 heap_node<A*> p3(&a);
	 printf("ptr=%p val=%d\n", p3.get_ptr(), p3.get_val().data);
	*/
     char ch = getchar();
}

(不要在类里直接保存值类型的数据,可以用指针或者引用都可以)

发现heap_node<A> p2(a)或者heap_node<A> p3(&a)的时候,无法正常表达我们原来的意识,此时的val_type就变成指针类型,怎么解决呢.需要对<T*>特殊处理一下.

struct A{
    int data;
    A(int _data = 0):data(_data){}
};
template <typename T>
 class heap_node{
 public:
 	 typedef T  val_type;
	 typedef T* ptr_type;
	 typedef T& ref_type;
	 ptr_type data;
	 ref_type get_val() { return *data; }
	 ptr_type get_ptr() { return data; }
	 heap_node(ptr_type d) :data(d){
		 printf("<T> (T*)\n");
	 }
	 heap_node(ref_type d) :data(&d){
		 printf("<T> (T)\n");
	 }
 };
//<T*>偏特化
template <typename T>
 class heap_node<T*>{
 public:
 	 typedef T  val_type;
	 typedef T* ptr_type;
	 typedef T& ref_type;
	 ptr_type data;
	 ref_type get_val() { return *data; }
	 ptr_type get_ptr() { return data; }
	 heap_node(ptr_type d) :data(d){
		 printf("<T*> (T*)\n");
	 }
	 heap_node(ref_type d) :data(&d){
		 printf("<T*> (T)\n");
	 }
 };
 int main() {
	 A a(10);
	 printf("ptr=%p\n",&a);
	 heap_node<A> p0(a);
	 printf("ptr=%p val=%d\n", p0.get_ptr(),p0.get_val().data);
	 heap_node<A> p1(&a);
	 printf("ptr=%p val=%d\n", p1.get_ptr(), p1.get_val().data);

	 heap_node<A*> p2(a);
	 printf("ptr=%p val=%d\n", p2.get_ptr(), p2.get_val().data);
	 heap_node<A*> p3(&a);
	 printf("ptr=%p val=%d\n", p3.get_ptr(), p3.get_val().data);

     char ch = getchar();
}

可能还有const修饰T,或者实例化T为原始数据类型......,都可能出现类似的问题,可以用偏特化解决.这里就不一一列举出来哈.

我们可以发现,特例化的<T*>模板与原模板代码上几乎一样的,是不是可以优化一下呢.

直接上代码:

struct A{
    int data;
    A(int _data = 0):data(_data){}
};

template <class T>
 struct heap_node_type{
	 typedef T  val_type;
	 typedef T* ptr_type;
	 typedef T& ref_type;
 };

 template <class T>
 struct heap_node_type<T*>{
	 typedef T  val_type;
	 typedef T* ptr_type;
	 typedef T& ref_type;
 };

 template <class T>
 class heap_node :heap_node_type<T>{
 public:
	 ptr_type data;
	 ref_type get_val() { return *data; }
	 ptr_type get_ptr() { return data; }
	 heap_node(ptr_type d) :data(d){
		 printf("<T> (T*)\n");
	 }
	 heap_node(ref_type d) :data(&d){
		 printf("<T> (T)\n");
	 }
 };

 int main() {
	 A a(10);
	 printf("ptr=%p\n",&a);
	 heap_node<A> p0(a);
	 printf("ptr=%p val=%d\n", p0.get_ptr(),p0.get_val().data);
	 heap_node<A> p1(&a);
	 printf("ptr=%p val=%d\n", p1.get_ptr(), p1.get_val().data);

	 heap_node<A*> p2(a);
	 printf("ptr=%p val=%d\n", p2.get_ptr(), p2.get_val().data);
	 heap_node<A*> p3(&a);
	 printf("ptr=%p val=%d\n", p3.get_ptr(), p3.get_val().data);

	 int b = 100;
	 printf("==========int====\nptr=%p\n", &b);
	 heap_node<int> p4(b);
	 printf("ptr=%p val=%d\n", p4.get_ptr(), p4.get_val());
	 heap_node<int> p5(&b);
	 printf("ptr=%p val=%d\n", p5.get_ptr(), p5.get_val());

	 heap_node<int*> p6(b);
	 printf("ptr=%p val=%d\n", p6.get_ptr(), p6.get_val());
	 heap_node<int*> p7(&b);
	 printf("ptr=%p val=%d\n", p7.get_ptr(), p7.get_val());
     char ch = getchar();
}