类模板深度剖析

多参数类模板
类模板可以定义任意多个不同的类型参数
template <typename T1, typename T2>
class Test
{
public:
　　void add(T1 a, T2 b);
};

使用上述的类模板：

Test<int ,float> t;

类模板可以被特化:即特殊化
-指定类模板的特定实现
-部分类型参数必须显示指定
-根据类型参数分开实现类模板
template
<typename T1, typename T2>
class Test
{

};

上面的类模板可以被特化为：
template
<typename T>
class Test <T,T>
{

};

类模板的特化类型
-部分特化：适用于特定规则约束类型参数
-完全特化：完全显示指定类型参数
template
<typename T1, typename T2>
class Test
{

};

完全特化为：
template
< >
class Test <int ,int>
{

};

#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 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 << "Test<T ,T> " << 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;
    }


};

//完全特化
template
< >
class Test <void*, void*>
{
public:
    void add(void* a, void* b)
    {
        cout << "void add(void* a, void* b) " << endl;
        cout << "error to add void* parameters" << endl;
    }

};
int main()
{

      Test<int,float> t1;
      Test<long,long> t2;
      Test<void*, void*>t3;
      t1.add(1,1.5);

      t2.add(5,5);
      t2.print();

      t3.add(NULL,NULL);

      Test<int*,double*>t4;
      int a = 2;
      double b = 3;
      t4.add(&a,&b); //它调用的

    return 0;
}

类模板特化注意事项：
-特化只是模板的分开实现
　　本质上是同一个类模板
-特化类模板的使用方式是统一的
　　必须显示指定每一个类型参数

重定义和特化的不同
-重定义
　　一个类模板和一个新类（或者两个类模板）
　　使用的时候需要考虑如何选择的问题
-特化
　　以统一的方式使用类模板和特化类
　　编译器自动优先选择特化类

函数模板只支持类型参数完全特化
template
<typename T> //函数模板定义
bool Equal(T a, T b)
{
　　return a == b;
}

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

特化的深入理解

#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()
{  
    cout << Equal( 1, 1 ) << endl;
    cout << Equal<>( 0.001, 0.001 ) << endl;
    
    return 0;
}

工程中的建议
当需要重载函数模板时，优先考虑使用模板特化
当模板特化无法满足需求，再使用函数重载

小结：

类模板可以定义任意多个不同的类型参数
类模板可以被部分特化和完全特化
特化的本质是模板的分开实现
函数模板只支持完全特化
工程中使用模板特化代替类（函数）重定义