【C++】了解模板

前言

如果我们要交换两个数字，那么我们就需要写一个Swap函数来进行交换，那如果我们要交换char类型的数据呢？那又要写一份Swap的函数重载，参数的两个类型是char，那我们还要交换double类型的数据呢？难道又要写一份Swap函数重载？如果在添加个自定义类型的交换呢？
模板的作用就是解决此类问题，模板的主要功能是实现通用

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

函数模板

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

基本用法：

template<typename T>
//这里的typename也可以换为class，一般情况下用typename居多
//也可以多参数
template<class T1, class T2>

实现一个交换函数模板：

template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

---

template<typename T> //模板参数 一般命名为T TY TP
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 2, b = 1;
	double c = 2.2, d = 1.1;
	cout << "交换前->" << a << " " << b << endl;
	Swap(a, b);
	cout << "交换后->" << a << " " << b << endl;

	cout << "交换前->" << c << " " << d << endl;
	Swap(c, d);
	cout << "交换后->" << c << " " << d << endl;

	return 0;
}

运行效果：

可以看到已经完成了交换，但实际上他们调用的并不是同一个函数，在编译器上看他们确实是调用的同一个函数，但是如果查看汇编就能发现他们调用的是不同的函数

可以看到调用的函数地址不相同

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

模板的实例化图解：

C++库中是有交换函数的，只不过库里的是小写，所以我们以后想要交换数据直接用库里的就好了

函数模板可以有多个参数

template<typename T1,typename T2>
void Func(const T1& x, const T2& y)
{
	cout << x << " " << y << endl;
}

函数模板可以做返回值

template<typename T1,typename T2>
T1 Func(const T1& x, const T2& y)
{
	cout << x << " " << y << endl;

	return x;
}

函数模板实例化生成具体函数
函数模板根据调用，自己推导模板参数的类型，实例化出对应的函数

函数模板的实例化

模板的实例化有两种方式
一种是隐式实例化：让编译器根据实参推演模板参数的实际类型
还有一种是显式实例化：在函数名后的<>中指定模板参数的实际类型

template<typename T>
T Add(const T& left, const T& right)
{
	return left + right;
}

int main()
{
	int a = 10;
	int b = 20;
	double c = 10.0;
	double d = 20.0;
	//编译器自动推导
	cout << Add(a, b) << endl;
	cout << Add(c, d) << endl;
	//但是下面这种场景如果让编译器自动推导就会出问题
	cout << Add(a, d) << endl;

	return 0;
}

左边的T是int右边的T是double，那到底是T推导成int还是double呢？
这时候编译器就会出现问题了

错误信息：

有两种方法可以解决这个问题
方法一：

cout << Add(a, (int)d) << endl;
cout << Add((double)a, d) << endl;

这样就不会出现推导歧义了

方法二：

//显式实例化,用指定类型实例化
cout << Add<int>(a, d) << endl;
cout << Add<double>(a, d) << endl;

大部分模板都不需要显式实例化，只有少数需要
比如：

template<typename T>
T* Alloc(int n)
{
	return new T[n];
}

int main()
{
	//有些函数无法自动推导，只能显式实例化
	double* arr = Alloc<double>(10);

	return 0;
}

类模板

//类模板
template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
	
private:
	T* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack<int> s1;
	Stack<double> s2;
	Stack<char> s3;

	return 0;
}

有了类模板就可以实现一个栈存储多类型的需求

类模板的声明和定义分离和普通的类不同：

//类模板
template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 3);

private:
	T* _array;
	int _capacity;
	int _size;
};

//普通类，类名和类型是一样的
//类模板，类名和类型不一样,
//类名是：Stack
//类型是：Stack<T>
//最好不要分离到两个文件
template<typename T>
Stack<T>::Stack(size_t capacity)
{
	_array = new T[capacity];
	_capacity = capacity;
	_size = 0;
}

int main()
{
	//类模板实例化
	Stack<int> s1;
	Stack<double> s2;
	Stack<char> s3;

	return 0;
}

总结：

优点:

1. 灵活性, 可重用性和可扩展性
2. 可以大大减少开发时间，模板可以把用同一个算法去适用于不同类型数据，在编译时确定具体的数据类型
3. 模版模拟多态要比C++类继承实现多态效率要高，无虚函数，无继承

缺点：

1. 可读性不好，调试比较困难
2. 模板的数据类型只能在编译时才能被确定
3. 所有用基于模板算法的实现必须包含在整个设计的.h头文件中, 当工程比较大的时候, 编译时间较长

以上就是本篇文章的全部内容了，希望大家看完能有所收获