在第3讲作业2动态整型数组类 CArray 上增加对下标运算符、赋值运算符的重载： ‍ 在动态整型数组类 CArray 中，添加深拷贝构造函数 ‍ 设计一个动态整型数组类 CArray ，并对CArray类进行测试 ‍ 数据成员： ‍ int *vec; // 动态数组指针 ‍ int size; //动态数组规模 ‍ 成员函数：public ‍ CArray(int n); // 构造函数，构造规模为n的数组 ‍ CArray (CArray &arr); //拷贝构造函数 ‍ ~CArray(); //析构函数，释放动态数组空间 ‍ int length(); // 取数组元素个数 ‍ int get(int i); // 取数组第i个元素 ‍ void set(int i, int value); // 设置数组第i个元素 ‍ int getMax(); // 取数组最大元素 ‍ int getMin(); // 取数组最大元素 ‍ void print(); //输出动态数组的所有元素 ‍ int & operator[](int); ‍ CArray & operator=( const CArray &arr); ‍ ​ ‍

下面是增加对下标运算符、赋值运算符的重载后的CArray类的实现：

#include <iostream>

using namespace std;

class CArray {
private:
    int *vec;           // 动态数组指针
    int size;           // 动态数组规模
public:
    CArray(int n) {     // 构造函数，构造规模为n的数组
        vec = new int[n];
        size = n;
    }

    CArray(CArray &arr) {   // 拷贝构造函数
        vec = new int[arr.size];
        size = arr.size;
        for (int i = 0; i < size; i++) {
            vec[i] = arr.vec[i];
        }
    }

    ~CArray() {     // 析构函数，释放动态数组空间
        delete[] vec;
    }

    int length() {      // 取数组元素个数
        return size;
    }

    int get(int i) {    // 取数组第i个元素
        return vec[i];
    }

    void set(int i, int value) {    // 设置数组第i个元素
        vec[i] = value;
    }

    int getMax() {      // 取数组最大元素
        int max = vec[0];
        for (int i = 1; i < size; i++) {
            if (vec[i] > max) {
                max = vec[i];
            }
        }
        return max;
    }

    int getMin() {      // 取数组最小元素
        int min = vec[0];
        for (int i = 1; i < size; i++) {
            if (vec[i] < min) {
                min = vec[i];
            }
        }
        return min;
    }

    void print() {      // 输出动态数组的所有元素
        for (int i = 0; i < size; i++) {
            cout << vec[i] << " ";
        }
        cout << endl;
    }

    int& operator[](int i) {    // 重载下标运算符
        return vec[i];
    }

    CArray& operator=(const CArray& arr) {    // 重载赋值运算符
        if (this == &arr) {     // 防止自我赋值
            return *this;
        }
        if (vec) {      // 释放原有的动态数组空间
            delete[] vec;
        }
        vec = new int[arr.size];
        size = arr.size;
        for (int i = 0; i < size; i++) {
            vec[i] = arr.vec[i];
        }
        return *this;
    }
};

下面是CArray类的测试代码：

int main() {
    CArray arr1(5);
    for (int i = 0; i < 5; i++) {
        arr1[i] = i;
    }
    cout << "arr1: ";
    arr1.print();

    CArray arr2 = arr1;
    cout << "arr2: ";
    arr2.print();

    CArray arr3(3);
    arr3 = arr1;
    cout << "arr3: ";
    arr3.print();

    arr1[2] = 10;
    cout << "arr1: ";
    arr1.print();
    cout << "arr2: ";
    arr2.print();
    cout << "arr3: ";
    arr3.print();

    return 0;
}

输出结果：

arr1: 0 1 2 3 4 
arr2: 0 1 2 3 4 
arr3: 0 1 2 3 4 
arr1: 0 1 10 3 4 
arr2: 0 1 2 3 4 
arr3: 0 1 2 3 4 

从输出结果可以看出，CArray类的下标运算符重载和赋值运算符重载都正常工作。