模板

• 泛型编程
• 模板
• 函数模板
• • 实例化
  • • 隐式实例化
    • 显式实例化
  • 匹配原则
• 类模板
• • 实例化

---

我们之前讲解过函数重载，对于函数名相同，参数不同的函数都得实现一个相应的重载函数，这样就十分的麻烦~
有没有一份代码可以在多种情况下达到复用的物什？有的！这就要提到泛型编程。

泛型编程

泛型编程：即以一种独立于任何特定类型的编码方式。编写与类型无关的通用代码，是代码复用的一种手段。
【模板则是泛型编程的基础】

模板

模板：是创建泛型类或函数的蓝图或公式。

例如STL库中容器、迭代器和算法，都是泛型编程的体现，它们都使用了模板的概念。

所以对于上面例子：使用函数重载虽然可以实现，但是有一下几个不好的地方：

1. 重载的函数仅仅只是类型不同，代码的复用率低，只要有新类型出现时，就需要增加对应的函数。
2. 代码的可维护性低，一个出错可能所有的重载均出错。

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

如果在C++中存在一个“模具”一般的工具，通过给这个模具中填充不同材料(参数类型)，来获得不同材料的成品(生成具体类型的代码），这将会减少大量冗余代码~这个模具就是模板。

模板分为两种：

• 函数模板
• 类模板

---

函数模板

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

格式：

template<class T1, class T2, ...>
返回值类型 函数名(参数列表) {
   // 函数主体逻辑
}

上面代码用来定义模板参数关键字除了使用class外，还可以使用typename关键字。

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

对于常用的Swap函数，不同的参数类型调用会产生不同的效果，除去函数重载，下边展示一下函数模板的使用：

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

此时无论两个int类型或者double等类型的参数都可以通过这个函数模板推演出适合的函数进行调用。

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

---

实例化

函数模板的实例化：用不同类型的参数使用函数模板时。

模板参数实例化分为：隐式实例化 和 显式实例化。

1. 隐式实例化：让编译器根据实参推演模板参数的实际类型。
2. 显式实例化：在函数名后的<>中指定模板参数的实际类型。

隐式实例化

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

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

注：在模板中，编译器一般不会进行类型转换操作。

所以处理方式有两种：

1. 强制转换：用户自己指定参数类型。

	Add(a, (int)d);

2. 显式实例化

显式实例化

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

	Add<int>(a, b);

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

匹配原则

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

// 专门处理 int 类型的加法函数
int Add(int left, int right){			//函数1
	return left + right;
}

// 通用类型的加法函数
template<class T>						
T Add(T left, T right){					//函数2
	return left + right;
}
void Test(){
	Add(1, 2); 		// 与非模板函数1匹配，编译器不需要特化
	Add<int>(1, 2); // 使用模板2推演，调用编译器特化的Add版本函数
}

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

// 专门处理int的加法函数
int Add(int left, int right){		//函数1
	return left + right;
}

// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right){			//函数2
	return left + right;
}

void Test(){
	Add(1, 2); 		// 与非函数模板1类型完全匹配，不需要函数模板实例化
	Add(1, 2.0); 	// 模板函数可以生成更加匹配的版本2，编译器根据实参生成更加匹配的Add函数
}

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

---

类模板

格式：

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

这里举例动态顺序表（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){
		// _CheckCapacity();
		_pData[_size++] = data;
	}
	
	void PopBack(){
		--_size;
	}
	
	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;
	}
}

我们所写的这部分代码Vector并不是具体的类，是编译器根据被实例化的类型生成具体类的模具。

实例化

类模板实例化与函数模板实例化不同：

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

// Vector：类名
// Vector<int>：类型
int main(){
	Vector<int> s1;
	s1.PushBack(1);
	s1.PushBack(2);
	s1.PushBack(3);
	Vector<double> s2;
	s2.PushBack(1.0);
	s2.PushBack(2.0);
	s2.PushBack(3.0);
	for(size_t i = 0; i < s1.Size(); ++i){
		cout << s1[i] << " ";
	}
	cout<<endl;
	for(size_t i = 0; i < s2.Size(); ++i){
		cout << s2[i] << " ";
	}
	cout<<endl;
}

输出结果：

1 2 3
1 2 3

说明vector容器的模拟实现与模板类的使用都是没问题的~

---

以上是C++模板的入门了解与使用，在模板（下篇）中我们会讲解非类型模板参数、类模板的特化、类型萃取与模板的分离编译,有兴趣的博友可以传送过去看看~

C++之 模板（下）：【 https://blog.csdn/qq_42351880/article/details/100058806 】