C++中类模板的深入理解

1，多参数类模板：

　1，类模板可以定义任意多个不同的类型参数；

　　1，代码示例：

 template <typename T1, typename T2>
 class Test
 {
 public:
     void add(T1 a, T2 a);
 };

 Test<int, float> t;

　　　　2，类模板可以被特化：

　　　　1，指定类模板的特定实现；

　　　　2，部分类型参数必须显示指定；

　　　　3，根据类型参数分开实现类模板；

　　　3，类模板的特化类型：

　　　　　1，部分特化 - 用特定规则约束类型参数；

　　　　　　1，上面的为部分特化；

　　　　 　2，完全特化 - 完全显示指定类型参数；

　　　4，类模板的特化编程实验：

 #include <iostream>
 #include <string>

 using namespace std;

 template
 < typename T1, typename T2 >
 class Test
 {
 public:
     void add(T1 a, T2 b)
     {
         cout << "void add(T1 a, T2 b)" << endl;
         cout << a + b << endl;
     }
 };

 /* 关于上述第一个类模板的特殊实现，关于指针的特化实现 */
 template
 < typename T1, typename T2 >
 class Test < T1*, T2* >      // 关于指针的特化实现
 {
 public:
     void add(T1* a, T2* b)
     {
         cout << "void add(T1* a, T2* b)" << endl;
         cout << *a + *b << endl;
     }
 };

 /* 定义上述第一个类模板的特殊实现，即当Test 类模板的两个类型参数完全相同时，使用这个实现；编译器并不认为在这里重新定义了一个新的模板，它认为这里是在定义第一个类模板的特殊实现；这里是部分特化；
 */
 template
 < typename T >
 class Test < T, T >    // Test 类模板的两个类型参数完全相同时，使用这个实现；
 {
 public:
     void add(T a, T b)
     {
         cout << "void add(T a, T b)" << endl;
         cout << a + b << endl;
     }

     void print()  // 特化实现可以重新定义新的函数；
     {
         cout << "class Test < T, T >" << endl;
     }
 };

 /* 定义上述第一个类模板的特殊实现，当 T1 == void* 并且 T2 == void* 时，使用这个实现； */
 template
 <  >  // 没有泛指类型；
 class Test < void*, void* >    // 当 T1 == void* 并且 T2 == void* 时
 {
 public:
     void add(void* a, void* b)
     {
         cout << "void add(void* a, void* b)" << endl;
         cout << "Error to add void* param..." << endl;
     }
 };

 int main()
 {
     Test<int, float> t1;  // 使用第一个类模板；
     Test<long, long> t2;  // 使用第三个类模板，特化实现；
     Test<void*, void*> t3;  // 使用第四个类模板，特化实现；

     t1.add(, 2.5);  // void add(T1 a, T2 b) 3.5；

     t2.add(, );  // void add(T a, Tb) 10；
     t2.print();  // class Test < T, T >

     t3.add(NULL, NULL);  // void add(void* a, void* b)；Error to add void* param...；

     Test<int*, double*> t4;  // 未有定义指针特化时，编译器显示 14 行：error: invalid operands of types 'int*' and 'double*' to binary 'operator+'；
                             // 特化指针后，打印 void add(T1* a, T2* b)；
     int a = ;
     double b = 0.1;

     t4.add(&a, &b);  // 1.1

     return ;
 }

　　　　　1，类模板的特化实现表象上面好像定义了不同的类模板，但其实我们仅仅是根据需要将一个类模板分开成不同的情况来实现；

　　　　　2，编译器编译过后根据我们使用的类型参数来决定究竟是哪一种实现；

　　　5，类模板特化注意事项：

　　　　　1，特化只是模板的分开实现：

　　　　　　 1，本质上是同一个类模板；

　　　　　　2，仅仅是将模板根据需要分开来实现；

　　　　　2，特化类模板的使用方式是统一的；

　　　　　　1，必须显示指定每一个类型参数；

2，类模板特化与重定义有区别吗？函数模板可以特化吗？

1，有区别；

3，特化的深度分析：

1，重定义和特化的不同：

　1，重定义：

　　1，一个类模板和一个新类（或者两个类模板）；

　　　　1，重定义本质是要么是实现了两个类模板，要么是一个类模板加上 一个新的类；

　　　　2，特化本质是只实现同一个类模板，特化的目的仅仅是考虑一些特殊的情况类模板应该如何工作；

　　 2，使用的时候需要考虑如何选择的问题；

　　　　1，使用的时候没有统一的方式，要选择用类模板的种类或用新的类；

　2，特化：

　　1，以统一的方式使用类模板和特化类；

　　2，编译器自动优先选择特化类；

　　　　1，能用特化就不要重定义；

2，函数模板只支持类型参数完全特化：

　1，代码示例：

 template < typename T>  // 函数模板定义
 bool Equal(T a, T b)
 {
     return a == b;
 }

 template < >  // 函数模板完全特化
 bool Equal<void *>(void* a, void* b)
 {
     return a == b;
 }

3，特化的深入理解编程实验：

 #include <iostream>
 #include <string>

 using namespace std;

 /* 以下是类模板的重定义实现 */
 template
 < typename T1, typename T2 >
 class Test
 {
 public:
     void add(T1 a, T2 b)
     {
         cout << "void add(T1 a, T2 b)" << endl;
         cout << a + b << endl;
     }
 };

 /*
 template
 <  >
 class Test < void*, void* >    // 当 T1 == void* 并且 T2 == void* 时
 {
 public:
     void add(void* a, void* b)
     {
         cout << "void add(void* a, void* b)" << endl;
         cout << "Error to add void* param..." << endl;
     }
 };
 */

 /* 类模板的重定义，重新实现上面注释的模板特化，处理指针相加 */
 class Test_Void
 {
 public:
     void add(void* a, void* b)
     {
         cout << "void add(void* a, void* b)" << endl;
         cout << "Error to add void* param..." << endl;
     }
 };

 /* 以下是函数模板的特化实验 */ 

 template
 < typename T >
 bool Equal(T a, T b)
 {
     cout << "bool Equal(T a, T b)" << endl;

     return a == b;
 }

 /* 函数完全特化解决浮点数比较问题 */
 template
 < >
 bool Equal<double>(double a, double b)
 {
     const double delta = 0.00000000000001;
     double r = a - b;

     cout << "bool Equal<double>(double a, double b)" << endl;

     return (-delta < r) && (r < delta);
 }

 /* 直接重载 */
 bool Equal(double a, double b)
 {
     const double delta = 0.00000000000001;
     double r = a - b;

     cout << "bool Equal(double a, double b)" << endl;

     return (-delta < r) && (r < delta);
 }

 int main()
 {
     Test<void*, void*> t3;  // 这里错误了，要用 Test_Void t3; 这样的 定义方式，因为重定义了类的实现方式，注销了模板特化方式；写代码时，要时刻考虑究竟是要使用类模板 还是要使用新类，这就是弊端，所以能特化时，就不要重新定义、重新实现；

     cout << Equal( ,  ) << endl;  // bool Equal(T a, T b) 1
     cout << Equal<>( 0.001, 0.001 ) << endl;  // 用相等符号比较两个浮点数是否相等是有问题的；用了特化后：bool Equal<double>(double a, double b) 1
     cout << Equal( 0.001, 0.001 ) << endl;  // bool Equal(double a, double b) 1；这里调用全局重载函数，因为编译器会优先寻找全局重载函数；

     return ;
 }

4，工程中的建议：

　　1，当需要重载函数模板时，优先考虑使用模板特化；当模板特化无法满足需求，再使用函数重载！

4，小结：

1，类模板可以定义任意多个不同的类型参数；

2，类模板可以被部分特化和完全特化；

3，特化的本质是模板的分开实现；

4，函数模板只支持完全特化；

5，工程中使用模板特化代替类（函数）重定义；