【C++模板】——C++模板的力气：构建灵活与安全的代码 ...

在C++中，模板参数可以分为两大类： 范例模板参数（type template parameters）和非范例模板参数（non-type template parameters）。这两种模板参数允许我们界说更为灵活和通用的模板代码。下面对它们分别进行介绍。
1. 范例模板参数

范例模板参数用于表现一个范例，通常用typename或class关键字来声明。例如，假设我们要实现一个通用的容器类，这个类可以存储任意范例的数据，我们可以使用范例模板参数：

1. template <typename T>
2. class MyContainer {
3. public:
4.     void add(const T& element);
5.     // 其他成员函数...
6. };

复制代码

在上面的例子中，T是一个范例模板参数。编译器在实例化模板时，会将T替换为详细的范例，例如int、double、std::string等。可以使用typename或class来声明范例模板参数，两者在这里是等效的。
使用示例：

1. MyContainer<int> intContainer;    // 使用int类型实例化模板
2. MyContainer<double> doubleContainer; // 使用double类型实例化模板

复制代码

2. 非范例模板参数

非范例模板参数用于表现一个详细的值，而不是一个范例。这个值必须在编译期是已知的，它通常是一个常量。非范例模板参数的范例可以是整型、指针、引用、布尔范例以及std::nullptr_t。
非范例模板参数允许我们根据详细的值来实例化模板。例如，可以用非范例模板参数来表现数组的巨细：

1. template <typename T, int Size>
2. class MyArray {
3. private:
4.     T data[Size];
5. public:
6.     T& operator[](int index) { return data[index]; }
7.     // 其他成员函数...
8. };

复制代码

在这个例子中，Size是一个非范例模板参数，表现数组的巨细，它是一个int范例的常量。编译器在实例化模板时，会将Size替换为详细的值，例如10、20等。
使用示例：

1. MyArray<int, 10> intArray;    // 使用大小为10的数组
2. MyArray<double, 20> doubleArray; // 使用大小为20的数组

复制代码

非范例模板参数的范例限制
非范例模板参数可以接受以下几种范例：
整型值：如int、unsigned int、char等。
指针或引用：指向对象或函数的指针或引用。
罗列值：如enum中的值。
布尔值：true或false。
std::nullptr_t：表现空指针值（nullptr）。
自从C++20起，非范例模板参数的范例限制有所放宽，可以使用浮点数和类范例的常量表达式。
范例模板参数与非范例模板参数的组合
范例模板参数和非范例模板参数可以组合使用。例如：

1. template <typename T, int Rows, int Cols>
2. class Matrix {
3. private:
4.     T data[Rows][Cols];
5. public:
6.     T& at(int row, int col) { return data[row][col]; }
7.     // 其他成员函数...
8. };

复制代码

在这个Matrix类模板中，T是范例模板参数，而Rows和Cols是非范例模板参数，分别表现矩阵的行数和列数。
使用示例：

1. Matrix<int, 3, 3> matrix;  // 3x3的整型矩阵
2. Matrix<double, 4, 5> matrix2; // 4x5的双精度矩阵

复制代码

总结
   范例模板参数：用于表现一个范例，使用typename或class关键字界说。
非范例模板参数：用于表现一个编译期已知的常量值，可以是整型、布尔值、指针等。
通过范例模板参数和非范例模板参数的结合，我们可以编写出更灵活和强大的模板代码。
  3.模板的特化

1. 概念

模板特化是指为特定的模板参数提供自界说的实现。它允许开发者为某些范例或特定值的情况界说差别的行为，重要分为以下两种：
全特化（Full Specialization）：针对某个详细范例提供完全的实现。
部分特化（Partial Specialization）：针对模板参数的一部分进行定制。
2. 函数模板特化

函数模板的特化步骤：

• 必须要先有一个基础的函数模板
  
• 关键字template后面接一对空的尖括号<>
  
• 函数名后跟一对尖括号，尖括号中指定必要特化的范例
  
• 函数形参表: 必须要和模板函数的基础参数范例完全相同，如果差别编译器大概会报一些奇
  怪的错误。
  

全特化
全特化是为某个详细范例提供一个特定实现。下面是一个例子：

1. #include <iostream>
3. template <typename T>
4. void process(T value) {
5.     std::cout << "Processing generic type: " << value << std::endl;
6. }
8. // 全特化：当T是int类型时的实现
9. template <>
10. void process<int>(int value) {
11.     std::cout << "Processing integer: " << value << std::endl;
12. }
14. int main() {
15.     process(5);       // 调用全特化版本
16.     process(3.14);    // 调用默认版本
17.     return 0;
18. }

复制代码

在上面的代码中，process函数模板的默认实现适用于全部范例，但对于int范例，提供了一个特定的实现。
部分特化
部分特化是针对参数的一部分进行特定实现。例如：

1. #include <iostream>
3. template <typename T>
4. void display(T value) {
5.     std::cout << "Displaying: " << value << std::endl;
6. }
8. // 部分特化：当参数是指针类型时
9. template <typename T>
10. void display(T* value) {
11.     std::cout << "Displaying pointer: " << *value << std::endl;
12. }
14. int main() {
15.     int x = 10;
16.     display(x);      // 调用默认版本
17.     display(&x);     // 调用部分特化版本
18.     return 0;
19. }

复制代码

在这个例子中，display函数模板有一个默认实现，但当传入指针范例时，使用了部分特化的实现。
3. 类模板特化

全特化
类模板的全特化与函数模板类似，提供一个特定范例的实现。

1. #include <iostream>
3. template <typename T>
4. class MyContainer {
5. public:
6.     void info() {
7.         std::cout << "Generic container" << std::endl;
8.     }
9. };
11. // 全特化：针对int类型
12. template <>
13. class MyContainer<int> {
14. public:
15.     void info() {
16.         std::cout << "Container for integers" << std::endl;
17.     }
18. };
20. int main() {
21.     MyContainer<double> container1;
22.     container1.info();  // 输出 "Generic container"
24.     MyContainer<int> container2;
25.     container2.info();  // 输出 "Container for integers"
26.     return 0;
27. }

复制代码

在这个示例中，MyContainer的默认实现适用于全部范例，但对于int范例，提供了一个特定的实现。
部分特化
部分特化允许我们为模板参数的某些组合提供特定实现。例如：

1. #include <iostream>
3. template <typename T, typename U>
4. class Pair {
5. public:
6.     T first;
7.     U second;
8. };
10. // 部分特化：当第一个类型是指针时
11. template <typename U>
12. class Pair<int*, U> {
13. public:
14.     int* first;
15.     U second;
16.     void show() {
17.         std::cout << "First is a pointer to int" << std::endl;
18.     }
19. };
21. int main() {
22.     Pair<double, char> p1;      // 使用默认模板
23.     Pair<int*, char> p2;        // 使用部分特化
25.     p2.show();                   // 输出 "First is a pointer to int"
26.     return 0;
27. }

复制代码

在这个例子中，Pair类模板的默认实现适用于全部范例，但对于第一个范例为int*的情况，提供了一个特定实现。
4.补充

偏特化和部分特化是同一个概念的差别称呼。在C++中，偏特化（partial specialization）通常用于形貌类模板或结构模板中仅对某些模板参数进行特化的情况。可以理解为，它允许我们为特定参数范例或范例组合提供差别的实现，而无需完全指定全部模板参数。
术语表明：
偏特化（Partial Specialization）：特指类模板或结构模板在未指定全部参数的情况下，为某些特定范例或范例组合提供定制实现。
5.模板编译分离

模板编译分离（Template Compilation Separation）是C++中处理惩罚模板界说和实现的一种技术，重要用于管理大规模代码库中的模板代码，以减少编译时间和提高代码的可维护性。
配景
在C++中，模板是在编译时生成的，这意味着编译器必要看到模板的完整界说才气生成实例化代码。如果模板的实现与其声明分离（即，声明在头文件中，界说在源文件中），会导致编译错误，由于编译器在实例化模板时无法找到其界说。
解决方案

为了实现模板编译分离，通常有几种常见的做法：

• 将全部代码放在头文件中：这是最简单的方式，全部模板的声明和界说都放在同一个头文件中。这种方式不支持严酷的编译分离，但适用于小型项目。
  

1. // MyTemplate.h
2. #ifndef MYTEMPLATE_H
3. #define MYTEMPLATE_H
5. template <typename T>
6. class MyTemplate {
7. public:
8.     void func(T value) {
9.         // 实现
10.     }
11. };
13. #endif // MYTEMPLATE_H

复制代码

• 使用包罗文件的方式：将模板的实现放在头文件的底部，大概单独的实现文件中，然后在头文件中包罗。
  

1. // MyTemplate.h
2. #ifndef MYTEMPLATE_H
3. #define MYTEMPLATE_H
5. template <typename T>
6. class MyTemplate {
7. public:
8.     void func(T value);
9. };
11. #include "MyTemplate_impl.h" // 包含实现文件
13. #endif // MYTEMPLATE_H

复制代码

1. // MyTemplate_impl.h
2. #ifndef MYTEMPLATE_IMPL_H
3. #define MYTEMPLATE_IMPL_H
5. template <typename T>
6. void MyTemplate<T>::func(T value) {
7.     // 实现
8. }
10. #endif // MYTEMPLATE_IMPL_H

复制代码

1. // MyTemplate_impl.h
2. #ifndef MYTEMPLATE_IMPL_H
3. #define MYTEMPLATE_IMPL_H
5. template <typename T>
6. void MyTemplate<T>::func(T value) {
7.     // 实现
8. }
10. #endif // MYTEMPLATE_IMPL_H

复制代码

• 显式实例化：如果知道将来会使用某些特定范例，可以显式实例化模板。将模板的实现放在源文件中，并在必要的地方显式实例化。
  

1. // MyTemplate.h
2. #ifndef MYTEMPLATE_H
3. #define MYTEMPLATE_H
5. template <typename T>
6. class MyTemplate {
7. public:
8.     void func(T value);
9. };
11. #endif // MYTEMPLATE_H

复制代码

1. // MyTemplate.cpp
2. #include "MyTemplate.h"
4. template <typename T>
5. void MyTemplate<T>::func(T value) {
6.     // 实现
7. }
9. // 显式实例化
10. template class MyTemplate<int>;   // 针对int类型的实例化
11. template class MyTemplate<double>; // 针对double类型的实例化

复制代码

优点与缺点

优点
降低编译时间：通过公道的编译分离，可以减少因模板变化而导致的整个项目的重新编译。
提高代码可维护性：将实现与接口分离，使代码更加模块化，易于管理。
缺点
复杂性增长：必要管理多个文件，大概导致开发和维护的复杂性增长。
错误大概性：包罗和实例化不妥大概导致编译错误，尤其是未显式实例化的情况下。
总结
模板编译分离是处理惩罚C++模板代码的重要策略，通过公道构造模板的声明和界说，可以有效管理大型代码库，降低编译时间，并提高代码的可维护性。在实践中，选择符合的策略取决于项目的规模和复杂性。如果有更多问题或详细的代码示例必要表明，接待继承询问！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。