✨✨小新课堂开课了,欢迎欢迎~✨✨
🎈🎈养成好习惯,先赞后看哦~🎈🎈
所属专栏:C++:由浅入深篇
小新的主页:编程版小新-CSDN博客
1.泛型模版
我们来想一下如何实现一个通用的交换函数呢?
在C语言中我们通常这么实现:
void swap1(int* left,int* right)
{
int tmp = *left;
*left = *right;
*right = tmp;
}
void swap2(double* left, double* right)
{
double tmp = *left;
*left = *right;
*right = tmp;
}
C语言不支持函数重载,所以用于交换不同类型变量的函数的函数名是不能相同的,并且传参形式必须是址传递,不能是值传递。
而在学习了C++的函数重载和引用后,我们又会用如下方法实现两个数的交换:
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;
}
//......
![](https://i-blog.csdnimg.cn/direct/744ebecf028a40b89afcd04dc03119d6.png)
![](https://i-blog.csdnimg.cn/direct/e84728baf8534e3884856d1e57473044.png)
2.函数模版
2.1函数模版的概念
2.2函数模版的格式
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名 ( 参数列表 ){}
template <typename T>
void Swap(T& left, T& right)
{
T tmp = left;
left = right;
right = tmp;
}
注意:typename是用来定义模板参数关键字,也可以使用class(切记:不能使用struct代替class)
template <typename T>
void Swap(T& left, T& right)
{
T tmp = left;
left = right;
right = tmp;
}
int main()
{
int a = 1, b = 2;
double i = 1.1, j = 2.2;
cout << "交换前:" << a << ' ' << b << endl;
Swap(a, b);
cout << "交换后:" << a << ' ' << b << endl;
cout << "交换前:" << i << ' ' << j << endl;
Swap(i, j);
cout << "交换后:" << i << ' ' << j << endl;
return 0;
}
我们先来看一下效果,后面再解释为什么能达到这个效果。
2.3函数模版的原理
屏幕录制 2024-08-16 213232
通过上面的视频调试,我们可以看到整形和浮点型走的都是Swap函数,那他们的底层调用的真的是同一个函数吗?
我们这里再转到反汇编看一下:
通过反汇编观察我们可以知道,当调用实参类型不同时,调用的函数也不同。
那么函数模版到底是如何调用的呢?
![](https://i-blog.csdnimg.cn/direct/e205261acd3649af87f92bca0abe4261.png)
2.4函数模板的实例化
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;
}
int main()
{
int a = 10;
double b = 20.0;
/*在编译期间,当编译器看到该实例化时,需要推演其实参类型
通过实参a将T推演为int,通过实参b将T推演为double类型,但模板参数列表中只有 一个T,
编译器无法确定此处到底该将T确定为int 或者 double类型而报错,这个时候要么显示实例化*/
// 显式实例化
Add<int>(a, b);
return 0;
}
2.5函数模版的匹配规则
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非模板函数匹配,编译器不需要特化
Add<int>(1, 2); // 调用编译器特化的Add版本
}
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
// 通用加法函数
}
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非函数模板类型完全匹配,不需要函数模板实例化
Add(1, 2.0); // 模板函数可以生成更加匹配的版本,编译器根据实参生成更加匹配的Add函数
}
#include <iostream>
using namespace std;
template<typename T>
T Add(const T& x, const T& y)
{
return x + y;
}
int main()
{
int a = Add(2, 2.2); //模板函数不允许自动类型转换,不能通过编译
return 0;
}
因为模板函数不允许自动类型转换,所以不会将2自动转换为2.0,或是将2.2自动转换为2。
3.类模板
3.1类模版的定义格式
template<class T1,class T2,…,class Tn>
class 类模板名
{
//类内成员声明
};
例如:
// 类模版
template<typename T>
class Stack
{
public:
Stack(size_t capacity = 4)
{
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}
void Push(const T& data);
private:
T* _array;
size_t _capacity;
size_t _size;
};
// 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误,具体原因后面会讲
//在类外定义
template<class T>
void Stack<T>::Push(const T& data)
{
// 扩容
_array[_size] = data;
++_size;
}
int main()
{
Stack<int> st1; // int
Stack<double> st2; // double
return 0;
}
注意:类模板中的成员函数若是放在类外定义时,需要加模板参数列表。而且模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误。
3.2类模板的实例化
// Stack是类名,Stack<int>才是类型
Stack<int> st1; // int
Stack<double> st2; // double