二维动态数组函数传参

二维动态数组可以通过指针传递给函数，函数的参数声明应该是指向指针数组的指针，例如：

void func(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 rows = 3, cols = 4;
    int **arr = new int*[rows];
    for (int i = 0; i < rows; i++) {
        arr[i] = new int[cols];
        for (int j = 0; j < cols; j++) {
            arr[i][j] = i * cols + j;
        }
    }
    func(arr, rows, cols);
    return 0;
}

输出结果为：

0 1 2 3 
4 5 6 7 
8 9 10 11 

在函数内部，可以通过 `arr[i][j]` 访问二维数组中的元素。

相关问题

c++动态二维数组怎么传参

在C++中，动态二维数组作为参数传递时通常会遇到困难，因为函数参数默认是按值传递的，这意味着原数组不会被修改，而是创建一个新的副本。如果你想让函数能直接操作到动态二维数组的内容，可以考虑以下几种方式：

1. **引用传递**：通过引用(&)传递数组地址，这样函数内部可以直接修改原数组。

void processArray(int(&arr)[rows][cols]) {
   // arr现在是一个指向二维数组的引用，可以直接访问元素
   arr[0][0] = someValue;
}

int main() {
    int rows, cols;
    int (*dynamicArr)[cols] = new int[rows][cols];
    // 初始化动态数组...
    processArray(*dynamicArr);
    //...
    delete[] dynamicArr;  //别忘了释放内存
}

2. **指针传递**：如果数组大小是已知的，可以使用指针和指针数组传递，但同样需要处理指针的生命周期。

void processArray(int** arr, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            arr[i][j] = someValue;  // 直接访问元素
        }
    }
}

int main() {
    int rows, cols;
    int* dynamicArr[rows];
    for (int i = 0; i < rows; i++) {
        dynamicArr[i] = new int[cols];  // 分配每个行的内存
        // 初始化...
    }
    processArray(dynamicArr, rows, cols);
    //...
    for (int i = 0; i < rows; i++) {
        delete[] dynamicArr[i];  // 逐行释放内存
    }
    delete[] dynamicArr;  // 总体上释放所有指针
}

C++二维数组怎么传参

在C++中，二维数组通常作为函数参数传递时，有两种常见的方式：

1. **通过引用（Pass by reference）**：
如果你需要修改原数组，可以将二维数组名作为引用传递。例如：

   void processArray(int(&array)[rows][columns]) {
       // 在函数内部可以直接操作array
       for (int i = 0; i < rows; ++i) {
           for (int j = 0; j < columns; ++j) {
               array[i][j] *= 2; // 修改元素值
           }
       }
   }

   int main() {
       int arr[4][5];
       // 填充数组...
       processArray(arr);
       // 数组内容已经被修改了
   }

2. **通过指针（Pass by pointer）**：
另一种方法是传递指向二维数组首元素的指针。这种方式允许函数直接访问数组，但不会影响到原始数组：

   void processArray(int (*array)[columns], int rows) {
       for (int i = 0; i < rows; ++i) {
           for (int j = 0; j < columns; ++j) {
               array[i][j] += 1; // 只能读取和修改副本
           }
       }
   }

   int main() {
       int arr[4][5];
       // 填充数组...
       processArray(arr, 4); // 指针指向arr数组
       // arr数组未受影响
   }