你不能改变过去，但你可以改变未来
算法/C++/数据结构/C
Hello，这里是小枫。C语言与数据结构和算法初阶两个板块都更新完毕，我们继续来学习C++的内容呀。C++是接近底层有比较经典的语言，因此学习起来注定枯燥无味，西游记大家都看过吧~，我希望能带着大家一起跨过九九八十一难，降伏各类难题，学会C++，我会尽我所能，以通俗易懂、幽默风趣的方式带给大家形象生动的知识，也希望大家遇到困难不退缩，遇到难题不放弃，学习师徒四人的精神！！！故此得名【C++游记】
话不多说，让我们一起进入今天的学习吧~~~
一、非类型模板参数：用编译期常量定制模板
模板参数分为"类型形参"和"非类型形参"两种。类型形参我们比较熟悉，就是用class或typename声明的未知类型（如template<class T>中的T）；而非类型形参则是用一个常量作为模板参数，这是一种非常实用但容易被忽略的特性。
1.1 非类型模板参数的本质与用法
非类型模板参数的核心价值在于：它允许我们在实例化模板时，通过指定常量值来生成不同规格的代码版本，而无需修改模板本身的实现。这种特性非常适合用于创建固定大小的容器，例如C++11标准库中的std::array就大量使用了非类型模板参数。
下面是一个自定义array类的示例，展示了非类型模板参数的基本用法：
// T：类型形参（数组元素类型）；N：非类型形参（数组大小，默认值10）
template<class T, size_t N = 10>
class array {
public:
T& operator[](size_t index) { return _array[index]; }
const T& operator[](size_t index) const { return _array[index]; }
size_t size() const { return N; } // 直接用N作为常量，无需额外存储
private:
T _array[N]; // 用非类型参数N定义数组大小，编译期确定内存
};使用时，我们可以这样实例化不同大小的数组：
// 定义一个大小为20的int数组
array<int, 20> arr1;
// 使用默认大小10的double数组
array<double> arr2;
cout << arr1.size() << endl; // 输出20
cout << arr2.size() << endl; // 输出10这种方式的优势在于：数组大小在编译期就已确定，编译器可以进行更严格的检查和优化，同时避免了动态内存分配的开销。
1.2 非类型模板参数的限制
注意：非类型模板参数并非支持所有类型的常量，它有明确的语法限制，违反这些限制会导致编译错误。
- 不支持的类型：浮点数（如double、float）、类对象和字符串不能作为非类型参数。例如下面的写法是错误的：
这是因为浮点数在编译期可能存在精度问题，编译器无法保证其值的唯一性。// 错误示例：浮点数不能作为非类型模板参数 template<class T, double PI> class Circle { // ... }; - 必须是编译期常量：非类型参数的值必须在编译阶段就能确定，不能使用运行时才能确定的变量。例如：
这里的n虽然被初始化为10，但它是一个变量，其值在运行时可能被修改，因此不能作为非类型模板参数。int n = 10; // 错误示例：n是运行时变量，不能作为非类型参数 array<int, n> arr;
二、模板特化：解决"通用模板不通用"的问题
通用模板的设计理念是"与类型无关"，但在实际开发中，我们经常会遇到一些特殊类型，它们无法直接使用通用模板的逻辑而得到正确结果。例如，当我们用模板比较两个指针时，默认比较的是指针的地址，而不是指针所指向的内容，这时候就需要使用模板特化来解决。
2.1 为什么需要特化？一个典型反例
假设我们有一个比较两个值大小的函数模板Less，当用于比较指针类型时会出现问题：
// 通用函数模板：比较两个值的大小
template<class T>
bool Less(T left, T right) {
return left < right; // 通用逻辑：直接比较值
}
int main() {
Date d1(2022, 7, 7), d2(2022, 7, 8);
Date* p1 = &d1; // p1指向"较小的日期"
Date* p2 = &d2; // p2指向"较大的日期"
cout << Less(d1, d2) << endl; // 正确：比较Date对象，输出1（true）
cout << Less(p1, p2) << endl; // 错误：比较指针地址，结果不确定
return 0;
}上述代码中，Less(d1, d2)能够正确比较两个日期对象的大小，但Less(p1, p2)比较的是两个指针的地址，这通常不是我们想要的结果。我们真正需要的是比较指针所指向的Date对象的大小，这时候就需要对Date*类型进行模板特化。
2.2 函数模板特化：为特殊类型定制逻辑
函数模板特化的本质是：在通用模板的基础上，为某一特定类型单独编写一个函数实现。它需要遵循严格的语法规则，否则可能导致编译错误或不符合预期的行为。
2.2.1 函数模板特化的步骤
- 必须先定义一个基础函数模板（不能直接特化一个不存在的模板）；
- 使用template<>标识这是一个特化版本（空尖括号表示所有模板参数都已确定）；
- 在函数名后添加<特化类型>，明确指定为哪种类型进行特化；
- 函数的形参列表必须与基础模板完全一致（否则编译器会将其视为重载函数而非特化版本）。
2.2.2 实战：特化Less模板处理Date*类型
按照上述步骤，我们可以为Date*类型特化Less模板：
// 1. 基础函数模板（必须先定义）
template<class T>
bool Less(T left, T right) {
return left < right;
}
// 2. 特化Less模板，处理Date*类型
template<> // 空尖括号：特化标识
bool Less<Date*>(Date* left, Date* right) { // 明确特化类型为Date*
return *left < *right; // 定制逻辑：比较指针指向的Date对象
}
int main() {
Date d1(2022, 7, 7), d2(2022, 7, 8);
Date* p1 = &d1;
Date* p2 = &d2;
cout << Less(p1, p2) << endl; // 调用特化版本，正确输出1
return 0;
}特化后，当我们调用Less(p1, p2)时，编译器会优先使用特化版本，从而实现比较指针所指向对象的功能。
2.2.3 更简单的替代方案：直接定义普通函数
对于函数模板来说，特化并不是唯一的解决方案。在很多情况下，直接定义一个与特化类型匹配的普通函数会更简单、更易读，也更不容易出错。记住：C++中匹配函数基本都是有现成吃现成。
这是因为普通函数的优先级高于模板函数，当存在匹配的普通函数时，编译器会优先调用普通函数：
// 直接定义普通函数，处理Date*类型
bool Less(Date* left, Date* right) {
return *left < *right;
}
// 调用时直接匹配普通函数，无需特化模板
cout << Less(p1, p2) << endl; // 正确调用普通函数提示：在实际开发中，对于简单的函数模板特化场景，推荐使用普通函数重载的方式，它可以避免特化带来的复杂性和潜在问题。
2.3 类模板特化：比函数特化更常用的场景
与函数模板相比，类模板的特化更为灵活和常用。类模板特化可以分为"全特化"和"偏特化"两种形式，全特化是指为所有模板参数指定具体类型，而偏特化则是对模板参数进行进一步的限制。
2.3.1 全特化：完全确定所有模板参数
全特化是最彻底的特化方式，它将模板参数列表中的所有参数都指定为具体类型。例如，我们可以对Data<T1, T2>类模板进行全特化：
// 1. 基础类模板
template<class T1, class T2>
class Data {
public:
Data() { cout << "Data<T1, T2>" << endl; }
private:
T1 _d1;
T2 _d2;
};
// 2. 全特化：T1=int，T2=char（所有参数确定）
template<> // 空尖括号
class Data<int, char> {
public:
Data() { cout << "Data<int, char>" << endl; } // 定制构造逻辑
private:
int _d1;
char _d2;
};
// 测试：不同实例化调用不同版本
Data<int, int> d1; // 调用基础模板：输出 Data<T1, T2>
Data<int, char> d2; // 调用全特化版本：输出 Data<int, char>当我们实例化Data<int, char>时，编译器会使用全特化的版本，而不是基础模板，这允许我们为特定类型组合提供定制化的实现。
2.3.2 偏特化：对模板参数加"条件限制"
偏特化并不是只特化部分参数，而是对模板参数施加额外的限制条件。它主要有两种形式：部分参数特化和对参数类型进行限制。
形式1：部分参数特化（特化一部分参数，保留另一部分为未知类型）：
// 基础模板
template<class T1, class T2>
class Data {
public:
Data() { cout << "Data<T1, T2>" << endl; }
};
// 偏特化：第二个参数特化为int，第一个参数保留未知
template<class T1>
class Data<T1, int> {
public:
Data() { cout << "Data<T1, int>" << endl; }
};
// 测试
Data<double, int> d1; // 调用偏特化版本：输出 Data<T1, int>
Data<int, double> d2; // 调用基础模板：输出 Data<T1, T2>形式2：参数类型限制（限制参数为指针、引用等类型）：
// 偏特化：两个参数都限制为指针类型
template<class T1, class T2>
class Data<T1*, T2*> {
public:
Data() { cout << "Data<T1*, T2*>" << endl; }
};
// 偏特化：两个参数都限制为引用类型（引用需初始化，需带参构造）
template<class T1, class 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;
};
// 测试
Data<int*, int*> d3; // 调用指针偏特化：输出 Data<T1*, T2*>
Data<int&, int&> d4(1, 2); // 调用引用偏特化：输出 Data<T1&, T2&>偏特化的核心价值在于：它允许我们为具有特定特征的类型组合（如指针类型、引用类型）提供定制化的实现，而不必为每种具体类型都编写全特化版本。
2.3.3 类模板特化实战：让sort正确排序指针数组
C++标准库的sort算法默认使用operator<来比较元素，当排序的是指针数组时，它会比较指针的地址而不是指针指向的内容。通过特化比较器类模板，我们可以让sort按照指针指向的内容进行排序。
#include <vector>
#include <algorithm>
// 基础Less类模板（用于sort的比较规则）
template<class T>
struct Less {
bool operator()(const T& x, const T& y) const {
return x < y; // 通用逻辑：比较值
}
};
// 特化Less类模板，处理Date*类型
template<>
struct Less<Date*> {
bool operator()(Date* x, Date* y) const {
return *x < *y; // 定制逻辑：比较指针指向的Date对象
}
};
int main() {
Date d1(2022, 7, 7), d2(2022, 7, 6), d3(2022, 7, 8);
vector<Date*> v = {&d1, &d2, &d3};
// 用特化的Less<Date*>作为比较规则，按日期升序排序
sort(v.begin(), v.end(), Less<Date*>());
return 0;
}通过特化Less类模板，sort算法会使用我们定制的比较逻辑，从而实现按指针指向的Date对象进行排序的功能。这种技巧在实际开发中非常有用，尤其是在处理各种容器和算法时。
三、总结
模板是C++中一项非常强大的特性，掌握非类型模板参数和模板特化等进阶知识，可以帮助我们编写更加灵活、高效和通用的代码。
非类型模板参数允许我们在编译期通过常量来定制模板的行为，特别适合创建固定大小的容器；而模板特化则解决了通用模板在特殊类型上的适配问题，通过全特化和偏特化，我们可以为特定类型或类型组合提供定制化的实现。
在实际开发中，我们需要根据具体场景灵活运用这些特性，同时也要注意它们的使用限制，编写既高效又易于维护的代码。
四、结语
今日C++到这里就结束啦，如果觉得文章还不错的话，可以三连支持一下。感兴趣的宝子们欢迎持续订阅小枫，小枫在这里谢谢宝子们啦~小枫の主页还有更多生动有趣的文章，欢迎宝子们去点评鸭~C++的学习很陡，时而巨难时而巨简单，希望宝子们和小枫一起坚持下去~你们的三连就是小枫的动力，感谢支持~
