理解向量vector的一些实现细节

#include <iostream>

using namespace std;

enum ErrorType
{
	invalidArraySize, memoryAllocFail, indexOutOfRange
};

const char*ErrorList[]={"invalidArraySize","memoryAllocFail","indexOutOfRange"};

template <class T>
class MyVector
{
public:
	MyVector(int sz=50);
	MyVector(const MyVector<T>& V);
	~MyVector();
	MyVector& operator=(const MyVector& V);
	T& operator[](int i);
	operator T*(); // 实现强制类型转换 MyVector---> T*;
	int Size();
	void resize(int sz);
	void Error(ErrorType err);
private:
	T *Array;
	int size;
};

template<class T>
void MyVector<T>::Error(ErrorType err)
{
	cout << ErrorList[err] << endl;
	exit(1);
}

template<class T>
MyVector<T>::MyVector<T>(int sz)
{
	if(sz<=0)
	{
		Error(invalidArraySize);
	}
	else
	{
		size = sz;
		Array = new T[size];
		if(Array==NULL)
			Error(memoryAllocFail);
		
	}
	
}

template<class T>
MyVector<T>::MyVector(const MyVector<T>& V)
{
	int n = V.size;
	size = n;
	Array = new T[n];
	if(Array==NULL)
		Error(memoryAllocFail);

	T*org_array = Array;
	T*new_array = V.Array;

	while(n--)
		*org_array++ = *new_array++;
}

template<class T>
MyVector<T>::~MyVector()
{
	delete [] Array;
}

template<class T>
MyVector<T>& MyVector<T>::operator=(const MyVector<T>& V)
{
	int n = V.size;
	if(size!=n)
	{
		delete[] Array;
		size = n;
		Array = new T[size];
		if(Array==NULL)
			Error(memoryAllocFail);
	}

	T* org_Array = Array;
	T* new_Array = V.Array;

	while(n--)
		*org_Array++ = *new_Array++;

	return *this;
}

template<class T>
T& MyVector<T>::operator[](int i)
{
	if(i<0 || i>=size)
		Error(indexOutOfRange);

	return Array[i];
}

template<class T>
MyVector<T>::operator T*()
{
	return Array;
}

template<class T>
void MyVector<T>::resize(int sz)
{
	if(sz<=0)
		Error(invalidArraySize);

	if(size == sz) return;

	int n=(sz<size)?sz:size;

	T* org_Array = Array;
	T* new_Array = new T[sz]();
	if(new_Array==NULL)
		Error(memoryAllocFail);

	T* tmp = new_Array;
	while(n--)
		*tmp++ =*org_Array++;
	//	*new_Array++ = *org_Array++;  // 这句话无法赋值？？？原因是啥？

	delete[] Array;
	Array = new_Array;
	size = sz;
}

template<class T>
int MyVector<T>::Size()
{
	return size;
}

int main()
{
	MyVector<int> V1(5);

	for(int i=0; i<V1.Size(); i++)
		cin>>V1[i];

	MyVector<int> V2 = V1;   // 拷贝构造函数,相当于V2(V1);
	MyVector<int> V3;        // 默认构造函数
	V3 = V2;  // 复制运算 operator=

	MyVector<int> V4(V3);    // 拷贝构造函数;

	cout << "V2======\n";
	for(int i=0; i<V2.Size(); i++)
		cout << V2[i] << " ";
	cout << endl;

	cout << "V3======\n";
	for(int i=0; i<V3.Size(); i++)
		cout << V3[i] << " ";
	cout << endl;

	cout << "V4======\n";
	for(int i=0; i<V4.Size(); i++)
		cout << V4[i] << " ";
	cout << endl;

	V1.resize(10);
	
	cout << "================\n";
	for(int *p=V1; p<V1+10; p++)
		cout << *p << endl;
	return 0;
}