c++杂记：二维数组传参、面向对象编程替代宏定义方法

1、传递静态二维数组的方法

#include <iostream>
using namespace std;
const int ROWS = 3;
const int COLS = 4;

void processStaticArray(int (&arr)[ROWS][COLS]) {
    // 处理静态数组的函数实现
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    int staticArray[ROWS][COLS] = {{1, 2, 3, 4},
                                    {5, 6, 7, 8},
                                    {9, 10, 11, 12}};
    processStaticArray(staticArray);
    return 0;
}

2、传递动态二维数组的方法

• 在动态数组的情况下，使用 int** 类型的指针，并在main函数中动态分配和释放内存。

#include <iostream>
using namespace std;
const int ROWS = 3;
const int COLS = 4;

void processDynamicArray(int** arr, int rows, int cols) {
    // 处理动态数组的函数实现
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    // 动态分配二维数组
    int** dynamicArray = new int*[ROWS];
    for (int i = 0; i < ROWS; ++i) {
        dynamicArray[i] = new int[COLS];
    }
    // 初始化动态数组
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            dynamicArray[i][j] = i * COLS + j + 1;
        }
    }
    // 传递动态数组给函数
    processDynamicArray(dynamicArray, ROWS, COLS);
    // 释放动态分配的内存
    for (int i = 0; i < ROWS; ++i) {
        delete[] dynamicArray[i];
    }
    delete[] dynamicArray;
    return 0;
}

• 在实际应用中，可以使用 std::vector 或 std::vector<std::vector> 来更安全地管理动态数组。

3、替代宏定义功能的方法

• 面向对象编程中，替代宏定义的方法：使用静态常量成员变量或枚举常量。

// 使用静态常量成员变量
class MyClass {
public:
    static const int MAX = 10;  // 常量成员变量
    void myFunction(int (&dp)[MAX][MAX]) {
        // 函数实现
    }
};

在这种方法中，使用了类的静态常量成员变量，它与宏定义相似，但可以实现更好的作用域控制，确保类型安全。

// 使用枚举常量
class MyClass {
public:
    enum { MAX = 10 };  // 匿名枚举
    void myFunction(int (&dp)[MAX][MAX]) {
        // 函数实现
    }
};

4、函数调用返回数组方法

• （1）使用指针作为参数传入，修改原数组

// 使用指针传入数组
void modifyArray(int* arr, int size) {
    // 对arr进行操作，修改其元素值
}
// 调用函数
int main() {
    const int SIZE = 5;
    int myArr[SIZE]; 
    modifyArray(myArr, SIZE); // 调用函数
    return 0;
}

• （2）使用动态分配方式创建新的数组并返回，由调用者管理内存释放。

#include <iostream>
using namespace std;
// 在函数中动态创建新数组并返回
int* createAndReturnArray(int size) {
    int* newArr = new int[size]; // 创建动态数组
    for (int i = 0; i < size; ++i) {
        newArr[i] = 0; // 数组初值需手动赋值
    }     
    return newArr;
}
 
// 调用函数
int main() {
    const int SIZE = 5;
    int* resultArr = createAndReturnArray(SIZE); // 调用函数
    
    cout << "Result array elements:" << endl;
    for (int i = 0; i < SIZE; ++i) {
        cout << resultArr[i] << " ";
    }
    cout << endl;
    
    delete[] resultArr; // 手动释放内存
    
    return 0;
}