1.泛型编程

如何实现一个通用的交换函数？
这点函数重载可以做到，比如一下Swap函数的重载，分别重载了俩种不同参数类型的Swap

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

void Swap(char& x, char& y)
{
	char tmp = x;
	x = y;
	y = tmp;
}

但是这也带来了几点不好的地方：

1.重载的函数仅仅是类型不同，代码的复用率比较低，只要有新类型出现，就需要增加对应的函数

2.代码的可维护性比较低，一个出错可能所有的重载均出错

那么有什么好的解决方法吗？我们能否告诉编译器一个模子，让编译器根据不同类型利用该模子自己去生成相应的代码呢？

当然能，这就是泛型编程，即编写与类型无关的通用代码，这是代码复用的一种手段。而模板是泛型编程的基础。模板分为两种，函数模板和类模板。

2.函数模板

概念

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

函数模板的格式
template<typename T1, typename T2,......,typename Tn>

即：返回值类型 函数名(参数列表){}

其中typename可以改成class（不能用struct）

例：

template <typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

函数模板的原理

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

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

函数模板的实例化

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

隐式实例化

让编译器自己推演函数参数的类型。

需要注意的是隐式实例化的参数一定要匹配，否则可能产生分歧导致编译器无法识别。比如：

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


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

	Add(a1, b2);

	return 0;
}

编译器报错，该语句不能通过编译,因为无法确定T是int还是double。

如何处理？有两种方式：
1.强制类型转换！但值得注意的是，强转会产生临时变量，临时变量是具有常性的，需要const修饰一下！

2.使用显式实例化

显式实例化

在函数名后的< >中指定模板参数的实际类型。

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

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

	cout<<Add<int>(a1, b2)<<endl;

	return 0;
}

模板参数的匹配原则

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

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

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

• 如果有定义出来的函数,且类型完全匹配调用时实参类型,则执行定义出来的函数.
• 如果定义出来的函数,不符合,则执行模板推演.

这部分没啥难度，不再举例说明，总的来说，对于函数调用的优先级就是：完全匹配 >模板匹配 >转换匹配。

3.类模板

(1) 类模板的定义格式

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

注意：

类模板中函数放在类外进行定义时，需要加模板参数列表；

template <typename T>
class Stack
{
public:
	Stack(int capacity = 4)
		:_a(new T[capacity])
		,_top(0)
		,_capacity(capacity)
	{}
	~Stack()
	{
		delete[] _a;
		_top = _capacity = 0;
	}
	void Push(T x);
private:
	T* _a;
	int _top;
	int _capacity;
};

// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <typename T>
void Stack<T>::Push(T x)
{
	if (_top == _capacity)
	{
		_capacity *= 2;
		T* tmp = (T*)realloc(_a, sizeof(int) * _capacity);
		if (tmp == nullptr)
		{
			cout << "realloc fail" << endl;
			exit(-1);
		}
		_a = tmp;
	}
	_a[_top++] = x;
}

对于普通类，类名就是类型；对于类模板，类名不是类型，类型是Class < T >

(2) 类模板的实例化

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

int main()
{
	// Stack只是类名，不是类型，Stack<int>才是类型
	Stack<int> s1;
	Stack<char> s2;
	return 0;
}

4.非类型模板参数

类型参数：就是在模板的参数列表中在class后面加上参数的类型名称。
非类型参数：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

注意两点：

1.浮点数、类对象以及字符串是不允许作为非类型模板参数的。
2.非类型的模板参数必须在编译期就能确认结果。

template<class T =int, size_t N = 10>
class array
	{
		 private:
	 	 T _array[N];
		 size_t _size;
	 }

5.模板特化

（1）函数模板的特化

当针对某一情景或者某一类型，函数模板无法满足要求，模板需要有特殊的处理，这个时候就需要用到模板的特化。

比如咱们要比较两个字符串是否相同：

template<class T>
bool IsEqual(T str1, T str2)
{
	return str1 == str2;
}

int main()
{
	char str1[] = "hello";
	char str2[] = "hello";

	if (IsEqual(str1, str2))
		cout << "true";
	else
		cout << "false";
}

上述代码输出false， 不满足咱们的要求， 因为调用函数IsEqual()时传递过去的是两个char*类型，他们两个比较的不是字符串的内容，而是指针的地址，所以返回false。

此时模板特化派上用场了：如果要比较char*, 可以用strcmp来对这个情况进行特殊处理

template<>
bool IsEqual<char*>(char* str1, char* str2)
{
	return strcmp(str1, str2) == 0;
}

此时就返回true， 符合预期了。

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同

（2）类模板的特化

类也是同理，如果需要有特殊情景也需要特化处理
以如下类举例(后边全特化、偏特化都针对它）：

template<class T1, class T2>
class test
{
public:
	test()
	{
		cout << "test<T1, T2>" << endl;
	}

private:
	T1 _x;
	T2 _y;
};

全特化

全特化即是将模板参数列表中所有的参数都确定化。
例如：
这里对test<int,double>版本特化

template<>
class test<int, double>
{
public:
	test()
	{
		cout << "test<int, double>" << endl;
	}

private:
	int _x;
	double _y;
};

int main()
{
	test<double, double> t1;
	test<int, double> t2;
}

偏特化

偏特化即是任何针对模版参数进一步进行条件限制设计的特化版本
偏特化有两种表现方式，一种是部分参数特化，一种是参数修饰特化

部分参数特化

这里对第二个参数特化，只要第二个参数是double就会调用对应特化版本

template<class T1>
class test<T1, double>
{
public:
	test()
	{
		cout << "test<T1, double>" << endl;
	}

private:
	T1 _x;
	double _y;
};
int main()
{
	test<double, double> t1;
	test<int, double> t2;
}

参数修饰特化

比如用指针或者引用来修饰类型，也可以进行特化

template<class T1, class T2>
class test<T1*, T2*>
{
public:
	test()
	{
		cout << "test<T1*, T2*>" << endl;
	}

private:
	T1* _x;
	T2* _y;
};

int main()
{
	test<int*, double*> t;
}

6.模板的分离编译

对于一个代码量比较多的项目，通常都会采用声明与定义分离的方法，比如在头文件进行声明，在源文件完成代码的实现，最后通过链接的方法链接成单一的可执行文件。但是C++的编译器却不支持模板的分离编译，一旦进行分离编译，就会出现链接错误。

问题分析

//头文件a.h
template<class T>
bool IsEqual(const T& str1, const T& str2);

-------------
//源文件a.cpp
template<class T>
bool IsEqual(const T& str1, const T& str2)
{
	return str1 == str2;
}
--------------
//test.c
#include<iostream>
#include"a.h"
using namespace std;

int main()
{
	cout << IsEqual(3, 5);

	cout << IsEqual('a', 'b');
}

这里看上去是没有问题的，但是涉及到了模板的实例化规则。

当主函数调用这个函数的时候他就会去头文件中找到函数的声明，再通过声明找到a.h中的实现。
但是对于模板却并不会这样，因为上一章说过，模板的实例化只会在其第一次使用的时候才会进行，例如这里IsEqual(3, 5),他就会去头文件中寻找，但是头文件中只有声明，没有定义，无法将其实例化。他又想通过找到a.cpp中的函数定义来进行实例化，但是遗憾的是，a.cpp中只有IsEqual(const T& str1, const T& str2)的定义，没有IsEqual(const int & str1, const int T& str2)，因为在a.cpp中并没有使用到该类型的实例，所以自然也不会为其实例化出来，这时test.cpp中就根本无法找到这个函数的实现，就导致了链接失败。

解决方法:

这个问题其实没有什么完美的解决方法

1. 将声明和定义放到同一个头文件中。
2. 类模板显式实例化。

问题的，但是涉及到了模板的实例化规则。

当主函数调用这个函数的时候他就会去头文件中找到函数的声明，再通过声明找到a.h中的实现。
但是对于模板却并不会这样，因为上一章说过，模板的实例化只会在其第一次使用的时候才会进行，例如这里IsEqual(3, 5),他就会去头文件中寻找，但是头文件中只有声明，没有定义，无法将其实例化。他又想通过找到a.cpp中的函数定义来进行实例化，但是遗憾的是，a.cpp中只有IsEqual(const T& str1, const T& str2)的定义，没有IsEqual(const int & str1, const int T& str2)，因为在a.cpp中并没有使用到该类型的实例，所以自然也不会为其实例化出来，这时test.cpp中就根本无法找到这个函数的实现，就导致了链接失败。

解决方法:

这个问题其实没有什么完美的解决方法

1. 将声明和定义放到同一个头文件中。
2. 类模板显式实例化。