目录
一、非类型模板参数
二、模板的特化
1、函数模板特化
2、类模板特化
全特化
偏特化
3、例题
三、模板分离编译
1、定义
2、解决方法
3、模板总结
一、非类型模板参数
- 模板参数分类类型形参与非类型形参。
- 类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
- 非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
- 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
- 非类型的模板参数必须在编译期就能确认结果。
template<class T, int N = 20>
class Array
{
public:private:T _a[N];
};
int main()
{Array<int, 10> a;Array<int, 15> b;return 0;
}
二、模板的特化
1、函数模板特化
使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门小于比较的函数模板。
template<class T>
bool Less(T left, T right)
{return left < right;
}int main()
{cout << Less(1, 2) << endl; // 可以比较，结果正确Date d1(2022, 7, 7);Date d2(2022, 7, 8);cout << Less(d1, d2) << endl; // 可以比较，结果正确Date* p1 = &d1;Date* p2 = &d2;cout << Less(p1, p2) << endl; // 可以比较，结果错误int* p3 = new int(1);int* p4 = new int(2);cout << Less(p3, p4) << endl; // 可以比较return 0;
}Less 函数是一个通用的模板函数，用于比较两个值的大小。大多数情况下，它可以正常比较并返回正确的结果。然而，在特殊情况下，比如比较指针类型时，Less 函数的行为可能会出现错误。
为了解决这个问题，可以对模板进行特化。模板特化是在原模板的基础上，针对特定类型进行特殊化的实现方式。在这种情况下，可以对 Less 函数进行特化，以处理指针类型的比较。
通过对 Less 函数进行特化，当比较指针类型时，会比较指针所指向的对象的内容，而不是指针的地址。这样就可以得到正确的比较结果。
函数模板的特化步骤：
- 必须要先有一个基础的函数模板
- 关键字template后面接一对空的尖括号<>
- 函数名后跟一对尖括号，尖括号中指定需要特化的类型
- 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
template<>
bool Less<Date*>(Date* left, Date* right)
{return *left < *right;
}template<class T>
bool Less(T* left, T* right)
{return *left < *right;
}这两个代码片段都是对 Less 函数进行特化，用于处理指针类型的比较。它们的区别在于特化的方式和适用范围。
-
template<> bool Less<Date*>(Date* left, Date* right) { ... }： 这是一个显式的全特化，针对Less函数的模板参数为Date*的情况进行特化。它指定了具体的类型Date*，并提供了特化的实现。这个特化只适用于Date*类型的指针比较。 -
template<class T> bool Less(T* left, T* right) { ... }： 这是一个偏特化的部分特化，针对Less函数的模板参数为指针类型的情况进行特化。它使用了模板参数T，表示任意类型的指针。这个特化适用于所有类型的指针比较。
总结来说，全特化是对特定类型进行特化，而部分特化是对一类类型进行特化。在给定的示例中，全特化 Less<Date*> 专门处理 Date* 类型的指针比较，而部分特化 Less<T*> 适用于所有类型的指针比较。选择使用哪种特化方式取决于具体的需求和使用场景。
注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。bool Less(Date* left, Date* right) {return *left < *right; }
- 该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时特别给出，因此函数模板不建议特化。
2、类模板特化
全特化
全特化即是将模板参数列表中所有的参数都确定化。
#include <iostream>template<class T1, class T2>
class Data
{
public:Data() { std::cout << "Data<T1, T2>" << std::endl; }
private:T1 _d1;T2 _d2;
};template<>
class Data<int, char>
{
public:Data() { std::cout << "Data<int, char>" << std::endl; }
private:int _d1;char _d2;
};void TestVector()
{Data<int, int> d1;Data<int, char> d2;
}int main()
{TestVector();return 0;
}偏特化
任何针对模版参数进一步进行条件限制设计的特化版本。
// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:Data() { cout << "Data<T1, int>" << endl; }
private:T1 _d1;int _d2;
};#include <iostream>template <class T1, class T2>
class Data<T1*, T2*>
{
public:Data() { std::cout << "Data<T1*, T2*>" << std::endl; }private:T1* _d1;T2* _d2;
};template <class T1, class T2>
class Data<T1&, T2&>
{
public:Data(const T1& d1, const T2& d2): _d1(d1), _d2(d2){std::cout << "Data<T1&, T2&>" << std::endl;}private:const T1& _d1;const T2& _d2;
};void test2()
{Data<double, int> d1; // 调用基础的模板Data<int, double> d2; // 调用基础的模板Data<int*, int*> d3; // 调用特化的指针版本Data<int&, int&> d4(1, 2); // 调用特化的引用版本
}int main()
{test2();return 0;
}- 在这个示例中，定义了一个模板类
Data，它有两个模板参数T1和T2。通过对Data类进行偏特化，针对特定的模板参数类型进行特殊化的实现。 - 首先，对
Data<T1*, T2*>进行偏特化，用于处理指针类型的模板参数。在特化版本中，输出 "Data<T1*, T2*>"。 - 然后，对
Data<T1&, T2&>进行偏特化，用于处理引用类型的模板参数。在特化版本中，输出 "Data<T1&, T2&>"。 - 在
test2函数中，创建了不同类型的Data对象，包括基础的模板实例化和特化版本的实例化。根据不同的模板参数类型，会调用相应的模板实现或特化版本的实现。 - 这样，通过模板的偏特化，可以针对特定的模板参数类型提供不同的实现，以满足特定的需求。
3、例题
#include <iostream>
using namespace std;template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};template <class T1>
class Data<T1, int>
{
public:Data() { cout << "Data<T1, int>" << endl; }
private:T1 _d1;int _d2;
};template <typename T1, typename T2>
class Data <T1*,T2*>
{
public:Data() { cout << "Data<T1*, T2*>" << endl; }
private:T1 _d1;T2 _d2;
};template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:Data(const T1& d1, const T2& d2): _d1(d1), _d2(d2){cout << "Data<T1&, T2&>" << endl;}
private:const T1 & _d1;const T2 & _d2;
};int main()
{Data<double, int> d1; Data<int, double> d2; Data<int *, int*> d3; Data<int&, int&> d4(1, 2);return 0;
}以下程序运行结果正确的是( )
A.Data<T1, T2> Data<T1, int> Data<T1*, T2*> Data<T1&, T2&>
B.Data<T1, int> Data<T1, T2> Data<T1&, T2&> Data<T1*, T2*>
C.Data<T1, int> Data<T1, T2> Data<T1*, T2*> Data<T1&, T2&>
D.Data<T1, T2> Data<T1, T2> Data<T1*, T2*> Data<T1&, T2&>
分析:
Data<double, int> d1; // 调用特化的int版本
Data<int, double> d2; // 调用基础的模板
Data<int *, int*> d3; // 调用特化的指针版本
Data<int&, int&> d4(1, 2); //调用特化的引用版本
故答案为: C
#include <iostream>
using namespace std;template<typename Type>
Type Max(const Type &a, const Type &b)
{cout<<"This is Max<Type>"<<endl;return a > b ? a : b;
}template<>
int Max<int>(const int &a, const int &b)
{cout<<"This is Max<int>"<<endl;return a > b ? a : b;
}template<>
char Max<char>(const char &a, const char &b)
{cout<<"This is Max<char>"<<endl;return a > b ? a : b;
}int Max(const int &a, const int &b)
{cout<<"This is Max"<<endl;return a > b ? a : b;
} int main()
{Max(10,20);Max(12.34,23.45);Max('A','B');Max<int>(20,30);return 0;
}以下程序运行结果正确的是( )
A.This is Max This is Max<Type> This is Max<char> This is Max<int>
B.This is Max<int> This is Max<Type> This is Max<char> This is Max<int>
C.This is Max This is Max<int> This is Max<char> This is Max<int>
D.This is Max This is Max<Type> This is Max<char> This is Max
分析:
在调用Max函数时，编译器会优先选择非模板函数。如果没有找到合适的非模板函数，编译器会再去查找模板函数。
Max(10,20); //能够直接匹配int参数，调动非模板函数
Max(12.34,23.45); //double类型参数没有最佳匹配函数，此时只能调动模板函数
Max('A','B'); //能够直接匹配char参数,调动非模板函数
Max<int>(20,30); //由于直接实例化了函数，因此要调动模板函数，但是，由于进行函数的int特化，所以会调用特化版本的模板函数
故答案为: A
三、模板分离编译
1、定义
一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。
// a.h
template<class T>
T Add(const T& left, const T& right);// a.cpp
template<class T>
T Add(const T & left, const T & right)
{return left + right;
}// main.cpp
#include "a.h"
int main()
{Add(1, 2);Add(1.0, 2.0);return 0;
}
- 在给定的示例中，模板函数 Add 的声明和定义被分离到了不同的文件中。Add 函数的声明位于头文件 "a.h" 中，而定义位于源文件 "a.cpp" 中。
- 然后，在主文件 "main.cpp" 中，通过包含 "a.h" 头文件来使用 Add 函数。 然而，这样的分离编译方式会导致编译错误。这是因为模板的实例化需要在编译时进行，而编译器在编译 "main.cpp" 时无法看到 "a.cpp" 中的模板定义，这是因为在C++中，模板的实例化是在编译时进行的。当编译器编译一个源文件时，它只能看到当前源文件中的代码以及通过包含的头文件中的代码。编译器无法直接访问其他源文件中的代码。
- 在给定的示例中，"main.cpp" 文件包含了 "a.h" 头文件，其中包含了模板函数 `Add` 的声明。编译器可以看到这个声明，并知道 `Add` 是一个模板函数，但它无法看到模板函数的具体定义，因为定义位于另一个源文件 "a.cpp" 中。
- 因此，当编译器在编译 "main.cpp" 时，它无法为 `Add` 函数生成特定类型的实例化代码，因为它没有模板定义的上下文。因此，编译器无法为 Add 函数生成特定类型的实例化代码。
2、解决方法
template<class T>
T Add(const T& left, const T& right);template<class T>
T Add(const T& left, const T& right)
{return left + right;
}2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。
template
double Add<double>(const double& left, const double& right);template
int Add<int>(const int& left, const int& right);3、模板总结
- 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。
- 增强了代码的灵活性。
- 模板会导致代码膨胀问题，也会导致编译时间变长。
- 出现模板编译错误时，错误信息非常凌乱，不易定位错误。
