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

【C++】15. 模板进阶

news 2025/11/1 2:12:47

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

  1. 全特化优先于偏特化：
    如果存在全特化版本且参数完全匹配，优先选择全特化。

  2. 偏特化优先于通用模板：
    若参数部分匹配偏特化的条件，优先选择偏特化。

  3. 通用模板是最后选择：
    仅当无特化版本匹配时，才会使用通用模板。

参数更进一步的限制 ：偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

//两个参数偏特化为指针类型
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深度集成运行时动态性受限

五、最佳实践

  1. 优先使用STL：避免重复造轮子，直接使用标准库中的模板组件。

  2. 限制模板复杂度：避免过度使用元编程，保持代码可维护性。

  3. 结合C++20概念：使用 concepts 约束模板参数，提升代码清晰度和错误信息质量。

  4. 类型萃取与SFINAE：合理使用 std::enable_if 或 if constexpr 实现条件编译。

  5. 模块化设计：将模板声明与实现分离到头文件中，减少编译依赖。

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

http://www.dtcms.com/a/156994.html

相关文章：

  • Eigen几何变换类 (Transform, Quaternion等)
  • 学习笔记：Qlib 量化投资平台框架 — GETTING STARTED
  • 将服务器接到路由器上访问
  • 【Leetcode 每日一题】2444. 统计定界子数组的数目
  • 图像特征检测算法对比及说明
  • 2025.4.26总结
  • ADC单通道采集实验
  • 3：QT联合HALCON编程—海康相机SDK二次程序开发
  • Android12源码编译及刷机
  • 详解Adobe Photoshop 2024 下载与安装教程
  • 论文笔记（八十）π0.5: a Vision-Language-Action Model with Open-World Generalization
  • Python并行计算：2.Python多线程编程：threading模块详解与守护线程实战
  • Spring Boot 3.4 实战指南：从性能优化到云原生增强
  • Spring Boot安装指南
  • Java后端开发——分层解耦详解
  • [mysql]数据类型精讲下
  • 用go从零构建写一个RPC（仿gRPC，tRPC）--- 版本1
  • Synology HDD db - 群晖硬盘兼容性数据库工具
  • Linux0.11内存管理：相关代码
  • DeepSeek系列（9）：团队协作最佳实践
  • 数字喜好判断之谜
  • 财务管理域——绩效管理系统设计
  • 代理专栏总结
  • 【微知】/proc中如何查看Linux内核是否允许加载内核模块？（/proc/sys/kernel/modules_disabled）
  • SpringBoot UserAgentUtils获取用户浏览器 操作系统设备统计 信息统计 日志入库
  • Arduino+ESP01S烧录
  • 【数据结构】优先级队列
  • 基于共享上下文和自主协作的 RD Agent 生态系统
  • 【计算机网络】TCP的四种拥塞控制算法
  • 驱动开发(1)|鲁班猫rk356x内核编译，及helloworld驱动程序编译