泛型编程的概念讲解以及如何实现

先理解一下为什么要进行泛型编程？
例如：我们要实现一个交换函数，但是在使用过程中，可能需要对多个不同类型的参数进行交换。比如第一次需要交换两个整型变量，第二次需要交换两个字符变量，第三次需要交换浮点型…
在C++里面我们可以通过函数重载来实现，函数重载可以通过传入的参数类型不同来进行调用相应的函数。函数重载如下：

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

但是通过函数重载来实现不同类型的数据交换，有以下几个缺点：

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

这个时候就引发了一个思考：能否告知诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码？

因此出现了泛型编程的概念：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

模板分为两种：函数模板和类模板

函数模板

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
函数模板格式：
template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){}

//函数模板
//T：模板参数
template <typename T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}
void test()
{
	int a = 1, b = 2;
	char d = 'm', e = 'n';
	double f = 1.2, g = 2.5;
	Swap(a,b);
	Swap(d,e);
	Swap(f,g);
}

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

函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。
隐式实例化：
让编译器根据实参推演模板参数的实际类型
即：在进行函数调用的时候不需要指定参数的类型，编译器会根据传入参数的类型来自己推演模板参数的类型。

//函数模板
//T：模板参数
template <typename T>
T add(T& left, T& right)
{
	return left + right;
}
void test()
{
	int a = 1, b = 2;
	char d = 'm', e = 'n';
	double f = 1.2, g = 2.5;
	add(a,b);
	add(d,e);
	add(f,g);
}

在进行同类型相加时可以使用隐式实例化，但是当传入的参数不同类型时，模板参数列表中只有有一个T，编译器无法确定此处到底该将T确定为哪一个参数。
此时有两种处理方式：
1.用户自己进行强制转化

Add(a, (int)f);

2.使用显式实例化
显式实例化：编译器不能进行类型推导的时候
在函数名后的<>中指定模板参数的实际类型

// 显式实例化
Add<int>(a, f);

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

template <class T1, class T2, class T3>
void print(const T1& a, const T1& b, const T1& c)
{
	cout << a << b << c << endl;
}


void test()
{
	int a = 1, b = 2;
	char d = 'm', e = 'n';
	double f = 1.2, g = 2.5;
	print(a, b, d);
	print(d, f, a);
}

模板参数的匹配规则：

1. 优先匹配普通函数
2. 如果函数模板可以实例化一个更加匹配的函数，则走实例化
3. 如果指明需要进行实例化，则直接实例化

类模板

类模板的定义格式和函数模板定义类似：

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

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类
通俗理解就是：在进行类的实例化的时候，要给定参数类型

seqList<int> sq(10);
seqList<double> sq2(10);

实例讲解：

template<class T>
class seqList
{
public:
	seqList(int n)
	:_data(new T[n])
	, _size(0)
	, _capacity(n)
	{}
	
	T seqListAt(size_t pos);
private:
	//int* _data; 
	T* _data;
	size_t _size;
	size_t _capacity;
};
//注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template<class T>
T seqList::seqListAt(size_t pos)
{
	return _data[pos];
}

void test()
[
	//错误写法
	//seqList sq;
	//正确写法：需要给定类型
	//类模板实例化之后，真正的类型 --> 类名<模板参数类型>
	seqList<int> sq(10);
	seqList<double> sq2(10);
	
}