//错误类型
enum ErrorType
{invalidArrySize,
memoryAllocationError,
indexOutOfRange
};
//错误信息
{
"Invalid array size",
"Memory allocation error",
"Invalid index"
};
//数组类的模板声明
class Array
{
private:
T* alist; //存放动态分配的数组内存的首地址
int size; //元素个数
void Error(ErrorType error, int badIndex = 0) const; //错误处理函数
public:
Array(int sz = 50); //默认构造函数
Array(const Array<T> & A); 拷贝构造函数
~Array(void);
Array<T> & operator=(const Array<T> &rhs); //等号运算符重载
T& operator[](int j); //下标运算符重载
int ListSize(void) const;
void Resize(int sz);
};
//成员方法的模板实现
void Array<T> :: Error(ErrorType error,int badIndex) const
{
cout << errMsg[error];
if(error == indexOutOfRange)
{
cout << badIndex;
}
cout << endl;
exit(1);
}
template <class T>
Array<T> :: Array(int sz)
{
if(sz <= 0)
{
Error(invalidArrySize , sz);
}
size = sz;
alist = new T[size];
if(alist == NULL)
{
Error(memoryAllocationError, 1);
}
}
template <class T>
Array<T> :: Array(const Array<T> & A)
{
size = A.size;
alist = new T[size];
if(alist == NULL)
{
Error(memoryAllocationError, 1);
}
T *ptr = A.alist;
T *p = alist;
for(int i = 0; i < size; i++)
{
*p++ = *ptr++;
}
}
template <class T>
Array<T> :: ~Array(void)
{
delete [] alist;
}
template <class T>
Array<T> & Array<T> :: operator=(const Array<T> &rhs)
{
if(size != rhs.size)
{
delete [] alist;
alist = new T[rhs.size];
if(NULL == alist)
{
Error(memoryAllocationError, 1);
}
size = rhs.size;
}
T* ptr = rhs.alist;
T* p = alist;
for(int i = 0; i < size; i++)
{
*p++ = *ptr++;
}
return *this;
}
template <class T>
T& Array<T> :: operator[](int j)
{
if(j < 0 || j >= size)
{
Error(indexOutOfRange, j);
}
return alist[j];
}
template <class T>
int Array<T> :: ListSize(void) const
{
return size;
}
template <class T>
void Array<T> :: Resize(int sz)
{
if(sz <= 0)
{
Error(invalidArrySize);
}
if(size == sz)
{
return;
}
T *newlist = new T[sz];
T *ptr = newlist;
T *p = alist;
int n = (sz < size)? sz : size;
for(int i = 0; i < n; i++)
{
*ptr++ = *p++;
}
size = sz;
delete [] alist;
alist = newlist;
}