C++类模板

类模板的实现可以使得我们一份代码到处使用，无视类型的区别。

这便是模板存在的意义。

一个栈的类模板的举例：

#include <iostream>
using namespace std;

template<typename T=int>//指定T的默认类型是int
class SeqStack//模板名称+类型参数列表 = 类名称
{
public:
	//构造和析构不用加<T> 其他出现模板的地方都加上类型参数列表
	SeqStack(int size = 10) 
		: _size(size)
		, _top(0)
		, _pstack(new T[size])
	{}
	~SeqStack()
	{
		delete[]_pstack;
		_pstack = nullptr;
	}
	SeqStack(const SeqStack<T> &stack)
		:_size(stack._size)
		,_top(stack._top)
	{
		_pstack = new T[_size];
		//不要用memcopy进行拷贝
		for (int i = 0; i < _top; ++i)
		{
			_pstack[i] = stack._pstack[i];
		}
	}
	SeqStack<T>& operator=(const SeqStack<T> &stack)
	{
		//防止自赋值
		if (this == &stack)
			return *this;

		delete[]_pstack;

		_top = stack._top;
		_size = stack._size;
		_pstack = new T[_size];
		for (int i = 0; i < _top; i++)
		{
			_pstack[i] = stack._pstack[i];
		}
		return *this;
	}
	void push(const T &val);
	
	void pop()
	{
		if (empty())
			return;
		--_top;
	}
	T top()const
	{
		if (empty())
			throw "stack is empty!";//抛出异常也代表函数逻辑结束
		return _pstack[_top - 1];
	}
	bool full()const { return _top == _size; }
	bool empty()const { return _top == 0; }
private:
	T *_pstack;
	int _top;
	int _size;
	//顺序栈底层数组按2倍进行扩容操作

	void expand()
	{
		T *ptmp = new T[_size * 2];
		for (int i = 0; i < _top; i++)
		{
			ptmp[i] = _pstack[i];
		}
		delete[]_pstack;
		_pstack = ptmp;
		_size *= 2;
	}
};
template<typename T>//在类外定义类模板函数须在函数前写T的声明。
void SeqStack<T>::push(const T &val)
{
	if (full())
	{
		expand();
	}
	_pstack[_top++] = val;
}
int main()
{
	//类模板的选择性实例化
	SeqStack<> s1;//由于我们在定义前定义了T的默认类型为int所以我们这里的<>可以不写内容
	s1.push(20);
	s1.push(78);
	s1.push(32);
	s1.push(15);
	s1.pop();
	cout << s1.top() << endl;
}