59_类模板深度剖析

关键词：多参数类模板、类模板的特化

1. 多参数类模板

• 类模板可以定义任意多个不同的类型参数
  语法规则：

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

• 类模板可以被特化
  (1) 指定类模板的特定实现
  (2) 部分类型参数必须显示指定
  (3) 根据类型参数分开实现类模板

• 类模板的特化类型

  • 部分特化：用特定规则约束类型参数

  • 完全特化：完全显示指定类型参数

    
    
    

    部分特化
    
    
    

    完全特化

编程说明：类模板的特化

#include 
#include 

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 = " << 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 = " << *a + *b << endl;
    }
};

template    
< typename T >              // 部分特化
class Test < T, T >         // Test类模板的特化（特殊实现）： 当Test 类模板的两个类型参数完全相同时，使用这个实现
{
public:
    void add(T a, T b)
    {
        cout << "void add(T a, T b)" << endl;
        cout << "a + b = " << 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 t1;
    
    t1.add(1, 2.5);
    cout << endl;
    
    Test t2;
    
    t2.add(1, 2);
    t2.print();
    cout << endl;
    
    Test t3;
        
    t3.add(NULL, NULL);
    cout << endl;
    
    Test t4;
    
    int a = 1;
    double b = 0.1;
    
    t4.add(&a, &b);

    return 0;
}

输出结果

void add(T1 a, T2 b)
a + b = 3.5

void add(T a, T b)
a + b = 3
class Test < T, T >

void add(void* a, void* b)
Error to add void* param... 

void add(T1* a, T2* b)
*a + *b = 1.1

类模板特化注意事项

• 特化只是模板的分开实现，本质上还是同一个类模板
• 特化类模板的使用方式是统一的，必须显示指定每一个类型参数

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

• 重定义：
  结果：一个类模板和一个新类或者是两个类模板
  使用时：需要考虑如何选择使用哪一个的问题
• 特化：
  结果：以统一的方式使用类模板和特化类
  使用时：编译器自动优先选择特化类

编程说明：重定义与特化

#include 
#include 

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 = " << a + b << endl;
    }
};

class Test_Void
{
public:
    void add(void* a, void* b)      // 重定义
    {
        cout << "Test_Void::void add(void* a, void* b)" << endl;
        cout << "Error to add void* param..." << endl;
    }
};

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

int main()
{
    Test_Void t1;   
    Test t2;
    double a = 1.2;
    int b = 1;
    void* m = &a;
    void* n = &b;
    
    t1.add(m, n);
    cout << endl;
    
    t2.add(m, n);

    return 0;
}

输出结果

Test_Void::void add(void* a, void* b)
Error to add void* param...

Test< void*, void* >::void add(T1 a, T2 b)
Error to add void* param...

总结：能用特化时优先考虑使用特化，而不是重定义

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

编程说明：函数模板的完全特化

#include 
#include 

using namespace std;

template 

bool Equal(T a, T b)
{
    cout << "bool Equal(T a, T b)" << endl;
    return a = b;
}

template                        //  函数模板的完全特化
< >
bool Equal(double a, double b)  
{
    cout << "bool Equal(double a, double b)" << endl;
    double delta = 0.00000000000001;
    double r = a - b;
    
    return (-delta < r) && (r < delta);
}

int main()
{
    cout << Equal(1, 1) << endl;
    cout << Equal(0.001, 0.001) << endl;

    return 0;
}

输出结果

bool Equal(T a, T b)
1
bool Equal(double a, double b)
1

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

3. 小结

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