C++初阶模版

一、泛型编程

我们知道在使用C/C++时我们可以根据

我们的需要来写出不同的函数，那么我们如何实现一个通用 的交换函数呢？

下面是一种实现方法：

void Swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

void Swap(double& left, double& right)
{
	double tmp = left;
	left = right;
	right = tmp;
}

void Swap(char& left, char& right)
{
	char tmp = left;
	left = right;
	right = tmp;
}

int main()
{
	int x1 = 0, x2 = 1;
	Swap(x1, x2);
	cout << x1 << " " << x2 << endl;

	return 0;
}

 使用函数重载虽然能够实现，但是有一些缺点的地方：

1.重载的函数仅仅类型不同，代码复用率低，只要有新类型出现，我们就得再实现一个重载

2. 代码的可维护性低， 一个出错可能导致所有的重载都出错

于是在C++中就存在泛型编程这个概念，泛型编程：编写与类型无关的代码，是代码复用的一种手段，模板是泛型编程的基础。

二、函数模板

2.1 函数模板的概念

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

2.2 函数模板的格式

template<typename T1, typename T2, ...typename Tn>

返回值类型 函数名（参数列表）

{

        函数体；

}

 下面是一个具体的模板实例：

//模板交换函数
template<typename T>
void Swap(T& left, T& right)
{
	T tmp = left;
	left = right;
	right = tmp;
}
int main()
{
	int x1 = 0, x2 = 1;
	Swap(x1, x2);
	cout << x1 << " " << x2 << endl;

	return 0;
}

注意：typename是用来定义模版参数的关键字， 也可以使用class。

例如：

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

2.3 函数模板的原理

函数模板是一个蓝图， 它本身并不是函数，是编译器用于产生特定的具体类型函数的模具，所以模板本质上其实是编译器替我们实现了不同类型的重载函数。

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

2.4 函数模板实例化

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

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

下面的就是隐式实例化的例子：

//模板求和函数
template<typename T>
T Add(const T& left, const T& right)
{
	return left + right;
}

int main()
{
	int x1 = 0, x2 = 1;
	Swap(x1, x2);
	cout << x1 << " " << x2 << endl;


	int a1 = 10, a2 = 20;
	double b1 = 10.0, b2 = 20.0;
	Add(a1, a2);
	Add(b1, b2);

	//下面的这条语句是不能通过编译的
	/*Add(a1, b1);*/
	//通过a1编译器将T推断为int类型，通过b1编译器将T推断为double类型，但是只有一个T
	//编译器会因为无法确定T是int还是double而报错

	//可以通过强制类型转换，来解决这个问题
	//也可以通过显式实例化来解决这个问题
	Add(a1, (int)b1);

	return 0;
}

这里的一些注意事项我写在代码注释里了，大家在看代码实例时可以留意一下。

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

使用显式实例化的话，编译器就不会再去推算模板参数的类型了。

//模板求和函数
template<typename T>
T Add(const T& left, const T& right)
{
	return left + right;
}


void test()
{
	int a = 10;
	double b = 30.0;

	//显式实例化
	cout << Add<int>(a, b) << endl;
}

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

2.5 模板参数的匹配原则

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

通过下面的实例我们就能看出：

//非模板函数
int Add(int left, int right)
{
	return left + right;
}

//模板求和函数
template<typename T>
T Add(const T& left, const T& right)
{
	return left + right;
}
void test1()
{
	//不指定的话就与非模板函数匹配，不需要编译器通过模板实现
	Add(1, 2);
	//使用显式实例化指定的话就使用编译器通过模板实现的版本
	Add<int>(1, 2);
}

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

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

三、类模板

3.1 类模板的定义格式

template<class T1, class T2, ..., class Tn>

class 类模板名

{

        类内成员定义；

}；

 我们来看下类模板的代码实例：

template<class T>
class Vector
{
public:
	//构造
	Vector(size_t capacity = 0)
		:_pData(new T[capacity])
		, _size(0)
		, _capacity(capacity)
	{}
	//析构(定义在类外）
	~Vector();


private:
	T* _pData;
	size_t _size;
	size_t _capacity;
};

//注意：类模板中的函数定义在类外时需要加上模板参数列表
template <class T>
Vector<T> :: ~Vector()
{
	if (_pData)
		delete[] _pData;
	_size = _capacity = 0;
}

3.2 类模板实例化

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

下面是实例化的具体操作：

void test_class()
{
	//Vector是类模板名， Vector<int>才是类型
	Vector<int> s1;
	Vector<double> s2;
	Vector<char> s3;
}

对于模板，不建议声明和定义分离到.h和.cpp两个文件中，会出现链接错误，最好声明和定义在一个文件中，可以在同一个文件中进行声明和定义分离，比如：在.h文件中进行声明和定义分离，但是不能跨文件进行声明定义分离。