59、类模板深度剖析

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

template<typename T1,tpyename T2>

class Test

{

    public:

    void add(T1 a,T2 b);

};

使用==> Test<int, float>t;

类模板可以被特化：指定类模板的特定实现，部分类型参数必须显示指定，根据类型参数分开实现类模板。

template <typeneme 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 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
< 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;
    }
};


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; //class Test < T, T >
    Test<void*, void*> t3;
    
    t1.add(1, 2.5);  //3.5
    
    t2.add(5, 5);
    t2.print();    //"class Test < T, T >" 
    
    t3.add(NULL, NULL);
    
    Test<int*, double*> t4;
    int a = 1;
    double b = 0.1;
    
    t4.add(&a, &b);  
    
    return 0;

}

将一个类模板分开成不同的情况来实现，三种情况:当t1=t2时，当是指针时，当是void* 时。

类模板特化注意事项：特化只是模板的分开实现：本质上是同一个类模板。

特化类模板的使用方式是统一的：必须显示指定每一个类型参数。

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

重定义和特化的不同：重定义：一个类模板和一个新类（或者两个类模板），使用的时候需要考虑如何选择的问题。

特化：以统一的方式使用类模板和特化类，编译器自动优先选择特化类。能做特化的时候不要用重定义。

函数模板只支持类型参数完全特化。

template<typename T>  //函数模板定义

bool Equal(T a,T b)

{

    return a==b;

}

tempate <>   //函数模板完全特化

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;   //优先选择函数重载，调用bool Equal(double a, double b)   //重载

    cout << Equal<>( 0.001, 0.001 ) << endl;  //<>表示用模板函数
    
    return 0;
}

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

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