初识C++——模板初阶

1.泛型编程

怎么实现一个通用的交换函数？

void Swap(int a, int b)
{
	int tmp = 0;
	tmp = a;
	a = b;
	b = tmp;
}

void Swap(double a, double b)
{
	double tmp = 0;
	tmp = a;
	a = b;
	b = tmp;
}

void Swap(char a, char b)
{
	char tmp = 'a';
	tmp = a;
	a = b;
	b = tmp;
}

通过函数重载虽然可以实现一个通用的交换函数，但是使用函数重载有几个缺点：

（1）重载的函数依靠类型识别，复用率比较低，一旦出现新的类型，就需要用户自己增加新的重载函数。

（2）代码的维护性比较低，一旦出现错误，可能所有的重载函数都出现错误了。

既然函数重载在复用性上有诸多不便，那我们是否能给编译器编写一个同样的例子，让编译器根据不用的类型利用该例子生成对应的代码。

由此C++就延伸出这样一个概念—泛型编程，编写与类型无关的通用算法。接下来介绍的模板，就是泛型编程的基础。

2.函数模板

2.1函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时根据实参的类型产生对应的函数。

2.2函数模板格式

//template 
//返回值  函数名（参数列表）
//类模板,正常函数调用就行了
template 
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
	return;
}

2.3函数模板的原理

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

编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然

后产生一份专门处理double类型的代码，对于其他内置类型也是如此。

2.4函数模板实例化

用不同的类型参数使用函数模板，生成对应函数的过程就叫做函数模板实例化。模板实例化可以分为隐式实例化和显式实例化。

2.4.1隐式实例化

//函数模板实例化——隐式实例化，编译器自己推演类型
	int a1 = 1;
	int a2 = 10;

	double b1 = 2.0;
	double b2 = 20.11;

	cout << Add(a1, a2) << endl;
	cout << Add(b1, b2) << endl;

2.4.2显式实例化

//显式实例化：在函数名后的<>中指定函数参数的类型。
	int a1 = 1;
	int a2 = 10;

	double b1 = 2.0;
	double b2 = 20.11;

	cout << Add(a1, a2) << endl;
	cout << Add(b1, b2) << endl;

	//函数模板实例化——显式实例化，自己指定类型

	cout << Add(a1, a2) << endl;
	cout << Add(b1, b2) << endl;

	//注意当模板参数列表只有一个参数时，以下形式不能通过,此时要么显示实例化，要么强转
	//Add(a1, b1);

2.5模板函数的匹配机制

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

int Add(int a, int b)
{
	cout << 11111 << endl;
	return a + b;
}

template 
T Add(const T& a, const T& b)
{
	return a + b;
}

int main()
{
	double a = 1;
	double b = 2;
	cout << Add(a, b) << endl;
	return 0;
}

2.5.2对于非模板函数和同名函数，如果其他条件相同，编译器则会优先调用非模板函数而不会从该模板产生一个实例，如果通过模板产生的函数更好匹配，那么将选择模板。

//专门处理int加法的函数
int Add(int a, int b)
{
	cout << 11111 << endl;
	return a + b;
}

//通用加法模板函数
template 
T Add(const T& a, const T& b)
{
	return a + b;
}

int main()
{
	int a = 1;
	int b = 2;
	cout << Add(a, b) << endl;
	return 0;
}

对于非模板函数和同名函数模板，会优先调用已有函数。原理还是比较好理解的，毕竟有现成的肯定用现成的更方便一些。当然，如果函数模板可以产生一个更好匹配的函数，那么会选择函数模板生成的。

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

3.类模板

3.1类模板的定义格式

template 
class A
{
	//类成员
};

3.2类模板的实例化

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

需要在类模板后加<>，然后将实例化的类型放入<>中，类模板名字不是真正的类，经过实例化后的结果才是真正的类。

template  //T是模板参数列表
class A
{
public:
	A(int a)
	
	:_a(a)
	{
		cout << 1 << endl;
	}

	void show();
	
private:
	int _a;
};

//类模板函数在类外定义时，要加上类模板参数列表
template
void show()
{
	cout << 22 << endl;
}

//A不是类型，用A实例化出来的A b(5)才是
A b(5);

int main()
{
	return 0;
}

3.2为什么要使用模板类

（1）模板可以具有非参数类型，用于指定大小，可以根据指定的大小创建动态结构。

（2）模板类与类型无关，可移植性高，只要支持模板语法，模板的代码就是可以移植的。

tip:大家要注意类模板和模板类的区别，类模板是一个类家族，通过类模板实例化出来的具体类才是模板类。