C++写的数组模板类

#ifndef CARRAY_H
#define CARRAY_H


#include<iostream>
using namespace std;

template<class Type>
class CArray {

public:
    //CArray();
    CArray(int length);
    CArray(Type* initArray, const int length);
    ~CArray();
    int length();
    Type min();
    Type max();
    Type operator[](const int index) const;
    bool operator==(const CArray<Type>&) const;
    bool operator=(const CArray<Type>&) const;

private:
    int m_Length;
    Type *p_array;
};

//构造函数1，为数组分配内存
template<class Type>
CArray<Type>::CArray(int length)
{
    p_array = new Type[length];
    m_Length = length;
}

//构造函数2，使用已有数组初始化该数组
template<class Type>
CArray<Type>::CArray(Type* initArray, const int length)
{
    p_array = new Type[length];
    m_Length = length;
    for(int i=0;i<m_Length;i++)
    {
        p_array[i] = initArray[i];
    }
}

//析构函数，删除对象分配的类存
template<class Type>
CArray<Type>::~CArray()
{
    if(p_array != NULL)
    {
        delete[] p_array;
    }
}

//成员函数，返回数组长度信息
template<class Type>
int CArray<Type>::length()
{
    if(p_array != NULL)
    {
        return m_Length;
    }
    else
    {
        return 0;
    }
}

//返回数组的最小值
template<class Type>
Type CArray<Type>::min()
{
    Type minimum;
    if(p_array != NULL)
    {
        minimum = p_array[0];
        for(int i=1;i<m_Length;i++)
        {
            if(p_array[i]<minimum)
                minimum = p_array[i];
        }
        return minimum;
    }
    else
        return 0;
}

//返回数组的最大值
template<class Type>
Type CArray<Type>::max()
{
    Type maximum;
    if(p_array != NULL)
    {
        maximum = p_array[0];
        for(int i=1;i<m_Length;i++)
        {
            if(p_array[i]>maximum)
                maximum = p_array[i];
        }
        return maximum;
    }
    else
        return 0;
}

//通过下标访问数组
template<class Type>
Type CArray<Type>::operator [](const int index) const
{
    if(p_array)
    {
        if(index<m_Length)
            return p_array[index];
        else
            cerr<<"Index exceeds the maximum size!";
    }
    else
    {
        cerr<<"Empty array!";
    }
}
//判断两个数组是否相等
template<class Type>
bool CArray<Type>::operator ==(const CArray& cArr) const
{
    if(m_Length != cArr.m_Length)
    {
        return false;
    }
    else
    {
        for(int i=0;i<m_Length;i++)
        {
            if(p_array[i] != cArr.p_array[i])
            {
                return false;
            }
        }
        return true;
    }
}

//将一个数组赋给另一个数组
template<class Type>
bool CArray<Type>::operator =(const CArray<Type> & cArr) const
{
    if(m_Length != cArr.m_Length || p_array == NULL)
    {
        return false;
    }
    else
    {
        for(int i=0;i<m_Length;i++)
        {
            p_array[i] = cArr.p_array[i];
        }
        return true;
    }
}

#endif