【C++深度解析】4四、类模板深度剖析--模板特化

文章目录

• • 1 多参数类模板
  • 2 类模板特化
  • 3 函数模板特化
  • 4 小结

1 多参数类模板

• 类模板能够定义任意多不一样的类型参数

2 类模板特化

类模板能够被特化

• 指定类模板的特定实现
• 部分类型参数必须显示指定
• 根据类型参数分开实现类模板
• 编译器自动择优选择

类模板特化能够分为部分特化和彻底特化两种类型

• 部分特化–>用特定规则约束类型参数
• 彻底特化–>彻底显示指定类型参数

编程实验：类模板特化

// 44-1.cpp
#include<iostream>
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;
    Test<void*, void*>t3;

    t1.add(1, 2.5);
    t2.add(5, 5);
    t2.print();

    t3.add(NULL, NULL);

    Test<int*, double*>t4;
    int a = 1;
    double b = 0.1;
    t4.add(&a, &b);
    return 0;
}

• 上面的代码先定义了一个模板类，而后给出了三个特化实现。特化本质上是同一个类模板。编译器老是选择最匹配的进行实现。
• t1.add(1, 2.5); 调用 class Test
• t2.add(5, 5); 调用 class Test<T, T>
• t3.add(NULL, NULL); 调用 class Test<void*, void*>
• t4.add(&a, &b); 调用 class Test<T1*, T2*>

$ g++ 44-1.cpp -o 44-1
$ ./44-1
void add(T1 a, T2 b)
3.5
void add(T a, T b)
10
class Test<T, T>
void add(void* a, void* b)
Error to add void* param...
void add(T1* a, T2* b)
1.1

注意事项：

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

3 函数模板特化

函数模板只支持类型参数彻底特化

编程实验：函数模板特化

// 44-2.cpp
#include<iostream>
using namespace std;
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.01, 0.01) << endl;		// 指定使用模板
    cout << Equal(0.1, 0.1) << endl;
    return 0;
}

• bool Equal(T a, T b) 是函数模板，两个浮点数比较不能直接使用 ‘==’，因此实现函数模板特化 bool Equal(double a, double b)，函数模板只能彻底特化。两者本质上属于同一模板，只是分开实现
• bool Equal(double a, double b) 是函数重载。
• 编译器自动择优选择
• Equal(1, 1) 将选择模板 bool Equal(T a, T b)
• Equal<>(0.01, 0.01) 使用模板 bool Equal<double>(double a, double b)
• Equal(0.1, 0.1) 使用重载函数 bool Equal(double a, double b)，

编译运行

$ g++ 44-2.cpp -o 44-2
$ ./44-2
bool Equal(T a, T b)
1
bool Equal<double>(double a, double b)
1
bool Equal(double a, double b)
1

建议：就当须要重载函数模板时，优先考虑使用模板特化，当模板特化没法知足要求时，再使用函数模板。

4 小结

一、类模板能够定义任意多个不一样的类型参数
二、类模板能够部分特化和彻底特化，特化本质上是模板的分开实现
三、函数模板只支持彻底特化