【C++】模板（入门+进阶）

news/2024/11/3 1:25:28/

「前言」

🌈个人主页： 代码探秘者
🌈C语言专栏：C语言
🌈C++专栏： C++ / STL使用以及模拟实现
🌈数据结构专栏： 数据结构 / 十大排序算法
🌈Linux专栏： Linux系统编程 / Linux网络编程（准备更新）
🌈喜欢的诗句:天行健,君子以自强不息.

pic_8da49713.png

一、泛型编程

首先看以下代码：如何实现一个通用的交换函数呢？

java">void Swap(int& left, int& right)
{int temp = left;left = right;right = temp;
}
void Swap(double& left, double& right)
{double temp = left;left = right;right = temp;
}
void Swap(char& left, char& right)
{char temp = left;left = right;right = temp;
}
//......

使用函数重载虽然可以实现，但是有一下几个不好的地方：

  1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
  2. 代码的可维护性比较低，一个出错可能所有的重载均出错

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

就好比活字印刷术，可以灵活调整印刷的板块和内容，比只能固定印刷某一个内容的雕版印刷术效率更高
在这里插入图片描述

在C++中，已经存在这样一个模具：泛型编程

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

模板又分函数模板和类模板
在这里插入图片描述

二、函数模板

2.1 函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.1 函数模板格式

java">template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}

测试代码：

java">template<typename T>
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}

注意：

  • typename 是用来定义模板参数关键字，也可以使用 class
  • 建议函数模板用typename，类模板用class
  • 切记：不能使用struct代替class

对于 T 我们可以任意起，T 这个名称是自己取的，但是一般要符合意境，一般喜欢用 T (Type 的意思)

测试代码：

java">#include<iostream>
using namespace std;template<typename T>
void Swap(T& left, T& right)
{T temp = left;left = right;right = temp;
}int main()
{int a = 1, b = 2;double c = 1.1, d = 2.2;Swap(a, b);Swap(c, d);cout << "a=" << a << " " << "b=" << b << endl;cout << "c=" << c << " " << "d=" << d << endl;return 0;
}

在这里插入图片描述

2.3 函数模板的原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器

在这里插入图片描述

在反汇编下查看，它们调用的是不同的函数

在这里插入图片描述

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。

比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

2.4 函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化

（1）隐式实例化：让编译器根据实参推演模板参数的实际类型

java">template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
int main()
{int a1 = 10, a2 = 20;double d1 = 10.0, d2 = 20.0;Add(a1, a2);Add(d1, d2);return 0;
}

以下情况是不能通过编译的：Add(a1, d1);

java">template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
int main()
{int a1 = 10;double d1 = 10.0;Add(a1, d1);return 0;
}

编译报错

在这里插入图片描述

  • Add(a1, d1) 该语句不能通过编译
  • 因为在编译期间，当编译器看到该实例化时，需要推演其实参类型通过实参a1将T推演为int，通过实参d1将T推演为double类型
  • 但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错

注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅

此时有两种处理方式：
（1) 用户自己来强制转化

java">//强转
//Add(a1, d1);error
Add(a1, (int)d1);

（2）显式实例化：在函数名后的<>中指定模板参数的实际类型

java">template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
int main()
{int a1 = 10;double d1 = 10.0;//Add(a1, d1);// 显式实例化Add<int>(a1, d1);return 0;
}

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错

2.5 函数模板特化(具体化)

函数模板的特化步骤

  1. 必须要先有一个基础的函数模板
  2. 关键字template后面接一对空的尖括号<>
  3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
  4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误

修改上面的代码

java">#include<iostream>
using namespace std;
//交换两个类的排名（这里使用普通函数模板和具体化（特化））
class girl		
{
public:int _num;		//学号string _name;	
};
//1.先有一个基础的函数模板
template<typename T>
void Swap(T& a, T& b)
{T tmp = a;a = b;b = tmp;cout << "函数模板" << endl;
}
//2.<>
template<>
//3.     <要交换的类型>
void Swap<girl>(girl& g1, girl& g2)		//交换学号
//void Swap(girl& g1, girl& g2)
{int tmp = g1._num;g1._name = g2._num;g2._num = tmp;cout << "函数模板特化（具体化）" << endl;
}
int main()
{int a = 20;int b = 30;Swap(a, b);		//使用了函数模板girl g1, g2;g1._name = 25;g2._num = 54;Swap(g1, g2);	//函数模板特化（具体化）return 0;
}

运行结果正确

在这里插入图片描述

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

java">void Swap(girl& g1, girl& g2)

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

2.5 模板参数的匹配原则（优先级）

  • 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
  • 就是具体化（特化）>常规模板，普通函数>具体化和常规模板
  • 如果希望使用具体函数模板，可以使用空模板参数强制使用函数模板
  • 如果函数模板（实例化或者强制类型转换）能产生更匹配的，就优先于普通模板
  • 具体化函数模板和函数模板实例化不一样

在这里插入图片描述

java">#include<iostream>
using namespace std;
//1.普通函数
void Swap(int a,int b)
{cout << "使用了普通函数" << endl;
}
//2.函数模板
template<typename T>
void Swap(T a, T b)
{cout << "使用了函数模板" << endl;
}
//3.函数模板特化（具体化）
template<>
void Swap<int>(int a,int b)
{cout << "使用了函数模板特化（具体化）" << endl;
}
int main()
{int a = 1;int b = 2;//优先使用普通函数Swap(a,b);//(可以实例化出更匹配的，使用函数模板)Swap<char>('a', 'b');		//字符型转整形Swap('a', 'b');		//使用函数模板具体化（特化）Swap<>(1, 3);return 0;
}

运行结果：
在这里插入图片描述

2.6 函数模板不支持声明和定义分离

2.6.1 函数模板分文件编写（三个同时有）

test.h

  • 普通函数和函数模板特化（具体化）声明定义分离
  • 特化，声明和定义处都加template<>
  • 函数模板，声明和定义全写头文件
java">#pragma once
#include<iostream>
using namespace std;
//普通函数
void Swap(int a, int b);
//函数模板
template<typename T>
void Swap(T a, T b)
{cout << "使用了函数模板" << endl;
}
//函数模板特化（具体化）
template<>
void Swap<int>(int a, int b);

public.cpp

java">#include"test.h"
//普通函数
void Swap(int a, int b)
{cout << "使用了普通函数" << endl;
}
//函数模板特化（具体化）
template<>
void Swap<int>(int a, int b)
{cout << "使用了函数模板特化（具体化）" << endl;
}

test.cpp

java">#include"test.h"
int main()
{int a = 1;int b = 2;//优先使用普通函数Swap(a, b);//(可以实例化出更匹配的，使用函数模板)Swap<char>('a', 'b');		//字符型转整形Swap('a', 'b');//使用函数模板具体化（特化）Swap<>(1, 3);return 0;
}

运行结果：
在这里插入图片描述

2.6.2 分离编译（只有函数模板）

一般情况下，我们都会在头文件中生命函数，在另外一个源文件中定义函数。

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

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

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

编译器会报链接错误

java">error LNK2019:无法解析的外部符号...

在这里插入图片描述

程序要运行起来一般要经历以下四个步骤：

  1. 预处理： 头文件展开、去注释、宏替换、条件编译等
  2. 编译： 检查代码的规范性、是否有语法错误等，确定代码实际要做的工作，在检查无误后，将代码翻译成汇编语言
  3. 汇编： 把编译阶段生成的文件转成目标文件
  4. 链接： 将生成的各个目标文件进行链接，生成可执行文件

解决方法

  1. 将声明和定义放到一个文件 “xxx.hpp” 里面或者xxx.h其实也是可以的（两者合并），推荐使用这种
  2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用

显示实例化如下，把类型写死了，没有展示模板的优势，不推荐

java">// a.h
template<class T>
T Add(const T& left, const T& right);// a.cpp(定义位置显式实例化)
template<class T>
T Add(const int& left, const int& right)
{return left + right;
}

2.7 C++11语法

2.7.1 decltype

语法：

java"> decltype(表达式) var；
  • 分析表达式，得到类型，不会计算执行表达式（函数调用也是表达式）
  • var和表达式类型相同
java">	int a1 = 3;const int* a2 = a1;//普通的decltype(a1) p1;decltype(a2) p2;

引用

  • 推导引用时，必须初始化
java">	int a3 = 3;int a4 = 4;int& ra = a3;	decltype(ra) p3=a4;		//初始化

函数

  • 填函数调用，得到函数返回类型
  • 填函数名，加* 指向函数，变成函数指针
  • 注意auto会调用函数，而decltype需要自己调用
java">int func2()
{cout << "调用func2()函数"<< endl;return 3;
}
//函数时
int a5 = 3;
decltype(func2()) p4 = a5;//填函数调用，得到函数返回类型decltype(func2)* p5=func2;//填函数名，加* 指向函数，变成函数指针
p5();	//调用函数
auto p8 = func2();				//注意auto会调用函数，而decltype需要自己调用

左值

java">//多加一个括号，变引用
int a6 = 8;
int a7 = 9;decltype((a6)) p6=a7;		//普通变量
decltype((func2)) p7 = func2;//函数名	
p7();	//调用

多次使用decltype，建议using或者typedef给类型重命名，方便使用

2.7.2 auto

函数模板会出现下面问题，？？？应该怎么写

  • 可以写auto
    但返回类型怎么写呢？
java">template<typename T1,typename T2>
int func1(T1 x,T2 y)
{？？？ tmp = x + y;cout << "tmp="<<tmp<<endl;return tmp;
}

C++11 标准：

  • 使用auto关键字结合尾置返回类型来自动推断返回类型
java">template<typename T1,typename T2>
auto func1(T1 x,T2 y)->decltype(x+y)
{decltype(x+y) tmp = x + y;cout << "tmp="<<tmp<<endl;return tmp;
}

C++14 标准：

  • 允许你在函数体内部使用auto来声明返回类型，而不需要指定具体的类型
  • 不需要尾置返回类型
java">template<typename T1,typename T2>
auto func1(T1 x,T2 y)
{auto tmp = x + y;cout << "tmp="<<tmp<<endl;return tmp;
}

三、类模板

3.1 类模板的定义格式

  • 建议函数模板用typename，类模板用class
java">template<class T1, class T2, ..., class Tn>
class 类模板名
{// 类内成员定义
};
  • 使用类模板时，必须指明具体数据类型
  • 对于函数模板可以根据实参去推演形参的类型，但是类在用的时候，首先是定义对象，所以类模板的使用都是显示实例化
java">template<class T1，class T2>
class Stack
{
private:T* _a;T2 _top;int _capacity;
};
int main()
{Stack<int,double> st1;//显示实例化，指明具体数据类型return 0;
}
  • 类模板中函数放在类外进行定义时，需要加模板参数列表

测试栈的代码：

java">template<class T>
class Stack
{
public:Stack();//类模板中函数放在类外进行定义时，需要加模板参数列表~Stack();
private:T* _a;int _top;int _capacity;
};//类模板中函数放在类外进行定义时，每个函数都要需要加模板参数列表
template <class T>
Stack<T>::Stack()
{//...
}
template <class T>//每个函数都要需要加模板参数列表
Stack<T>::~Stack()
{//...
}
int main()
{return 0;
}
  • 类模板可以为通用数据类型指定缺省的数据类型（C++11的函数模板也可以）
java">template<class T=int>
  • 可以使用new一个类模板对象

比如有一个AA类

java">AA<int,string> *a=new AA<int,string>(3,'lan')

3.2 类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类

java">//Stack是类名，Stack<int>,Stack<double>才是类型
Stack<int> s1;
Stack<double> s2;

注意区分

  • 普通类，类名就是类型
  • 类模板，类名不是类型，类型是 Stack（以上面的 Stack类 为例子）

3.3 类模板特化

3.3.1 全特化

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

测试代码

java">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 Test()
{Data<int, int> d1;Data<int, char> d2;//调用特化的类
}

运行结果

在这里插入图片描述

3.3.2 偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本

偏特化有以下两种表现方式：部分特化和参数更进一步的限制
（1）部分特化

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

比如对于以下模板类

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

进行部分特化

java">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; }
private:T1 _d1;int _d2;
};void Test()
{Data<char, int> d1;//调用特化的类Data<int, char> d2;
}

运行结果

在这里插入图片描述

（2）参数更进一步的限制

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

测试代码

java">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; }
private:T1 _d1;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 Test()
{Data<double, int> d1; // 调用特化的int版本Data<int, double> d2; // 调用基础的模板Data<int*, int*> d3; // 调用特化的指针版本Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}

运行结果

在这里插入图片描述

四、非类型模板参数

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

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

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

java">template<class T, size_t N>

class T 就是类型参数，size_t N 就是非类型形参

例如，要实现一个静态数组的类，就需要用到非类型模板参数

java">template<class T, size_t N> //N：非类型模板参数
class StaticArray
{
public:size_t arraysize(){return N;}
private:T _array[N]; //利用非类型模板参数指定静态数组的大小
};

使用非类型模板参数后，就可以在实例化对象的时候指定所要创建的静态数组的大小

测试代码

java">void Test()
{StaticArray<int, 10> a1; //定义一个大小为10的静态数组cout << a1.arraysize() << endl; //10StaticArray<int, 100> a2; //定义一个大小为100的静态数组cout << a2.arraysize() << endl; //100
}

运行结果

在这里插入图片描述

注意

  1. 非类型模板参数对于 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
  2. 非类型的模板参数在编译期就需要确认结果，因为编译器在编译阶段就需要根据传入的非类型模板参数生成对应的类或函数

对于第二点进行测试

java">void Test1()
{int n = 10;StaticArray<int, n> a1; //定义一个大小为10的静态数组cout << a1.arraysize() << endl; //10
}

运行结果

--------------------- END ----------------------

java">「 作者 」 代码探秘者
「 更新 」 2024.11。01

http://www.ppmy.cn/news/1544020.html

相关文章

【网络面试篇】TCP与UDP类

【网络面试篇】TCP与UDP类

目录 一、综述 1. TCP与UDP的概念 2. 特点 3. 区别 4. 对应的使用场景 二、补充 1. 基础概念 &#xff08;1&#xff09;面向连接 &#xff08;2&#xff09;可靠的 &#xff08;3&#xff09;字节流 2. 相关问题 &#xff08;1&#xff09;TCP 和 UDP 可以同时绑定…
阅读更多...
ISO 26262与ISO 21434：汽车安全领域的双重保障与交汇探索

ISO 26262与ISO 21434：汽车安全领域的双重保障与交汇探索

ISO 26262和ISO 21434都是关于汽车安全的国际标准&#xff0c;它们在汽车安全领域各自有不同的侧重点&#xff0c;但它们也存在交集。 ISO 26262是一个针对汽车行业的功能安全标准&#xff0c;它主要关注汽车电子和电气系统的安全性。这个标准从概念阶段开始&#xff0c;贯穿了…
阅读更多...
微信小程序时间弹窗——年月日时分

微信小程序时间弹窗——年月日时分

需求 1、默认当前时间2、选择时间弹窗限制最大值、最小值3、每次弹起更新最大值为当前时间&#xff0c;默认值为上次选中时间4、 minDate: new Date(2023, 10, 1).getTime(),也可以传入时间字符串new Date(2023-10-1 12:22).getTime() html <view class"flex bb ptb…
阅读更多...
src和href的区别

src和href的区别

src和href都是HTML中用于指定资源地址的属性&#xff0c;但它们在用途、引用方式、对文档的影响以及适用范围等方面存在显著的区别。以下是对这两者的详细比较&#xff1a; 一、用途不同 src&#xff1a;主要用于嵌入到文档中的资源。它告诉浏览器去加载指定的资源&#xff0…
阅读更多...
深入探索：深度学习在时间序列预测中的强大应用与实现

深入探索：深度学习在时间序列预测中的强大应用与实现

深入探索&#xff1a;深度学习在时间序列预测中的强大应用与实现 时间序列分析是数据科学和机器学习中的一个重要研究领域&#xff0c;广泛应用于金融市场、天气预报、能源管理、交通预测、健康监控等多个领域。时间序列数据具有顺序相关性&#xff0c;通常展示出时间上较强的…
阅读更多...
kafka里的consumer 是推还是拉？

kafka里的consumer 是推还是拉？

大家好&#xff0c;我是锋哥。今天分享关于【kafka里的consumer 是推还是拉&#xff1f;】面试题&#xff1f;希望对大家有帮助&#xff1b; kafka里的consumer 是推还是拉&#xff1f; 1000道 互联网大厂Java工程师 精选面试题-Java资源分享网 在Kafka中&#xff0c;消费者&…
阅读更多...
雷池社区版compose配置文件解析-mgt

雷池社区版compose配置文件解析-mgt

在现代网络安全中&#xff0c;选择合适的 Web 应用防火墙至关重要。雷池&#xff08;SafeLine&#xff09;社区版免费切好用。为网站提供全面的保护&#xff0c;帮助网站抵御各种网络攻击。 compose.yml 文件是 Docker Compose 的核心文件&#xff0c;用于定义和管理多个 Dock…
阅读更多...
微软认证是什么？有哪些科目？

微软认证是什么？有哪些科目？

微软认证是微软公司设立的推广微软技术&#xff0c;培养系统网络管理和应用开发人才的完整技术金字塔证书体系&#xff0c;在全世界90多个国家认可有效&#xff0c;并且可以作为薪资职位变迁的有效证明&#xff0c;公司资质实力证明和移民加分等多项益处!微软认证从1992年设立&…
阅读更多...
最新文章

Copyright @ 2022~2023