C++动态数组类模板

深藏阁楼爱情的钟 2022-02-16 03:48 205阅读 0赞

/*------------------------
    功能：实现动态数组类模板
    示例运行结果：
    1 2 3 4 5 6 7 8 9 0
    1 2 3 4 5 6 7 8 9 0
    --------------------------
    Author: Zhang Kaizhou
    Date: 2019-4-21 17:19:00
    -------------------------*/
    #include <iostream>
    #include <cassert>
    #include <iomanip>
    #include <cmath>
    
    using namespace std;
    
    template<class T> // 定义一个动态数组类模板
    class Array{
    private:
        T * list; // 存放为数组动态分配的内存块的首地址
        int size;
    public:
        Array(int size = 50); // 构造函数
        Array(const Array<T> & a); // 复制构造函数
        ~Array(); // 析构函数
        Array<T> & operator =(const Array<T> & rhs); // 重载=
        T & operator [](int i); // 重载[]
        const T & operator [](int i) const; // 重载[]为常函数
        operator T *(); // 重载到T * 类型的转换
        operator const T *() const;
        int getSize() const;
        void reSize(int sz);
    };
    
    template<class T> // 类模板构造函数的实现
    Array<T>::Array(int sz){
        assert(sz >= 0); //断言语句判定数组长度应为非负
        size = sz;
        list = new T[size]; // 用new关键字动态分配size个T类型的内存空间，并将首地址赋值给list成员变量
    }
    
    template<class T> // 类模板析构函数的实现
    Array<T>::~Array(){
        delete [] list; // 在析构函数中释放以list为首地址的一块大小为size的内存空间
    }
    
    template<class T> // 类模板复制函数的实现
    Array<T>::Array(const Array<T> &a){
        size = a.size;
        list = new T[size];
        for(int i = 0; i < size; i++){
            list[i] = a.list[i];
        }
    }
    
    template<class T> // 重载=运算符的实现
    Array<T> & Array<T>::operator =(const Array<T> &rhs){ // 将对象rhs赋值给当前对象，实现两个对象的整体赋值
        if(&rhs != this){ // 若当前对象与rhs对象不是同一个对象(即未占用相同的内存空间)
            if(size != rhs.size){ // 重置当前对象的数组大小为rhs对象的大小，并重新为其分配空间
                delete [] list;
                size = rhs.size;
                list = new T[size];
            }
            for(int i = 0; i < size; i++){ // 逐个复制数组数据
                list[i] = rhs[i];
            }
        }
        return * this; // 返回当前对象的引用
    }
    
    template<class T> // 重载下标运算符[]，使其可通过[]访问数组元素，并具有越界检查功能
    T & Array<T>::operator [](int n){
        assert(n >= 0 && n < size); // 断言语句进行越界检查
        return list[n]; // 返回下标为n的数组元素
    }
    
    template<class T> // 重载下标运算符[]，使其可通过[]访问数组元素，并具有越界检查功能，将其定义为常函数，只能读取数组元素，而不能改变数组元素
    const T & Array<T>::operator [](int n) const{
        assert(n >= 0 && n < size); // 断言语句进行越界检查
        return list[n]; // 返回下标为n的数组元素
    }
    
    template<class T> // 重载指针转换运算符 "类型名 *"，将Array类的对象名转换为T类型的指针
    Array<T>::operator T *(){
        return list; // 返回当前对象的list数组的首地址
    }
    
    template<class T> // 返回当前数组的大小
    int Array<T>::getSize() const{
        return size;
    }
    
    template<class T> // 修改数组大小为sz
    void Array<T>::reSize(int sz){
        assert(sz >= 0);
        if(sz == size){
            return;
        }
        T * newList = new T[sz];
        int n = sz < size ? sz : size;
        for(int i = 0; i < n; i++){
            newList[i] = list[i];
        }
        delete[] list;
        list = newList;
        size = sz;
    }
    
    int main(){
        Array<int> a(10); // 利用Array类模板实例化一个对象a，并指定a对象中的数组类型为int，初大小为10
        for(int i = 0; i < a.getSize(); i++){
            cin >> a[i];
        }
        for(int i = 0; i < a.getSize(); i++){
            cout << a[i] << " ";
        }
        cout << endl;
    
        return 0;
    }