c++学习---Array模板类和带越界检查的ArrayRC模板类(类2)

写了一个Array模板类和一个要检查ArrayRC模板类，可以用它声明int、double、char。更复杂的暂时没有写。

ArrayT.h文件，无越界检查模板类。

#ifndef ArrayT_H
#define  ArrayT_H
// #include <iostream>
// using namespace std;

template  < class  elemType >
class  Array
... {
public:
    //构造函数
    Array(int sz = DefaultSize/**//*elemType()---0*/);
    Array(elemType* pa,int size);
    Array(const Array& par);
    //析构函数
    ~Array();
    //相等与不相等操作
    bool operator==(const Array& par) const;
    bool operator!=(const Array& par) const;
    
    //赋值操作
    Array& operator=(const Array& par);
    
    //取数组大小
    int size()...{return _size;}
    //访问特定数组
    virtual int find(elemType value);
    //重载[]符号
    virtual elemType& operator[](int index)...{return pArray[index];}
    //void aaaaa(){cout<<"IntArray::aaaaa()!";}
protected:
    //初始化数据函数
    void Initial(elemType* pa,int size);
    int _size;
    elemType* pArray;
    static const int DefaultSize;
} ;

template  < class  elemType >
const   int  Array < elemType > ::DefaultSize  =   12 ;

// 初始化函数
template  < class  elemType >
void  Array < elemType > ::Initial(elemType *  pa, int  size)
... {
    //assert(size>0&&pa);
    //申请空间
    _size = size;
    pArray = new elemType[_size];
    //拷贝数据
    for(int i = 0; i<_size;++i)
    ...{
        if(!pa)
        ...{
            pArray[i]=0;
        }
        else
        ...{
            pArray[i] = pa[i];
        }
    }
}
// 构造函数
template  < class  elemType >
Array < elemType > ::Array( int  sz)
... {
    Initial(0,sz);
}

template  < class  elemType >
Array < elemType > ::Array(elemType *  pa, int  size)
... {
    Initial(pa,size);
}

// 析构函数
template  < class  elemType >
Array < elemType > :: ~ Array()
... {
    delete[] pArray;
}

template  < class  elemType >
Array < elemType > ::Array( const  Array < elemType >&  par)
... {
    Initial(par.pArray,par._size);
}

// 查找特定数值
template  < class  elemType >
int  Array < elemType > ::find(elemType value)
... {
    //assert(index>0);
    for(int i=0;i<_size;++i)
    ...{
        if(pArray[i]==value)
        ...{
            return i;
        }
    }
    return -1;
}
// 重载==
template  < class  elemType >
bool  Array < elemType > :: operator == ( const  Array < elemType >&  par)  const
... {
    if(_size!=par._size)
    ...{
        return false;
    }
    for(int i=0;i<_size;++i)
    ...{
        if(pArray[i]!=par.pArray[i])
        ...{
            return false;
        }
    }
    return true;
}
// 重载!=
template  < class  elemType >
bool  Array < elemType > :: operator != ( const  Array < elemType >&  par)  const // ??常成员函数可以调用非常变量
... {
    if(_size!=par._size)
    ...{
        return true;
    }
    for(int i=0;i<_size;++i)
    ...{
        if(pArray[i]!=par.pArray[i])
        ...{
            return true;
        }
    }
    return false;
}

// 重载=
template  < class  elemType >
Array < elemType >&  Array < elemType > :: operator = ( const  Array < elemType >&  par)
... {
    if(this != &par)
    ...{
        //先释放资源
        Array<elemType>::~Array();
        Initial(par.pArray,par._size);
    }
    return *this;
}

#endif

ArrayTRC.h文件，带越界检查的模板类

#ifndef ArrayTRC_H
#define  ArrayTRC_H

#include  " ArrayT.h "
#include  < cassert >

template  < class  elemType >
class  ArrayRC: public  Array < elemType >
... {
public:
    //构造函数
    ArrayRC(int sz = Array<elemType>::DefaultSize):Array<elemType>(sz)...{}
    ArrayRC(elemType* pa,int size):Array<elemType>(pa,size)...{}
    ArrayRC(const ArrayRC& par):Array<elemType>(par.pArray,par._size)...{}
    virtual int& operator[](int index);
private:
    void check_range(int index);
} ;

template  < class  elemType >
int &  ArrayRC < elemType > :: operator []( int  index)
... {
    check_range(index);//检查越界
    return pArray[index];
}

template  < class  elemType >
void  ArrayRC < elemType > ::check_range( int  index)
... {
    assert(index>=0&&index<_size);//检查越界
}

#endif

最后，测试一下

#include  " ArrayT.h "
#include  " ArrayTRC.h "
#include  < iostream >

using   namespace  std;

int  main()
... {
    int ddm[5] = ...{1,2,3,4,5};
    int eem[5] = ...{5,4,3,2,1};
    //int
    Array<int> d;
    Array<int> a(ddm,5);
    Array<int> b(eem,5);
    Array<int> c(a);
    cout<<"Array<int>: ";
    cout<<"a.size:"<<a.size()<<endl;
    cout<<"a[4]="<<a[4]<<" ";
    d=c;
    if(a!=b)
    ...{
        cout<<"a!=b"<<" ";
    }
    else
    ...{
        cout<<"a==b"<<" ";
    }
    
    if(c==d)
    ...{
        cout<<"c==d"<<" ";
    }
    else
    ...{
        cout<<"c!=d"<<" ";
    }
    
    cout<<"c.size:"<<c.size()<<endl;
    cout<<"c[4]="<<c[4]<<" ";
    
    cout<<"d.size:"<<d.size()<<endl;
    cout<<"d[5]="<<d[5]<<" ";//无越界检查

    //ArrayRC类
    cout<<"ArrayRC: ";
    ArrayRC<int> li(ddm,5);
    cout<<"li[5]:"<<li[5]<<" ";//越界了


    char ddw[5] = ...{'a','b','c','d','e'};
    char eew[5] = ...{'e','d','c','b','a'};
    //char
    Array<char> dd;
    Array<char> aa(ddw,5);
    Array<char> bb(eew,5);
    Array<char> cc(aa);
    cout<<"Array<char>: ";
    cout<<"aa.size:"<<aa.size()<<endl;
    cout<<"aa[4]="<<aa[4]<<" ";
    dd=cc;
    if(aa!=bb)
    ...{
        cout<<"aa!=bb"<<" ";
    }
    else
    ...{
        cout<<"aa==bb"<<" ";
    }
    
    if(c==d)
    ...{
        cout<<"cc==dd"<<" ";
    }
    else
    ...{
        cout<<"cc!=dd"<<" ";
    }
    
    cout<<"cc.size:"<<cc.size()<<endl;
    cout<<"cc[4]="<<cc[4]<<" ";
    
    cout<<"dd.size:"<<dd.size()<<endl;
    cout<<"dd[1]="<<dd[1]<<" ";
    return 0;
}