如何将指针转换为C数组引用且避免未定义行为？

能否在不触发未定义行为的前提下，将堆上分配的内存转换为C数组的引用？

我在堆上分配了4个double类型元素，希望将其视为2×2的C数组（例如用于传递给函数）。目前我使用了reinterpret_cast进行转换，是否存在比reinterpret_cast更温和的替代方案？

// Type your code here, or load an example.
double f(double(&ref)[2][2]) {
    return ref[0][0] + ref[1][1];
}


int main() {
    double* data = new double[4];
    data[0] = 1; data[1] = 1; data[2] = 1; data[3] = 1;

    auto& array = reinterpret_cast<double(&)[2][2]>(*data);
//  auto& array = *reinterpret_cast<double(*)[2][2]>(data);

    f(array);
    delete[] data;
}

clang-tidy建议完全不要使用reinterpret_cast。

Sonar Lint指出这种reinterpret_cast的使用属于未定义行为，提示信息如下：

dereference of type 'double *[2][2]' that was reinterpret_cast from type 'double *' has undefined behavior

你代码里的reinterpret_cast确实会触发未定义行为——C++标准不允许将一维数组的指针/引用直接强制转换为多维数组的引用，因为二者的对象类型不匹配，这种类型转换后的解引用违反了严格别名规则。

下面是几种安全的替代方案：

1. 直接分配二维数组 #

直接在堆上分配2×2的二维数组，这样可以直接得到合法的多维数组引用，完全不需要类型转换：

double f(double(&ref)[2][2]) {
    return ref[0][0] + ref[1][1];
}

int main() {
    double(*data)[2] = new double[2][2];
    data[0][0] = 1; data[0][1] = 1;
    data[1][0] = 1; data[1][1] = 1;

    f(*data);
    delete[] data;
}

这里new double[2][2]返回的是指向包含2个double的数组的指针，解引用后就是合法的double[2][2]类型引用，可以直接传给函数f。

2. 使用std::array包装 #

如果偏好更现代的C++风格，可以用std::array来管理堆上的二维数组，其底层内存布局和原生数组兼容，能安全传递给接受数组引用的函数：

#include <array>

double f(double(&ref)[2][2]) {
    return ref[0][0] + ref[1][1];
}

int main() {
    auto* data = new std::array<std::array<double, 2>, 2>();
    (*data)[0][0] = 1; (*data)[0][1] = 1;
    (*data)[1][0] = 1; (*data)[1][1] = 1;

    f(*reinterpret_cast<double(*)[2][2]>(std::data(*data)));

    delete data;
}

如果可以修改函数f的参数类型为std::array<std::array<double,2>,2>&，会更优雅且完全避免转换操作。

3. 调整函数参数类型 #

如果允许修改函数f，可以将其参数改为接受一维数组指针/引用，在函数内部手动计算索引，完全规避类型转换问题：

double f(double* data) {
    // 手动模拟二维数组索引：data[i*2 + j]对应ref[i][j]
    return data[0*2 + 0] + data[1*2 + 1];
}

int main() {
    double* data = new double[4];
    data[0] = 1; data[1] = 1; data[2] = 1; data[3] = 1;

    f(data);
    delete[] data;
}

4. 使用std::span（C++20及以上） #

如果项目支持C++20，用std::span包装一维数组，在函数内部将其视为二维视图，既安全又灵活：

#include <span>

double f(std::span<double, 4> data) {
    auto row0 = data.subspan(0, 2);
    auto row1 = data.subspan(2, 2);
    return row0[0] + row1[1];
}

int main() {
    double* data = new double[4];
    data[0] = 1; data[1] = 1; data[2] = 1; data[3] = 1;

    f(std::span<double,4>(data, 4));
    delete[] data;
}

std::span是对内存区域的安全视图，不需要额外内存分配，还能清晰表达数组的维度信息。

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