C++中的函数模板和类模板

---

一、泛型编程是什么？

我们想要实现一个简单的交换函数，但是要交换的变量类型不确定，可能是int、double、char等，如果是c语言，我们就得为每一种变量类型创建一个swap函数并且函数名还不能相同，因为C语言不支持函数重载,在C++中我们可以使用函数重载，这样可以一定程度上提高效率

void swap(int& a, int& b)
{
	int x = a;
	a = b;
	b = x;
}

void swap(double& a, double& b)//构成函数重载
{
	double x = a;
	a = b;
	b = x;
}
int main()
{
	int a = 2, b = 3;
	swap(a, b);
	double c = 2.0, d = 3.0;
	swap(c, d);

	return  0;
}

但是函数重载依然有它的局限性：

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

为此C++提出了泛型编程的概念

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础
可以将泛型编程理解为一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码）

---

二、函数模板

函数模板概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本,函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器
函数模板格式：template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){}

上面的交换函数可以用函数模板写成

template<typename T>//template<class T>模板参数列表--参数类型
void Swap( T& left, T& right)//函数参数列表
{
 	T temp = left;
 	left = right;
	 right = temp;
}

typename也可以换成class,但是有些地方也是有区别的
template < class T > 是模板参数列表–也就是参数类型，可以有多种参数类型，比如template < class T1,class T2 >
T就是数据类型，可以是int、char、double

这三个函数虽然共用一个模板，但是调的不是同一个函数，其实是三个不同的函数

三、函数模板的实例化

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

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


int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.2;
	cout << Add(a1, d1) << endl;
	cout<<Add(a2, d2)<<endl;
	return  0;
}

该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型,通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错
这时候有两种处理方法：
1.用户自己来强制转换，比如将double转换成int或者将int转换成double使两个参数类型相同
2.使用显式实例化 ，即告诉编译器使用的模板类型，如Add< int >(a1,d2)或者Add< doeble >(a2,d2)
3.在模板的参数列表再加一个参数 如template< class T1,class T2 >

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

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

int main(void)
{
 int a = 10;
 double b = 20.0;
 
 // 显式实例化
 Add<int>(a, b);
 return 0;
}

显式实例化 ，即告诉编译器使用的模板类型,这里就告诉编译器使用int类型的函数模板

四、模板参数的匹配原则

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); // 与非模板函数匹配，编译器不需要特化 也就是调用专门处理int的加法函数，不需要函数模板实例化
 Add<int>(1, 2); // 调用编译器特化的Add版本
 Add(1,2.0); 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数,只需将上面的模板参数列表加上一个class T2
}

当函数模板和普通函数都可以满足调用需求的时候，编译器会优先调用普通函数，这样可以避免模板实例化带来的开销，如果模板可以产生一个具有更好匹配的函数， 那么将选择模板**

---

五、类模板

在C语言中，假设我们写了一个栈的数据结构，那么这个栈中元素只能是一种指定的元素，也就是说，在一个.cpp文件下我们无法同时定义存储int类型的栈和double类型的栈,除非我们特定指定stackint结构体或者stackdouble结构体
但是在c++我们可以利用类模板在一个.cpp文件中创建多个不同类型的stack类

template<class T>
class Vector//vector是类名，vector<T>是类型
{
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()//告诉编译器这是vector<T>类的析构函数
{
	if (_pData)
		delete[] _pData;
	_size = _capacity = 0;
}

如此一来，我们只要写一份vector类的实现就可以实现各种数据类型的vector了，只需在实例化vector对象的时候在后面加上<>，<>中加上我们想要使用的数据类型如int、double即可

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

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

---

总结

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