template的使用

1、template的使用

C++ 的高级玩法，当然包含了模板。模板（template）是实现代码重用机制的一种工具，它可以实现类型参数化，把类型定义为参数（模板元编程），从而实现了真正的代码可重用性。

模板是用来批量生成功能和形式都几乎相同的代码的。编译器就能在需要的时候，根据模板自动生成程序的代码。从同一个模板自动生成的代码，形式几乎是一样的。 模板就像一个做饼干的模具，至于饼干是什么味道，则要看具体实例化时制作饼干的材料。

模板可以分为两类，一个是函数模板，另外一个是类模板。

1.1、函数模板

函数模板比较简单，下面我们来看一个两者交换的例子就明白了:

template<typename T>
void swap(T& t1, T& t2)
{
	T temp = t2;
	t2 = t1;
	t1 = temp;
}

1.2、类模板

类模板比函数模板稍微复杂一下，主要是实现时的书写，如下面的代码:

//stack.h
template<typename T>
class Stack
{
public:
	Stack();
	~Stack();
	void push(T t);
	T pop();
	bool isEmpty();
private:
	T* m_pT;
	int	m_maxSize;
	int m_size;
};

//Stack.cpp
#include "Stack.h"

template<typename T>
Stack<T>::Stack()
{
	m_maxSize = 100;
	m_size = 0;
	m_pT = new T[m_maxSize];
}

template<typename T>
Stack<T>::~Stack()
{
	delete[] m_pT;
	m_pT = nullptr;
}

template<typename T>
void Stack<T>::push(T t)
{
	m_size++;
	m_pT[m_size - 1] = t;
}

template<typename T>
T Stack<T>::pop()
{
	T t = m_pT[m_size - 1];
	m_size--;
	return t;
}

template<typename T>
bool Stack<T>::isEmpty()
{
	return m_size == 0;
}

上述类模板是模仿了一个栈，这个栈很简单，最多只能支持100个元素入栈。

通过上面的例子可知，在类模板中，通用类型可以作为普通成员变量，也可以作为成员函数的参数和返回值。

2、模板的实例化与具象化

2.1、实例化

模板的实例化有两种形式，分别是 显示实例化 和 隐式实例化。

显示实例化 就是直接命令编译器创建特定的实例。在使用模板之前，编译器会根据显示指定的类型生成模板实例。显示实例化有两种写法，具体如下：

template void swap2<int>(int& a, int& b); //声明时显示实例化，只需要声明，不需要实现

int a = 1, b= 2;
swap<int>(a, b);	//使用时显示实例化

隐式实例化 类似普通的函数调用，在使用模板时，根据使用的类型，编译器进行推导，生成相应类型的实例。方便程序员的书写，但是增加编译器的负担。如下所示：

swap(a, b);	//隐式实例化，和显示实例化的结果是一样的

2.2、具象化（专业化）

具象化就是模板中特化性质。例如上面书写的交换函数，如果传入的是char* 类型，使用 = 操作只是复制了指针数据，指针指向的内存有可能会失效，所以 = 操作可能会出现问题，我们需要进行单独的操作。如下:

<pre class="prettyprint"><code class="has-numbering" onclick="mdcp.copyCode(event)" style="position: unset;">template&lt;&gt;
void swap2(char*&amp; a, char*&amp; b)
{
//具象化
.....
}

具象化的定义应该在有常规模板的情况下，以 template<> 打头，通过名称来指出类型，并必须要有具体的实现。

函数在调用的过程时，编译器调用顺序是：常规函数 > 具体化模板函数 > 常规模板。

3、其它

一个类没有模板参数，但是成员函数有模板参数是可行的。代码如下：

class Util
{
public:
	template<class T>
	bool equal(T t1, T t2)
	{
		return t1 == t2;
	}
};

int main()
{
	Util aab;
	std::cout << aab.equal<int>(a, b) << std::endl;
	std::cout << aab.equal(1, 1) << std::endl;
}

在类模板的例子中栈的最大元素数量是写死的，可以使用模板的偏特化特性来自定义元素的最大数量。如下所示

template<typename T, int maxsize = 100>
class Stack
{
	//和上面的例子一样
	.....
}

template <class T,int maxsize>	//这里和上面的不一样
Stack<T, maxsize>::Stack()
{
   m_maxSize = maxsize;      	//最大数量通过外面传入
   m_size = 0;
   m_pT = new T[m_maxSize];
}

int main()
{
	int maxsize = 1024;
	Stack<int,1024> intStack;
	for (int i = 0; i < maxsize; i++) 
    	intStack.push(i);
}