【C++】浅谈模板

1.前言

在学习C语言的时候，我们实现了一个void Swap (int* x, int* y)函数用以交换两个int型整数，但是由此却引发了这样一个问题：当我们想要交换两个double类型的数时，先前写的Swap就无能为力了，因为先前的Swap只能交换int型数据，于是乎我们不得不重写Swap2，Swap3…

到了学习C++之时，我们似乎有了解决方案：函数重载。这时的我们可以给所有的交换函数都起一个名字：Swap，然后单纯地改变参数类型就能实现函数的重载。可是，想要重载一个别的类型的Swap，我们就得CV重复的代码，未免太过冗余

于是，泛型编程和模板应运而生。

所谓泛型编程，就是我们的处理对象，不再面向单单一个具体的类型，而是面向广泛的类型，我们不妨用T（type）称呼这种广泛类型的全体

泛型编程的对象有函数和类两大主体

目录

函数模板
2.1 如何定义函数模板
2.2 函数模板的原理
2.3 函数模板的实例化
2.4 模板参数的匹配原则类模板
3.1 类模板的定义格式
3.2 类模板的实例化关于编译器根据实参自动推演模板参数类型 2.函数模板 2.1 如何定义函数模板

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

定义一个函数模板的格式：

template
返回值类型 函数名(参数列表){}

或

template
返回值类型 函数名(参数列表){}

注意typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

用Swap函数来举个栗子：

template
void Swap( T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

2.2 函数模板的原理

太棒了，我们很快便学会了如何定义函数模板，那么我们就更进一步，一探其中的原理吧

首先，我们要明白一点，函数模板本身不是函数，因为其中尚含有模板参数，它现在只是一个模具，并未真正地根据人的需求被做出实物来。

当编译器在编译代码的时候，编译器需要根据调用模板函数时传入实参的类型推导出模板参数的类型，以生成对应的具体的函数。

就拿Swap函数来说，当我们的实参传入2个double类型的数时，编译器就根据传入的实参推演出了实参的类型是double，接着就会帮助我们用double替换掉模板参数T，并根据模具生成一份void Swap( double& left, double& right)来

也就是说，在编译阶段，编译器帮我们生成了一份原来需要我们自己CV的代码，我们只不过是将任务交给了编译器，其实仍然会生成一个有具体类型参数的函数

2.3 函数模板的实例化

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

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

template
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); //能够完成函数模板的实例化
	Add(a1, d1); //该语句不能通过编译
	return 0;
}

我们来解释一下Add(a1, d1);编译不通过的原因：

因为在编译期间，当编译器看到该实例化时，需要推演其实参类型

通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错

另外，在模板中，编译器一般不会进行类型转换操作，所以我们有3种处理方案：

1.用户自己来强制转化2.使用2个模板参数T1，T23.使用显式实例化

方案一：用户自己来强制转化

template
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, (int)d1); //用户自己来强制转化
	return 0;
}

方案二：使用2个模板参数T1，T2

template
T1 Add(const T1& left, const T2& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.0, d2 = 20.0;
	Add(a1, d1); //使用2个模板参数T1，T2
	return 0;
}

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

方案三：显示实例化

template
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, d1);
	return 0;
}

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

2.4 模板参数的匹配原则

一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

// 专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}
// 通用加法函数
template
T Add(T left, T right)
{
	return left + right;
}
void Test()
{
	Add(1, 2); // 与非模板函数匹配，编译器不需要特化
	Add(1, 2); // 调用编译器特化的Add版本
}

---

聪明的小伙伴们此刻一定会有一个疑问：如果非模板函数和同名模板函数都存在时，当我们调用函数时，会进到哪一个函数里面去呢？

那我就先问大家一个小问题

今天中午，你独自一人在家，又特别想吃红烧肉。此时呢，你有2种选择：
1.刚拿到过年红包，有钱，直接点个外卖

2.大过年的，家里冰箱里就有生的五花肉，自己做红烧肉也行

好了，3秒钟的时间告诉我你选什么

3


















2






















1

应该都选了点外卖吧。嘿嘿，我也是。

---

既然我们人都偏爱点外卖，不想自己动手做饭，那么编译器何尝不是呢？
上面都有专门写好了的非模板函数可以调用了，我编译器才懒得自己去推演生成一个一模一样的函数呢

---

对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

// 专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}
// 通用加法函数
template
T1 Add(T1 left, T2 right)
{
	return left + right;
}
void Test()
{
	Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
	Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

3.类模板

在接下来的STL学习中，我们会深刻地理解并运用类模版给我们带来的福利，因为STL中的容器都是类。我们先来看看类模板

3.1 类模板的定义格式

template
class 类模板名
{
	// 类内成员定义
};

// 动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template
class Vector
{
public:
	Vector(size_t capacity = 10)
		: _pData(new T[capacity])
		, _size(0)
		, _capacity(capacity)
	{}
	// 使用析构函数演示：在类中声明，在类外定义。
	~Vector();
	void PushBack(const T& data)；
		void PopBack()；
		// ...
		size_t Size() { return _size; }
	T& operator[](size_t pos)
	{
		assert(pos < _size);
		return _pData[pos];
	}
private:
	T* _pData;
	size_t _size;
	size_t _capacity;
};
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template 
Vector::~Vector()
{
	if (_pData)
		delete[] _pData;
	_size = _capacity = 0;
}

3.2 类模板的实例化

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

// Vector类名，Vector才是类型
Vector s1;
Vector s2;

4.关于编译器根据实参自动推演模板参数类型

关于编译器自动推演模板参数的类型的探究，我做了一下一个验证：
代码一：

template 
void func(T x)
{
	cout << "T的大小：" << sizeof(T) << endl;
}
int main()
{
	double a = 1;
	double* pa = &a;
	func(pa);
	return 0;
}

此时，T应该被推演成了double* 类型，而在32位系统中所有指针都是4个字节
运行结果：

代码二：

template 
void func(T* x)
{
	cout << "T的大小：" << sizeof(T) << endl;
}
int main()
{
	double a = 1;
	double* pa = &a;
	func(pa);
	return 0;
}

此时，T应该被推演成了double 类型，占8个字节
运行结果：

不得不说，模板参数的推演编译器做的很智能