C++小白的逆袭之路——初阶（第六章：初识模版）

1.泛型编程

---

泛型编程，就是根据广泛的类型来编程。

1）例：如何实现一个通用的交换函数？

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

// ......

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

• 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。

• 代码的可维护性比较低，一个出错可能所有的重载均出错。

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？这就是我们接下来要学习的模版。

2）还有一个更让人头疼的例子：

如果我们要在一个main函数中创建两个栈，一个栈存放int类型数据，一个存放double类型数据，这时应该怎么办？难道我们要定义两个仅仅是数据类型不同的栈吗？

// int栈
class Stack1
{
	// 函数功能
public:
	// ...

private:
	int* _array;
	int top;
	size_t capacity;
};

// double栈
class Stack2
{
	// 函数功能
public:
	// ...

private:
	double* _array;
	int top;
	size_t capacity;
};

int main()
{
	Stack1 st1;		// int栈
	Stack2 st2;		// double栈
	return 0;
}

这样未免也太麻烦了，只有两个数据类型还好说，要是还有long栈，long long栈，还要再定义两个栈，代码出现大量重复。

---

2.函数模版

---

2.1函数模版的概念

---

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

---

2.2函数模版的格式

---

伪代码：

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

我们通过具体的例子，来学习一下函数模版的格式：

//template<class T>也是可以的，typename可以用class替换
template<typename T>	// 单个参数
template<typename T1, typename T2>	// 多个参数

执行下面代码时，上面的代码要注释掉。

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

int main()
{
	int a = 10, b = 0;
	Swap(a, b);			

	double x = 3.14, y = 0;
	Swap(x, y);

	return 0;
}

注意，Swap(a, b)和Swap(x, y)，执行的不是同一个函数，我们通过调试查看反汇编来验证：

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

---

2.3函数模版的原理

---

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

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

---

2.4函数模版的实例化

---

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

1.隐式实例化：

让编译器根据实参，推演模版参数的实际类型。

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

int main()
{
	int a1 = 10, a2 = 20;
	double b1 = 3.1, b2 = 2.1;

	// 隐式实例化
	cout << Add(a1, a2) << endl;		
	cout << Add(b1, b2) << endl;

	// 无法隐式实例化的情况
	cout << Add(a1, b1) << endl;		// 报错

	return 0;
}

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

此时，有两种解决方法，一种是用户自己来强制转化：

Add(a1, (int)b1);		// 会丢失数据，b1后的小数点部分自定舍去
Add((double)a1, b1);

另一种是显示实例化。

2.显示实例化：

在函数名后的<>中，指定模版参数的实际类型。

int main()
{
	int a1 = 10, a2 = 20;
	double b1 = 3.1, b2 = 2.1;

	cout << Add<int>(a1, b1) << endl;		// 会丢失数据
	cout << Add<double>(a1, b2) << endl;

	return 0;
}

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

---

2.5模版参数的匹配规则

---

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

// 专门处理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版本
}

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

// 专门处理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函数 
}

3.模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

---

3.类模版

---

3.1类模板的定义格式

---

1.伪代码：

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

2.实例：动态顺序表

// 动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
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 <class T>
Vector<T>::~Vector()
{
	if(_pData)
		delete[] _pData;
	_size = _capacity = 0;
}

完美解决了我们在泛型编程中提到的问题，写一个栈类的模版，就可以创建多个不同数据类型的栈。

注意：类模板，不要轻易的去做声明和定义分离。在一个文件可以分离，在两个文件（.h放声明，.cpp放定义）分离会报错，具体原因我们在模版进阶部分详谈。

---

3.2类模版的实例化

---

类模板实例化与函数模板实例化不同（类模版实例化没有隐式实例化，必须显示实例化），类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可。类模板名字不是真正的类，而实例化的结果才是真正的类。

// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;

---