float (*somethingAsMatrix)[2] = (float (*)[2]) matrixReturnAsArray;

字符串

float *可以指向浮点数组的第一个元素，并且应该是reinterpret_castable到该数组类型。该转换的结果可以指向float [][]的第一个元素，因此应该是reinterpret_castable到该类型，等等。您应该能够组合这样的转换，然后直接执行

float (&arr)[2][2] = *reinterpret_cast<float (*)[2][2]>(matrixReturnAsArray);

字符串
float **类型的参数是不一样的，不应该这样使用。
为了避免未定义的行为，指针必须来自实际的多维数组，如果直接使用float*，则只能访问多维矩阵的第一行。

void foo(float *f) {
    f[3] = 10.;

    float (&arr)[2][2] = *reinterpret_cast<float (*)[2][2]>(f);
    arr[1][1] = 10.;
}

void main() {
    float a[2][2];
    foo(&a[0][0]); // f[3] = 10.; is undefined behavior, arr[1][1] = 10. is well defined

    float b[4];
    foo(&b[0]); // f[3] = 10.; is well-defined behavior, arr[1][1] = 10. is undefined
}

型
给定float arr[2][2];，没有什么能保证&arr[0][1] + 1与&arr[1][0]相同，就我所能确定的而言。所以尽管你可以通过执行f[i*width + j]来将一维数组用作多维数组，但你不能将多维数组视为一维数组。
最好使用C++的编译时类型安全，而不是仅仅依赖于不意外地传递错误的东西或执行错误的reinterpret_cast。为了使用raw-arrays获得类型安全，你应该使用对你想要的raw数组类型的引用：

void foo(float (&f)[2][2]) {}
void foo(float (&f)[3][3]) {}

型
如果你想通过值传递数组，你不能使用原始数组，而应该使用像std：：array这样的东西：

void foo(std::array<std::array<float,2>,2> f) {}
void foo(std::array<std::array<float,3>,3> f) {}

型

这种类型的类型转换总是更干净，更容易处理，并明智地使用typedef：

typedef float Matrix_t[2][2];

Matrix_t* someThingAsMatrix = (Matrix_t*) matrixReturnAsArray;

字符串
如果这是C++而不是C，你应该创建一个矩阵类（或者更好的是，寻找一个开源类）。

如果我是对的：

typedef float Matrix_t[2][2];  
Matrix_t &matrix = *(Matrix_t *)matrixReturnAsArray;

字符串
或

float (&matrix2)[2][2] = *(float ( *)[2][2])matrixReturnAsArray;

型
在C语言中，只有指针的方式

Matrix_t *someThingAsMatrix = (Matrix_t *)matrixReturnAsArray;

型
并通过以下方式访问：

(*someThingAsMatrix)[1][0] = ...

型