Carry容器的实现

要求存放各类型的数据段(自动识别类型)，不同类型的数据段可以通过拷贝构造函数模板完成拷贝，或是等号运算符重载的模板。(C++中实现)

具体请看代码：

#include<iostream>
using namespace std;


template<typename T>
class Carry
{
public:
	Carry(int resize = 10);//普通构造函数
	~Carry();//析构函数
	Carry(const Carry<T> &src);//拷贝构造函数

	template<typename E>
	Carry(const Carry<E> &src);//拷贝构造函数模板

	void operator=(const Carry<T> &src);//=运算符重载

	template<typename E>
	void operator=(const Carry<E> &src);//=运算符重载的模板

	T &operator[](int pos);//[]运算符重载

	void Insert(T val);//插入数据

	void Show();//打印数据

private:
	void copyfrom(const Carry<T> &src);//数据拷贝的实现

	template<typename E>
	void copyfrom(const Carry<E> &src);//不同类型对象之间的拷贝

	void Resize(int size);//扩容

	T *_arr;
	int _reSize;
	int _eSize;

	template<typename U>
	friend class Carry;
};

template<typename T>
Carry<T>::Carry(int resize = 10)
{
	_reSize = resize;
	_eSize = 0;
	_arr = new T[_reSize];
	
	for (int i = 0; i < _reSize; ++i)
	{
		_arr[i] = T();//初始化
	}
}

template<typename T>
Carry<T>::~Carry()
{
	_reSize = 0;
	_eSize = 0;

	delete []_arr;
}

template<typename T>
void Carry<T>::copyfrom(const Carry<T> &src)
{
	_reSize = src._reSize;
	_eSize = src._eSize;
	_arr = new T[_reSize];

	for (int i = 0; i < _reSize; ++i)
	{
		_arr[i] = src._arr[i];
	}
}

template<typename T>
template<typename E>
void Carry<T>::copyfrom(const Carry<E> & src)
{
	_reSize = src._reSize;
	_eSize = src._eSize;
	_arr = new T[_reSize];
	for(int i = 0; i < _reSize; ++i)
	{
		_arr[i] = src._arr[i];
	}
}

template<typename T>
Carry<T>::Carry(const Carry<T> &src)
{
	cout << "Carry(const Carry<T> &src)" << endl;

	copyfrom(src);
}

template<typename T>
template<typename E>
Carry<T>::Carry(const Carry<E> &src)
{
	cout << "Carry(const Carry<E> &src)" << endl;

	copyfrom(src);
}

template<typename T>
void Carry<T>::operator=(const Carry<T> &src)
{
	cout << "operator=(Carry<T> &src)" << endl;

	if (this == &src)
	{
		return;
	}
	delete _arr;

	copyfrom(src);
}

template<typename T>
template<typename E>
void Carry<T>::operator=(const Carry<E> &src)
{
	cout << "operator=(const Carry<E> &src)" << endl;

	//这里不用考虑自赋值,因为自赋值不会来调用运算符重载函数的模板的

	delete[]_arr;

	copyfrom(src);
}

template<typename T>
T & Carry<T>::operator[](int pos)
{
	return _arr[pos];
}

template<typename T>
void Carry<T>::Insert(T val)
{
	if (_eSize == _reSize)
	{
		Resize(2*_reSize);
	}

	_arr[_eSize++] = val;
}

template<typename T>
void Carry<T>::Resize(int size)
{
	cout << "Reize(int size)" << endl;

	_reSize = size;
	T *p = _arr;
	_arr = new T[_reSize];
	for (int i = 0; i < _eSize; ++i)
	{
		_arr[i] = p[i];
	}

	delete[]p;
}

template<typename T>
void Carry<T>::Show()
{
	for (int i = 0; i < _eSize; ++i)
	{
		cout << _arr[i] << " ";
	}
	cout << endl;
}

int main()
{
	Carry<int>arr1;//调用普通构造

	Carry<int>arr2(arr1);//调用拷贝构造
	arr2 = arr1;//=运算符重载

	for (int i = 0; i < 15; ++i)
	{
		arr1.Insert(i);
	}
	arr1.Show();

	Carry<double>arr3(arr1);//调用拷贝构造的模板函数
	arr3.Show();

	return 0;
}

运行结果：