C++ 一个典型的数组类的模板

//错误类型

enum ErrorType

{
    invalidArrySize,
    memoryAllocationError,
    indexOutOfRange
};

//错误信息

char * errMsg[] =
{
    "Invalid array size",
    "Memory allocation error",
    "Invalid index"
};

//数组类的模板声明

template <class T>
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);
};

//成员方法的模板实现

template <class T>
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;
}