C++模板一

前言

再写模板之前我们先来回忆一下以前我们在将函数重载是说过，在C++中是可以允许同名函数存在，只要函数参数个数，类型其中之一不同，就可以实现不同的函数功能。
看看代码，回忆回忆：

int Add(int left, int right)
{
	return left + right;
}
double Add(double left, double right)
{
	return left + right;
}
char Add(char left, int right)
{
	return left + right;
}
int main()
{
	int i = 10;
	int j = 20;
	cout << Add(i, j) << endl;
	cout << Add(10.0, 20.0) << endl;
	cout << Add('a', 1) << endl;
	return 0;
}

这里输入的第二个应该是编译器给优化的，不影响。

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

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

那我们就会想否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
引出一个概念：
泛型编程：代码复用的一种手段。模板是泛型编程的基础。

一、函数模板

基本概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定 类型版本。
格式：templete <class T1,class T2, …>
按需分配，这里也可以用 typename，是为了和后面的类模板做区分，但是绝对不能用struct

template <class T,class T2>
T Add(T left, T2 right)
{
	return left + right;
}
int main()
{
	int i = 10;
	int j = 20;
	cout << Add(i, j) << endl;
	cout << Add(10.0, 20.0) << endl;
	cout << Add('a', 1) << endl;
	return 0;
}

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

给张图理解一下：

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供 调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然 后产生一份专门处理double类型的代码，对于字符类型也是如此。
1.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.0, d2 = 20.0;   
	Add(a1, a2);    
	Add(d1, d2); 

	//显式实例化 在函数名后的<>中指定模板参数的实际类
	Add<int>(a1, d1);
	return 0;
}

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

1.2 函数模板匹配规则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函 数
2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模 板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

二、类模板

2.1 类模板格式

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

具体实例：

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

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

int main()
{	
	// Vector类名，Vector<int>才是类型
	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;
	return 0;
}