今天你学C++了吗？——C++中的模板

♥♥♥~~~~~~欢迎光临知星小度博客空间~~~~~~♥♥♥

♥♥♥零星地变得优秀~也能拼凑出星河~♥♥♥

♥♥♥我们一起努力成为更好的自己~♥♥♥

♥♥♥如果这一篇博客对你有帮助~别忘了点赞分享哦~♥♥♥

♥♥♥如果有什么问题可以评论区留言或者私信我哦~♥♥♥
✨✨✨✨✨✨ 个人主页✨✨✨✨✨✨

这一篇博客我们来继续领略C++的魅力~进入C++的模板部分~准备好了吗~我们发车啦~🚗🚗🚗🚗🚗🚗

函数模板

我们来看看我们以前是怎么实现不同类型交换函数呢？

cpp 复制代码

#include<iostream>
using namespace std;
//应用函数重载（参数类型不同）
void Swap(int& a, int& b)
//引用传参，减少拷贝参数
{
	int t = a;
	a = b;
	b = t;
}

void Swap(double& a, double& b)
{
	double t = a;
	a = b;
	b = t;
}

void Swap(char& a, char& b)
{
	char t = a;
	a = b;
	b = t;
}

我们知道实现数据交换需要创建一个中间变量来实现的~对于不同的类型，我们是一个个写的，事实上它们的逻辑是相似的，只是它们的类型不一样而已~所以这个时候C++就引入了模板这个概念~模板分为函数模板和类模板~

接下来，我们一起来看看~

函数模板

函数模板概念

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

函数模板格式

》 template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名 ( 参数列表 ){ }
》 typename是 用来定义模板参数关键字 ， 也可以使用 class( 但是不能使用 struct 代替 class)
typename T1, typename T2,......,typename Tn也就是模板参数表~

那么上面的交换代码我们就可以这样实现

cpp 复制代码

template<typename T>
//也可以写成class T
//template<class T>

void Swap(T& a, T& b)
{
	T t = a;
	a = b;
	b = t;
}

我们可以使用它交换任意类型 ，这里面的T可以在程序运行时被C++语言支持的任意数据类型取代~这里进行简单测试，交换int类型和char类型~

我们可以看见通过使用模板，我们也实现了正确的交换~

模板的出现大大提高了代码复用率~

模板的原理

》 函数模板也就像是一个蓝图，它本身并不是函数，而是 编译器用使用方式产生特定具体类型函数的模具 ，所以模板也就是将 本来应该我们做的重复的事情交给了编译器
》在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应
类型的函数以供调用~ 比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于其他类型也是如此~

所以上面的代码调用的并不是一个函数~我们可以通过反汇编来看看~

我们可以看到交换int类型和char类型调用函数地址是不一样的，所以它们也就是不是调用同一个函数，这是因为编译器根据传入的实参类型来推演生成对应类型的函数进行调用~

看来编译器偷偷为我们做了很多事~

函数模板的实例化

》 用不同类型的参数使用函数模板时 ，称为函数模板的实例化 。模板参数实例化分为：隐式实例化和显式实例化
**》****隐式实例化：**让编译器根据实参推演模板参数的实际类型

例：

cpp 复制代码

#include<iostream>
using namespace std;
template<class T>

T Add(const T& a, const T& b)
{
	return a + b;
}

int main()
{
	int a = 1, b = 2;
	double x = 3.3, y = 4.4;
	//隐式实例化
	//编译器根据实参推演模板参数的实际类型
	cout << Add(a, b) << endl;
	cout << Add(x, y) << endl;
	return 0;
}

这里还存在一个类型转换问题

例：

cpp 复制代码

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

如果我们想解决这个问题，有两种方式：

**》**解决方法一：对想要的类型进行强制类型转换

cpp 复制代码

//解决方法一：强制类型转换
cout << Add((double)a, x) << endl;
cout << Add(a, (int)x) << endl;

这里有一个点需要注意的是在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅，所以这里就需要我们自己进行强制类型转换~

**》**解决方法二：显示实例化

我们可以发现前面的模板实例化是编译器根据实参进行推演的，这里我们可以使用另外一种实例化方式------显示实例化
》 显式实例化： 在函数名后的< >中指定模板参数的实际类型

例：

cpp 复制代码

//解决方法二：显示实例化
cout << Add<int>(a, x) << endl;//指定T为int
cout << Add<double>(a, x) << endl;//指定T为double

这里也就同样达到了我们想要的效果~
在显示实例化过程中，如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错~

模板参数的匹配原则

》 一个非模板函数可以和一个同名的函数模板同时存在 ，而且该函数模板还是可以被实例化为这 个非模板函数
》 对于非模板函数和同名函数模板， 如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例 （模板类似于半成品，而非模板函数也就类似于现成的，编译器也会偷点小懒~）， 如果模板可以产生一个具有更好匹配的函数，那么将选择模板（最优匹配原则）
》 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

cpp 复制代码

#include<iostream>
using namespace std;
template<class T1,class T2>//两个模板参数
//函数模板------通用加法函数
T1 Add(const T1& a, const T2& b)
{
	return a + b;
}
//非模板函数
//专门处理两个int类型加法的非模板函数
int Add(const int& a, const int& b)
{
	return a + b;
}
int main()
{
	int a = 1, b = 2;
	double x = 3.3, y = 4.4;
	cout << Add(a, b) << endl;//与非模板函数参数类型完全匹配，调用非模板函数（选择现成的）
	cout << Add(a, x) << endl;//与非模板函数参数类型不完全匹配，调用模板生成的匹配函数
	return 0;
}

我们同样使用反汇编可以观察这个情况~

类模板

类模板和函数模板是很类似的，编译器可以根据模板生成不同的类~

类模板的定义格式

template < class T1 , class T2 , ..., class Tn >
class 类模板名
{
// 类内成员定义
};

例：

cpp 复制代码

#include<iostream>
using namespace std;
// 类模版
template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		delete[] _array;
	}

	void Push(const T& data);
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};
//如果模版声明和定义分开写，要这样写
template<class T>//这里要单独声明模板参数
void Stack<T>::Push(const T& data)//指定类域加上模板参数
{
	// 扩容
	if (_size == _capacity)
	{
		int newcapacity = _capacity * 2;
		T* tmp = new T[newcapacity];//创建新空间
		memcpy(tmp, _array, sizeof(T) * _size);//拷贝数据
		delete[] _array;//释放旧空间
		_array = tmp;
		_capacity = newcapacity;
	}
	_array[_size] = data;
	++_size;
}
// 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误，具体原因后面博客会提及~
int main()
{
	//下面是不同的类------通过模板实例化出不同的类
	//通过模板实例化出不同的类
// Stack是类名，Stack<int>是类型
	Stack<int> st1; // int
	//Stack是类名，Stack<double>是类型
	Stack<double> st2; // double
	Stack<int*> st3; //int*
	return 0;
}

类模板的实例化

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

cpp 复制代码

//通过模板实例化出不同的类
// Stack是类名，Stack<int>是类型
Stack<int> st1; // int
//Stack是类名，Stack<double>是类型
Stack<double> st2; // double

♥♥♥本篇博客内容结束，期待与各位优秀程序员交流，有什么问题请私信♥♥♥

♥♥♥如果这一篇博客对你有帮助~别忘了点赞分享哦~♥♥♥

✨✨✨✨✨✨个人主页✨✨✨✨✨✨