如何使同一函数同时支持静态数组与动态数组作为参数传入？

直接传递静态二维数组给double**参数可行吗？ #

不行。

静态二维数组double myArray[10][3]在内存中是连续存储的整块数据，本质是包含10个元素的数组，每个元素又是含3个double的数组。当它作为函数参数传递时，会退化为double (*)[3]类型（指向含3个double的数组的指针），而double**是指向double*的指针，两者类型和内存布局完全不兼容：

• double**指向的是存储double*指针的数组，每个指针再指向一行double数据；
• 静态二维数组的首地址直接指向第一行的double数据，而非指针。

如果强制转换类型（比如myFunction((double**)myArray)），函数内访问myArray[i][j]时会错误地把内存中的double值当成指针解引用，导致未定义行为（通常是程序崩溃或数据错误）。

如何用一个函数同时支持静态数组和动态数组？ #

方法1：统一使用连续内存的数组表示（C/C++通用） #

修改函数，让它接受指向数组首元素的指针，同时传入行数和列数：

void myFunction(double* data, size_t rows, size_t cols) {
    // 访问第i行第j列元素：*(data + i * cols + j) 或 data[i*cols + j]
    for (size_t i = 0; i < rows; ++i) {
        for (size_t j = 0; j < cols; ++j) {
            printf("%lf ", data[i * cols + j]);
        }
        printf("\n");
    }
}

• 调用静态数组时，传入数组首元素的地址：

  double staticArr[10][3];
  myFunction(&staticArr[0][0], 10, 3);
  

• 调用动态数组时，改为分配连续的整块内存（而非double**的分散布局）：

  // 分配连续的10*3个double
  double* dynamicArr = new double[10 * 3];
  myFunction(dynamicArr, 10, 3);
  // 记得释放内存
  delete[] dynamicArr;
  

方法2：使用模板函数（仅C++） #

利用模板推导数组类型，同时兼容静态数组和double**动态数组：

#include <cstddef>

template <typename Array>
void myFunction(Array& arr, size_t rows, size_t cols) {
    for (size_t i = 0; i < rows; ++i) {
        for (size_t j = 0; j < cols; ++j) {
            // 静态数组和double**都支持arr[i][j]的访问方式
            printf("%lf ", arr[i][j]);
        }
        printf("\n");
    }
}

• 调用静态数组：

  double staticArr[10][3];
  myFunction(staticArr, 10, 3);
  

• 调用double**动态数组：

  // 传统分散式动态二维数组
  double** dynamicArr = new double*[10];
  for (size_t i = 0; i < 10; ++i) {
      dynamicArr[i] = new double[3];
  }
  myFunction(dynamicArr, 10, 3);
  // 释放内存
  for (size_t i = 0; i < 10; ++i) {
      delete[] dynamicArr[i];
  }
  delete[] dynamicArr;
  

方法3：临时转换静态数组为double**结构（不推荐） #

如果必须保留double**的函数签名，可以手动创建一个指针数组，指向静态数组的每一行：

double staticArr[10][3];
// 创建临时指针数组
double* rowPtrs[10];
for (size_t i = 0; i < 10; ++i) {
    rowPtrs[i] = staticArr[i];
}
// 传递指针数组给函数
myFunction(rowPtrs);

这种方法需要额外的临时数组，每次调用都要初始化，代码冗余且容易出错，仅作为应急方案。

内容的提问来源于stack exchange，提问作者Verardo Matteo