类模板

        类模板也称作参数化类型或者容器，因为它们需要一个或多个参数类型，来说明如何自定义一个用于产生类模板特化的通用类模板。想要产生多个类模板特化，只需要定义一个类模板。当需要一个特定的类模板特化时，使用简洁的表示方法，编译器就会写出类模板特化的源代码。

       类模板和函数模板类似，也具有以下特点：

1. 类模板不编译
2. 模板的作用域只在当前

      类模板与函数模板很大的区别在于：类模板不存在隐式实例化，在实例化的时候必须提供参数类型

1、类模板中成员方法的模板和类模板中成员方法的模板特例化

2、拷贝构造函数的模板和特例化

3、类中模板的成员方法的模板的特例化不允许在类外实现

举例：实现一个数组类模板，可以根据不同参数实例化为不同类型的数组，其中提供了相关方法的模板和特例化。

# include<string.h>
# include<iostream>
using namespace std;
# define Size 10

template<typename T>
class Carry
{
public:
	Carry()
	{
		_arr = new T[Size];
		_count = Size;
		_size = 0;
	}
	~Carry()
	{
		delete[]_arr;
		_arr = NULL;
		_size = 0;
	}
	Carry(const Carry &src)
	{
		delete[]_arr;
		_arr = new T[src._count];
		for (int i = 0; i < src._count; i++)
		{
			_arr[i] = src._arr[i];
		}
		_arr = src._count;
		_size = src._size;
	}
	Carry &operator = (const Carry& src)
	{
		if (src == *this)
		{
			return *this;
		}
		delete[]_arr;
		_arr = new T[src._count];
		for (int i = 0; i < src._count; i++)
		{
			_arr[i] = src._arr[i];
		}
		_arr = src._count;
		_size = src._size;
	}
	void pushBack(T val)
	{
		if (isFull())
		{
			reSize();
		}
		_arr[_size++] = val;
	}
	void insert(int sit, T val)
	{
		if (isFull())
		{
			reSize();
		}
		int i = 0;
		for (i = _size; i > sit; i--)
		{
			_arr[i] = _arr[i - 1];
		}
		_arr[i] = val;
		_size++;
	}
	bool popBack()
	{
		if (isEmpty())
		{
			cout << "数组空，删除失败" << endl;
			return false;
		}
		_size--;
		return true;
	}
	bool deleteSit(int sit)
	{
		if (isEmpty())
		{
			cout << "数组空，删除失败" << endl;
			return false;
		}
		for (int i = sit; i < _size; i++)
		{
			_arr[i] = _arr[i + 1];
		}
		_size--;
	}
	T getBack()
	{
		return _arr[_size - 1];
	}
	bool isFull()
	{
		if (_size == _count)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool isEmpty()
	{
		if (_size == 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	void reSize()
	{
		T *brr = new T[_count * 2];
		for (int i = 0; i < _size; i++)
		{
			brr[i] = _arr[i];
		}
		delete[]_arr;
		_arr = brr;
		_count *= 2;
	}
	void show()
	{ 
		for (int i = 0; i < _size; i++)
		{
			cout << _arr[i] << " ";
		}
		cout << endl;
	}

	template<typename T>
	int find(T val)
	{
		cout << "int find(T val)" << endl;
		for (int i = 0; i < _size; i++)
		{
			if (_arr[i] == val)
			{
				return i;
			}
		}
		return - 1;
	}
	template<>
	int find<char *>(char *val)
	{
		cout << "int find<char *>(char *val)" << endl;
		for (int i = 0; i < _size; i++)
		{
			if (strcmp(_arr[i], val) == 0)
			{
				return i;
			}
		}
		return - 1;
	}
private:
	T *_arr;
	int _size;//当前元素大小
	int _count;//数组大小
};