类模板实例（3）

说明：
类的私有成员(private)在类外不可访问，如果要访问：1、提供接口函数；2、设置有元friend
#include<iostream>
#include <typeinfo>  //使用类型获取函数必须包含此头文件
//注意：在c++中，typeid用于获知一个常量或变量的具体类型。（注意：typeid本身是操作符，不是函数！）
using namespace std;
#define INCREMENT 2	  //扩容倍数为当前容量的2倍
template<typename T>
class MyVector {
public:
	MyVector(int capacity = 10);		//构造函数
	MyVector(MyVector<T> &src);		//拷贝构造函数
	template<typename E>
	MyVector(MyVector<E> &src);		//拷贝构造函数的模板
	~MyVector();		//析构函数
	void operator = (MyVector<T> &src);			//等号运算符重载
	template<typename E>		//等号运算符重载的模板
	void operator = (MyVector<E> &src);
	void push_back(T val);		//插入元素
	void show();		//打印输出
private:
	void increase(int size);		//扩容
	void CopyFrom(MyVector<T> &src);	//供拷贝构造函数调用
	template<typename E>		//供拷贝构造函数调用的模板
	void CopyFrom(MyVector<E> &src);	
	T *_pAr;
	int _cursize;
	int _capacity;
	
	template<typename U>		//设置有元便于访问私有成员
	friend class MyVector;
};

//构造函数
template<typename T>
MyVector<T>::MyVector(int capacity)		
{
	cout << "构造函数：MyVector(int capacity)" << endl;
	_pAr = new T[capacity];
	memset(_pAr, 0, sizeof(T)*capacity);
	_cursize = 0;
	_capacity = capacity;
}

//拷贝构造函数
template<typename T>
MyVector<T>::MyVector(MyVector<T>& src)
{	
	cout << "拷贝构造函数：MyVector(MyVector<T>& src)" << endl;
	CopyFrom(src);
}

//拷贝构造函数的模板
template<typename T>
template<typename E>
MyVector<T>::MyVector(MyVector<E> &src) {
	cout << "拷贝构造函数的模板：MyVector(MyVector<E> &src)" << endl;
	CopyFrom(src);
}

//析构函数
template<typename T>
MyVector<T>::~MyVector()
{
	cout << "析构函数：~MyVector()" << endl;
	delete _pAr;
	_cursize = 0;
	_capacity = 0;
}

//等号运算符重载
template<typename T>
void MyVector<T>::operator=(MyVector<T>& src)
{
	cout << "运算符重载：operator=(MyVector<T>& src)" << endl;

	//if (typeid(src).name() == typeid(this).name()&& &src == this)		//防止自赋值，语句有问题，待改正
		//return;
	delete[]_pAr;
	CopyFrom(src);
}

template<typename T>
template<typename E>		//等号运算符重载的模板
void MyVector<T>:: operator = (MyVector<E> &src) {
	cout << "运算符重载模板：operator=(MyVector<E>& src)" << endl;
	//if(typeid.name(src).name() == typeid(this).name() && (&src == this))return
	delete[]_pAr;
	CopyFrom(src);
}

template<typename T>
void MyVector<T>::push_back(T val)
{
	cout << "尾部插入：push_back(T val)" << endl;
	if (_cursize >= _capacity)
		increase(INCREMENT * _capacity);
	_pAr[_cursize++] = val;
}

template<typename T>
void MyVector<T>::show()
{
	cout << "打印输出：show()" << endl;
	for (int i = 0; i < _cursize; ++i) {
		cout << _pAr[i] << endl;
	}
}

//扩容函数
template<typename T>
void MyVector<T>::increase(int size)
{
	cout << "扩容函数：increase(int size)" << endl;
	T *p = _pAr;	//记下待复制的地址
	if(_capacity >= size) return;	//空间只能增加不可减少;因为是成块申请的
	_pAr = new T[size];	//申请新的空间
	_capacity = size;		//容量增加
	for (int i = 0; i < _cursize; ++i)
		_pAr[i] = p[i];
	for (int i = _cursize; i < _capacity; ++i)
		_pAr[i] = T();
	delete[] p;	//将原始的空间释放，避免内存泄露
}

//复制函数:供给拷贝构造函数使用
template<typename T>	
void MyVector<T>::CopyFrom(MyVector<T>& src)		//请传入引用(或者指针)——不会发生拷贝。 要调用复制函数，就必须拷贝实参；拷贝实参又需要调用复制函数。
{
	_pAr = new T[src._capacity];
	_cursize = src._cursize;
	_capacity = src._capacity;
	for (int i = 0; i < _cursize; ++i)
		_pAr[i] = src._pAr[i];
}

//复制函数的模板：供拷贝构造函数使用
template<typename T>
template<typename E>
void MyVector<T>::CopyFrom(MyVector<E> &src)	//复制函数的模板
{
	cout << "复制函数的模板：CopyFrom(MyVector<E> &src)" << endl;
	_capacity = src._capacity;
	_cursize = src._cursize;
	_pAr = new T[_capacity];
	for (int i = 0; i < _cursize; ++i) {
		_pAr[i] = src._pAr[i];	//允许发生强制类型转换
	}
}

/****************************************************************************/
int main()
{
	MyVector<int> vec1;
	MyVector<int>vec2(2);	//构造函数
	MyVector<int>vec3(vec2);	//拷贝构造函数
	vec3 = vec2;

	/*  //用于验证扩容函数
	for (int i = 0; i < 5; ++i) {
		vec2.push_back(i);
	}
	vec2.show();*/
	MyVector<double>vec4;
	vec1 = vec4;
	system("pause");
	return 0;
}
猜你喜欢
