C++：模板的相关内容

本篇介绍一部分关于C++中模板使用的问题，模板是C++的一大特色，需要在实际运用中体会它的妙处

泛型编程

为了知道什么是泛型编程，先来看，如何实现对于所有类型都使用的交换函数？

在C语言中这个实现是不可以的，因为没有函数重载，在C++中引入了函数重载的概念，根据函数参数的类型不同在寻找符号表的时候函数名不同，因此构成了函数重载，即使使用函数重载可以解决这个问题，函数重载依旧有很多弊端，比如同样的代码语句逻辑一摸一样，只有最后的函数参数的类型和函数体中的类型不一样，因此这里引入了模板的概念：

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码

因此就有了函数模板的概念

函数模板

格式：

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

因此swap函数就可以写成

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

这里需要注意的是，typename是用来定义模板参数关键字，也可以使用class

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

那实际函数调用的时候，编译器调用的是同一个函数吗，其实并不是这样

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

类模板

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

非类型模板参数

模板参数主要有两种，一种是类型形参，另外一种是非类型形参

• 类型形参：出现在模板参数列表中，也就是在class或者typename后面的参数类型名称就是类型形参
• 非类型形参：用一个常量作为类模板的一个参数，在类模板中可以将该参数作为常量来使用

namespace static_array
{
	// 定义一个模板类型的静态数组
	template<class T, size_t N = 10>
	class array
	{
	public:
		T& operator[](size_t index) 
		{ 
			return _array[index]; 
		}
		const T& operator[](size_t index) const 
		{ 
			return _array[index]; 
		}
		size_t size() const 
		{ 
			return _size; 
		}
		bool empty() const 
		{ 
			return 0 == _size; 
		}
	private:
		T _array[N];
		size_t _size;
	};
}

以上面的为例，通过这样的非类型模板参数可以实现定义一个常量的功能

值得注意的有下面两点：

1. 浮点数，类对象和字符串不能作为非类型模板参数
2. 非类型模板参数必须在编译前就确定，因为编译器要根据这个值开辟空间等操作

模板的特化

什么是模板的特化？

模板可以缩减代码的重复性，也就是可以实现一些和类型不相关的代码，但是也会有特殊的情况，比如说对于一些特殊的类型就会得到一些错误的结果，如果遇到这种情况该如何处理呢？

C++就引入了特化的概念，对于特殊的情况可以采用特殊的结果进行处理，那么有什么场景可以对这些进行使用？

以下面的例子为例：

#include 
using namespace std;

template <class T>
bool Less(T a, T b)
{
	return a < b;
}

int main()
{
	int p = 2;
	int q = 1;
	cout << Less(1, 2) << endl;
	cout << Less(1.1, 2.2) << endl;
	cout << Less(&p, &q) << endl;
	return 0;
}

运行结果如下

问题此时就出现了，对于模板来说，它可以比较各种类型的值，但是对于指针类型来说，它只能把指针的地址当成一个值来进行比较，因此是无法得到正确的结果的，此时可以用特化的原理来解决问题：

#include 
using namespace std;

template <class T>
bool Less(T a, T b)
{
	return a < b;
}

template <>
bool Less<int*>(int* a, int* b)
{
	return (*a) < (*b);
}

int main()
{
	int p = 2;
	int q = 1;
	cout << Less(1, 2) << endl;
	cout << Less(1.1, 2.2) << endl;
	cout << Less(&p, &q) << endl;
	return 0;
}

运行结果如下

上面的写法就是函数模板的特化，有下面一些需要注意的步骤

• 必须有一个基础的函数模板
• 关键字template后要带一个尖括号
• 函数名后要带尖括号，内容是要被特化的类型
• 函数的参数表要和模板函数的基础参数类型完全相同，才能实现函数模板的特化

注意，一般不使用函数特化，为了实现简单都是直接将函数给出，这样更加便携

#include 
using namespace std;

template <class T>
bool Less(T a, T b)
{
	return a < b;
}

// 直接给出函数，这样阅读起来更加便捷，可读性更高
bool Less(int* a, int* b)
{
	return (*a) < (*b);
}

int main()
{
	int p = 2;
	int q = 1;
	cout << Less(1, 2) << endl;
	cout << Less(1.1, 2.2) << endl;
	cout << Less(&p, &q) << endl;
	return 0;
}

模板的分离编译

类模板中的成员函数是不支持分离编译的：

原因在于，类模板其实是没有进行实例化的，所以本身是找不到的，因此是找不到函数的

模板的优点

1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
2. 增强了代码的灵活性

模板的缺点

1. 模板会导致代码膨胀问题，也会导致编译时间变长
2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误