C++：模板进阶

Chris-zz2024-06-10 6:03

✨✨✨学习的道路很枯燥，希望我们能并肩走下来!

文章目录

文章目录

前言

[一 非类型模板参数](#一 非类型模板参数)

[二 模板的特化](#二 模板的特化)

[2.1 概念](#2.1 概念)

[2.2 函数模板特化](#2.2 函数模板特化)

函数模板的易错点

[2.3 类模板特化](#2.3 类模板特化)

[2.3.1 全特化](#2.3.1 全特化)

[2.3.2 偏特化](#2.3.2 偏特化)

部分特化

参数更进一步的限制

[2.3.3 类模板特化应用示例](#2.3.3 类模板特化应用示例)

[三 模板分离编译](#三 模板分离编译)

[3.1 什么是分离编译](#3.1 什么是分离编译)

[3.2 模板的分离编译](#3.2 模板的分离编译)

[​编辑 3.3 解决方法](#编辑 3.3 解决方法)

[四 模板总结](#四 模板总结)

总结

前言

本篇详细介绍了进一步介绍模板使用，让使用者对模板有更加深刻的认知，而不是仅仅停留在表面，更好的模拟，为了更好的使用. 文章可能出现错误，如有请在评论区指正，让我们一起交流，共同进步！

一 非类型模板参数

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

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

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

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。（C++20支持double等内置类型

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

在我们的STL库中，我们也可以发现模板的非类型形参的身影

我们来介绍一个c++11引入的array

array的底层其实封装的是一个静态数组。并且用到了非类型形参，在这里N指代的是底层静态数组的容量大小。

问题：

1、为什么要有这个非模版形参，为什么不用define

define定义宏常量有时也可以解决问题，但是宏常量的作用域是全局，比如我们想让一个数组是10的容量，一个数组是20的容量，显然是做不到的，但是模版是可以做到的！！我们不传的时候N就是缺省值，传的时候就是我们指定的容量。

2、可以直接用静态数组，为什么用类把他封起来？

C语言的静态数组有一个致命缺陷：对越界问题检查不严格，是抽查行为

二 模板的特化

2.1 概念

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

cpp 复制代码 
// 函数模板 -- 参数匹配
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;  // 可以比较，结果错误
 
    return 0;
 }

可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。

此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式 。模板特化中分为函数模板特化 与类模板特化。

2.2 函数模板特化

函数模板的特化步骤：

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

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

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

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

cpp 复制代码 
 // 函数模板 -- 参数匹配
template<class T>
 bool Less(T left, T right)
 {
    return left < right;
 }
 
// 对Less函数模板进行特化
template<>
 bool Less<Date*>(Date* left, Date* 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;  // 调用特化之后的版本，而不走模板生成了
    return 0;
 }

函数模板的易错点

cpp 复制代码 
 // 函数模板 -- 参数匹配
template<class T>
 bool Less(const T left, const T right)
 {
    return left < right;
 }
 
// 对Less函数模板进行特化
template<>
 bool Less<Date*>(const Date* left, const Date* right)
 {
    return *left < *right;
 }

大家看看上面的代码有没有错误

对于原模板，const修饰的是left和right本身

对特化，const修饰的是指针指向的内容不可修改

违反了上面提到的函数模板的特化规则

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

正确的应该是：

cpp 复制代码 
 // 函数模板 -- 参数匹配
template<class T>
 bool Less(const T left, const T right)
 {
    return left < right;
 }
 
// 对Less函数模板进行特化
template<>
 bool Less<Date*>(Date* const left, Date* const right)
 {
    return *left < *right;
 }

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

cpp 复制代码 
bool Less(Date* left, Date* right)
 {
    return *left < *right;
 }

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

2.3 类模板特化

2.3.1 全特化

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

cpp 复制代码 
 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 TestVector()
 {
    Data<int, int> d1;
    Data<int, char> d2;
 }

2.3.2 偏特化

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

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

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

部分特化

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

cpp 复制代码 
// 将第二个参数特化为int
 template <class T1> 
class Data<T1, int>
 {
 public:
    Data() {cout<<"Data<T1, int>" <<endl;}
 private:
    T1 _d1;
    int _d2;
 };
参数更进一步的限制

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

cpp 复制代码 
//两个参数偏特化为指针类型 
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 test2 () 
{
     Data<double , int> d1;    // 调用特化的int版本
    Data<int , double> d2;     // 调用基础的模板   
    Data<int *, int*> d3;      // 调用特化的指针版本          
    Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}

2.3.3 类模板特化应用示例

有如下专门用来按照小于比较的类模板Less：

cpp 复制代码 
#include<vector>
#include <algorithm>
template<class T>
struct Less
{
    bool operator()(const T& x, const T& y) const
    {
        return x < y;
    }
};
int main()
{
    Date d1(2022, 7, 7);
    Date d2(2022, 7, 6);
    Date d3(2022, 7, 8);
    vector<Date> v1;
    v1.push_back(d1);
    v1.push_back(d2);
    v1.push_back(d3);
    // 可以直接排序，结果是日期升序
    sort(v1.begin(), v1.end(), Less<Date>());
    vector<Date*> v2;
    v2.push_back(&d1);
    v2.push_back(&d2);
    v2.push_back(&d3);
    // 可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序
   // 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象
   // 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期
    sort(v2.begin(), v2.end(), Less<Date*>());
    return 0;
}

通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排序元素是指 针，结果就不一定正确。因为：sort最终按照Less模板中方式比较，所以只会比较指针，而不是比较指针指 向空间中内容，此时可以使用类版本特化来处理上述问题：

cpp 复制代码 
 // 对Less类模板按照指针方式特化
template<>
 struct Less<Date*>
 {
     bool operator()(Date* x, Date* y) const
     {
         return *x < *y;
     }
 };

特化之后，在运行上述代码，就可以得到正确的结果

三 模板分离编译

3.1 什么是分离编译

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

3.2 模板的分离编译

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

cpp 复制代码 
 // 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. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。

四 模板使用问题（typename必须使用场景

编译器不会对类模板实例化做详细的检查，只会检查外壳（比如有没有加；

编译器在类模板没有实例化之前，不会去里面查细节的东西，此处编译器不敢进去查找，无法判断是类型还是变量

五 模板总结

【优点】

  1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生

  2. 增强了代码的灵活性

【缺陷】

  1. 模板会导致代码膨胀问题，也会导致编译时间变长

  2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误

总结

✨✨✨各位读友，本篇分享到内容是否更好的让你理解模板进阶，如果对你有帮助给个👍赞鼓励一下吧！！
🎉🎉🎉世上没有绝望的处境，只有对处境绝望的人。
感谢每一位一起走到这的伙伴，我们可以一起交流进步！！！一起加油吧！！

相关推荐
蓝黑202013 分钟前
IntelliJ IDEA常用快捷键
java·ide·intellij-idea
Ysjt | 深15 分钟前
C++多线程编程入门教程（优质版）
java·开发语言·jvm·c++
ephemerals__21 分钟前
【c++丨STL】list模拟实现（附源码）
开发语言·c++·list
码农飞飞25 分钟前
深入理解Rust的模式匹配
开发语言·后端·rust·模式匹配·解构·结构体和枚举
一个小坑货26 分钟前
Rust 的简介
开发语言·后端·rust
shuangrenlong27 分钟前
slice介绍slice查看器
java·ubuntu
牧竹子27 分钟前
对原jar包解压后修改原class文件后重新打包为jar
java·jar
湫ccc34 分钟前
《Python基础》之基本数据类型
开发语言·python
Matlab精灵35 分钟前
Matlab函数中的隐马尔可夫模型
开发语言·matlab·统计学习
Microsoft Word36 分钟前
c++基础语法
开发语言·c++·算法
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10【目标跟踪】相机运动补偿