当前位置：首页 > news >正文

【C++】15. 模板进阶

news 来源：原创 2025/6/17 13:28:19

1. 非类型模板参数

模板参数分类类型形参与非类型形参。

类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。

非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常 量来使用。

namespace Ro
{// 定义一个模板类型的静态数组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 _size; }bool empty()const { return 0 == _size; }private:T _array[N];size_t _size;};
}

在这里 N 就是一个非类型模板参数，是一个常量，使用的时候传多大就是多大，不会直接写死大小。

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的，不过在C++20之后可以使用浮点数作为非类型模板参数

2. 非类型的模板参数必须在编译期就能确认结果。

说到array类，那我们就来介绍一下它

说白了就是在底层封装了一个静态数组。但是呢，比静态数组要强一点，但是和vector比又显得很鸡肋

在C++中，静态数组（内置数组）和std::array类（来自STL）都是用于存储固定大小的数据集合，但它们在功能、安全性和用法上有显著区别。以下是详细对比：

1. 类型定义与声明

静态数组（内置数组）：
直接使用原生语法声明，例如：

int arr[5]; // 静态数组，大小为5
int arr2[] = {1, 2, 3}; // 自动推断大小为3

std::array类：
需包含头文件 <array>，并显式指定类型和大小：

#include <array>
std::array<int, 5> arr; // 大小为5的array对象
std::array<int, 3> arr2 = {1, 2, 3};

2. 类型安全性

静态数组：
- 作为函数参数传递时会退化为指针（丢失大小信息），例如：
```
void func(int arr[]); // 实际接受的是指针，无法知道数组大小
```
- 容易因隐式指针转换导致未定义行为。
std::array类：
- 作为对象传递时保留完整类型信息（包括大小），例如：
```
void func(std::array<int, 5>& arr); // 明确知道大小和类型
```
- 类型严格匹配，避免隐式转换错误。

3. 访问元素

静态数组：
- 使用下标 arr[i] 或指针算术直接访问。
- 无越界检查，越界访问可能导致未定义行为。
std::array类：
- 支持下标 arr[i]（不检查越界，性能与原生数组相同）。
- 提供 .at(i) 方法（进行越界检查，越界时抛出 std::out_of_range 异常）。
- 提供便捷的成员函数：front()、back() 等。

4. 成员函数与功能

静态数组：
- 无成员函数，需手动实现常见操作（如复制、比较等）。
- 大小需通过 sizeof(arr)/sizeof(arr[0]) 计算（易出错）。

std::array类：

提供丰富的成员函数：

arr.size();      // 返回元素数量（编译时常量）
arr.empty();     // 检查是否为空
arr.fill(42);    // 填充相同值
arr.swap(arr2);  // 交换两个array的内容

支持迭代器：

for (auto it = arr.begin(); it != arr.end(); ++it) { ... }
// 或范围for循环
for (auto& x : arr) { ... }

5. 赋值与复制

静态数组：

不能直接赋值，必须逐个元素复制：

int arr1[3] = {1, 2, 3};
int arr2[3];
// arr2 = arr1; // 错误！
std::copy(arr1, arr1+3, arr2); // 需要手动复制

std::array类：

支持直接赋值（深拷贝）：

std::array<int, 3> arr1 = {1, 2, 3};
std::array<int, 3> arr2;
arr2 = arr1; // 合法，整体复制

6. 作为函数返回值

静态数组：
- 无法直接返回，通常需返回指针或封装为结构体。
std::array类：
- 可直接返回，无需额外操作：
```
std::array<int, 3> create_array() {return {1, 2, 3};
}
```

7. 内存与性能

相同点：
- 两者均在栈上分配内存（除非显式动态分配）。
- 访问速度相同（operator[] 无额外开销）。
不同点：
- std::array 的 .at() 方法因边界检查有轻微性能损失，但提供安全性。

8. 兼容性

静态数组：
- 兼容C语言，适合与C代码交互。
std::array类：
- 仅限C++11及以上版本，需支持STL的编译器。

总结对比表

特性	静态数组	`std::array`类
类型安全性	弱（退化为指针）	强（保留大小和类型）
越界检查	无	支持（通过 `.at()`）
成员函数	无	丰富（`size()`, `fill()`, 等）
赋值操作	不支持直接赋值	支持整体赋值
迭代器支持	需手动处理指针	支持STL迭代器
作为返回值	需额外处理	直接支持
兼容性	兼容C	仅限C++11+

使用建议

优先使用 std::array：
在C++11及以上环境中，推荐使用 std::array，因其安全性、功能性和与现代STL的兼容性。
静态数组适用场景：
- 需要与C代码交互时。
- 对旧代码兼容性要求较高时。

2.模板的特化

2.1 概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{return left < right;
}int main()
{cout << Less(1, 2) << endl; // 可以比较，结果正确Date d1(2025, 4, 26);Date d2(2025, 4, 27);cout << Less(d1, d2) << endl; // 可以比较，结果正确Date* p1 = new Date(2025, 4, 26);Date* p2 = new Date(2025, 4, 27);cout << Less(p1, p2) << endl; // 可以比较，结果错误return 0;
}

可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

2.2 函数模板特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板

2. 关键字template后面接一对空的尖括号<>

3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型

4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误

// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{return *left < *right;
}

只要特化一下，比较的就不是地址了，编译器这里会优先调用特化版本的Less，毕竟编译器也知道省点懒，有现成的就用现成的。

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

bool Less(Date* left, Date* right)
{return *left < *right;
}

三者都存在时，编译器会优先走函数重载，因为函数重载是直接能用的，比函数模板特化更加现成

该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时特别给出，因此函数模板不建议特化。

2.3 类模板特化

2.3.1 全特化

全特化即是将模板参数列表中所有的参数都确定化

template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};
// 全特化
template<>
class Data<int, char>
{
public:Data() { cout << "Data<int, char>" << endl; }
private:int _d1;char _d2;
};
void Test1()
{Data<int, int> d1;Data<int, char> d2;
}

当两个类模板传的类型不同时，我们就需要全特化

2.3.2 偏特化（半特化）

偏特化又叫半特化，注意函数模板只有全特化，没有偏特化，这里偏特化只适用于类模板

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下模板类

template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};

偏特化有以下两种表现方式：

部分特化：将模板参数类表中的一部分参数特化。

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:Data() { cout << "Data<T1, int>" << endl; }
};void Test2()
{Data<int, int> d1;Data<char, 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;
};
void Test3()
{Data<double, int> d1; // 调用特化的int版本Data<int, double> d2; // 调用基础的模板Data<int*, int*> d3; // 调用特化的指针版本Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}

3 模板分离编译

3.1 什么是分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

3.2 模板的分离编译

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

// 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;
}

分析：

3.3 解决方法

1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。

2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。

【分离编译扩展阅读】

http://blog.csdn.net/pongba/article/details/19130

4.模板的优缺点

一、模板的优点

1. 代码复用与泛化

泛型编程：
允许编写与类型无关的代码，适用于多种数据类型。
例如：std::vector<T> 可以存储任意类型的元素，无需为每种类型重复实现容器逻辑。
减少冗余：
避免为相似逻辑但不同数据类型的函数或类编写重复代码（如排序、交换等操作）。

2. 类型安全

编译时类型检查：
模板在实例化时会生成具体类型的代码，编译器会进行严格的类型匹配，避免运行时类型错误。
例如：std::vector<int> 和 std::vector<double> 是完全不同的类型，不能隐式转换。

3. 性能优化

编译时多态：
通过模板展开生成具体类型的代码，无需运行时虚函数表（vtable）查找，性能接近手写代码。
例如：std::sort 的模板实现比运行时多态的排序算法更快。
零成本抽象：
模板的高效性使得抽象（如STL容器和算法）几乎不带来额外性能开销。

4. 灵活性

支持元编程：
模板元编程（TMP）允许在编译时进行计算和类型推导，实现高度优化的逻辑（如编译时条件判断、循环展开等）。
例如：std::tuple 的递归实现和 std::enable_if 的条件编译。
与类型系统结合：
可以结合 constexpr、concepts（C++20）等特性，实现更复杂的编译时逻辑。

5. 标准库支持

STL的基石：
标准模板库（STL）完全基于模板构建，提供了通用的容器（vector、map）、算法（sort、find）和迭代器。

二、模板的缺点

1. 编译时间膨胀

代码生成开销：
每个模板实例化都会生成独立的代码，若模板被频繁用于不同类型，可能导致编译后二进制文件体积增大（代码膨胀）。
例如：std::vector<int> 和 std::vector<double> 会生成两份完全不同的机器码。
编译速度下降：
模板的递归展开和复杂实例化逻辑会显著增加编译时间，尤其是大型项目或深度嵌套的模板。

2. 错误信息晦涩

难以调试的报错：
模板错误通常会在实例化时暴露，编译器报错信息冗长且难以理解，尤其是涉及嵌套模板或元编程时。
例如：一个简单的类型不匹配可能导致数十行的错误链。

3. 代码可读性降低

语法复杂性：
模板语法（如 typename 依赖、特化规则）对初学者不友好，复杂模板代码可能难以维护。
例如：template <typename T> using EnableIf = typename std::enable_if<...>::type;
元编程的隐式逻辑：
模板元编程依赖编译时计算，逻辑可能隐藏在类型推导和特化中，增加理解成本。

4. 跨平台兼容性挑战

编译器差异：
不同编译器对模板的支持可能存在差异（如旧版本编译器对C++11/14/17特性的支持不完整），导致移植性问题。

5. 运行时动态性受限

编译时确定类型：
模板的类型必须在编译时确定，无法实现真正的运行时多态（需结合虚函数或类型擦除技术如 std::any）。

三、使用场景与替代方案

1. 适用场景

需要高度复用且类型无关的代码（如容器、算法）。
对性能要求严格的场景（如数值计算、游戏引擎）。
编译时逻辑优化（如条件编译、静态检查）。

2. 替代方案

运行时多态（虚函数）：
适用于需要动态类型或接口统一的场景，但会引入运行时开销。
宏（Macro）：
简单代码生成，但缺乏类型安全且难以调试（不推荐替代模板）。
C++20概念（Concepts）：
增强模板的类型约束，提升错误信息的可读性。

四、总结

优点	缺点
代码复用与泛化	编译时间膨胀
类型安全	错误信息晦涩
高性能（编译时多态）	代码可读性降低
灵活支持元编程	跨平台兼容性挑战
与STL深度集成	运行时动态性受限

五、最佳实践

优先使用STL：避免重复造轮子，直接使用标准库中的模板组件。
限制模板复杂度：避免过度使用元编程，保持代码可维护性。
结合C++20概念：使用 concepts 约束模板参数，提升代码清晰度和错误信息质量。
类型萃取与SFINAE：合理使用 std::enable_if 或 if constexpr 实现条件编译。
模块化设计：将模板声明与实现分离到头文件中，减少编译依赖。

模板是C++的核心特性之一，正确使用可以大幅提升代码的灵活性和效率，但需权衡其复杂性和编译成本。在性能关键型项目和泛型库开发中，模板几乎是不可替代的工具；而在需要动态多态或快速迭代的场景中，需谨慎选择其使用范围。