C++ 动态创建二维数组指针和多功能数组类

C++ 动态创建二维数组指针

二维数组指针动态创建可以通过以下步骤实现：

1. 定义一个指向二维数组的指针，例如：int **arr;
2. 分配内存空间，使用动态内存分配函数malloc()，例如：arr = (int **)malloc(rows * sizeof(int *));
3. 分配每行的内存空间，使用动态内存分配函数malloc()，例如：for(int i=0; i< rows; i++) arr[i] = (int *)malloc(cols * sizeof(int));
4. 分配每列的内存空间，例如：for(int j=0; j< cols; j++) arr[i][j] = value;

C++ 多功能数组类

以下是一个多功能的数组类的示例代码：

#include <iostream>
#include <cstring>
using namespace std;
class Array {
private:
    int *arr; // 数组指针
    int size; // 数组大小
public:
    // 构造函数
    Array(int s) {
        size = s;
        arr = new int[size];
        memset(arr, 0, sizeof(int) * size); // 初始化数组元素为0
    }
    // 拷贝构造函数
    Array(const Array& a) {
        size = a.size;
        arr = new int[size];
        memcpy(arr, a.arr, sizeof(int) * size);
    }
    // 析构函数
    ~Array() {
        delete[] arr;
    }
    // 重载[]运算符
    int& operator[](int index) {
        return arr[index];
    }
    // 获取数组大小
    int getSize() const {
        return size;
    }
    // 数组元素求和
    int sum() const {
        int res = 0;
        for (int i = 0; i < size; i++) {
            res += arr[i];
        }
        return res;
    }
    // 数组元素求平均值
    double avg() const {
        return (double)sum() / size;
    }
    // 数组元素最大值
    int max() const {
        int res = arr[0];
        for (int i = 1; i < size; i++) {
            if (arr[i] > res) {
                res = arr[i];
            }
        }
        return res;
    }
    // 数组元素最小值
    int min() const {
        int res = arr[0];
        for (int i = 1; i < size; i++) {
            if (arr[i] < res) {
                res = arr[i];
            }
        }
        return res;
    }
    // 重载=运算符
    Array& operator=(const Array& a) {
        if (this == &a) { // 判断是否为自我赋值
            return *this;
        }
        delete[] arr; // 释放旧内存
        size = a.size;
        arr = new int[size];
        memcpy(arr, a.arr, sizeof(int) * size);
        return *this;
    }
};
int main() {
    // 创建一个大小为5的数组
    Array a(5);
    // 给数组赋值
    for (int i = 0; i < a.getSize(); i++) {
        a[i] = i + 1;
    }
    // 输出数组元素
    for (int i = 0; i < a.getSize(); i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    // 输出数组元素求和、平均值、最大值、最小值
    cout << "sum: " << a.sum() << endl;
    cout << "avg: " << a.avg() << endl;
    cout << "max: " << a.max() << endl;
    cout << "min: " << a.min() << endl;
    return 0;
}

运行结果：

1 2 3 4 5
sum: 15
avg: 3
max: 5
min: 1

重载=运算符

以下是一个重载=运算符的示例代码，用于实现对象之间的赋值操作：

Array& operator=(const Array& a) {
    if (this == &a) { // 判断是否为自我赋值
        return *this;
    }
    delete[] arr; // 释放旧内存
    size = a.size;
    arr = new int[size];
    memcpy(arr, a.arr, sizeof(int) * size);
    return *this;
}

其中，参数为另一个Array对象的引用，返回值为当前对象的引用。在函数体中，首先判断是否为自我赋值，若是则直接返回当前对象的引用；否则，先释放旧内存，再分配新内存，并将另一个对象的元素拷贝到当前对象中，最后返回当前对象的引用。