假设我们有一个二维的int数组：
int a[3][4] = { { 1,3,2,4 }, { 2,1,5,3 }, { 0,8,2,3 } };
将其地址引用并重新解释为指向一维int数组的指针合法吗？基本上是：
int *p = reinterpret_cast<int *>(&a);
这样我就可以做一些类似于以下的事情（大致上）：
template<typename T, size_t X, size_t Y>
void sort2(T(&arr)[X][Y])
{
T *p = reinterpret_cast<T *>(&arr);
std::sort(p, p + X*Y);
}
据我所知，标准保证2D数组的对齐方式在内存中是连续的，虽然 p + X*Y 技术上超出了范围，但由于从未访问过，因此不应导致未定义行为。
当需要时，我是否可以将2D数组绝对视为1D数组？
如果两个对象可以相互转换指针，则它们具有相同的地址，并且可以通过 reinterpret_cast 从一个指针获得另一个指针。[注：即使数组对象和其第一个元素具有相同的地址，它们也不能相互转换指针。—end note]
然后在reinterpret_cast页面上，有以下带有示例的备注：
假设满足对齐要求，reinterpret_cast 在处理涉及指针可互换对象的少数局限情况外，不会改变指针的值：
int arr[2];
int* p5 = reinterpret_cast<int*>(&arr); // value of p5 is unchanged by reinterpret_cast and
// is "pointer to arr"
p5从技术上讲仍然是指向arr而不是arr[0]。因此，基本上使用我使用的reinterpret_cast会导致UB。考虑到上述情况，如果我直��创建指向第一个int的int *（根据@codekaizer的答案，这是可以的），那么这应该是有效的，对吗？template<typename T, size_t X, size_t Y>
void sort2(T(&arr)[X][Y])
{
T *p = &arr[0][0]; // or T *p = arr[0];
std::sort(p, p + X * Y);
}
template<typename T, size_t X, size_t Y>
void sort2(T(&arr)[X][Y])
{
T(&a)[X * Y] = reinterpret_cast<T(&)[X * Y]>(arr);
std::sort(a, a + X * Y);
}
T arr[X][Y]首先会通过reinterpret_cast转换为T a[X*Y]，我认为现在是有效的。重新解释的数组a可以愉快地衰减为指向数组a[X*Y]第一个元素的指针（a + X * Y也在范围内），并在std::sort中被转换为迭代器。
简短版本
由于不正确使用reinterpret_cast，OP的行为是未定义的。将二维数组转换为一维数组的正确方法是：//-- T arr2d[X][Y]
T(&arr1d)[X*Y] = reinterpret_cast<T(&)[X*Y]>(arr2d);
在声明
TD中，其中D的形式为
D1 [ 常量表达式 opt ] 属性说明符序列 opt并且声明中标识符的类型为“派生声明符类型列表
T”，则声明D的标识符类型是数组类型；如果声明D的标识符类型包含 auto 类型说明符，则程序是非法的。T被称为数组的 元素类型；
T[X*Y]和T[X][Y]并不相似。T[X*Y]的长度为X*Y，而T[X][Y]的长度为X，T[X*Y]的元素类型为T，而T[X][Y]的元素类型为T[Y]。 - xskxzrint jimmy [3][5]; // is equivalent to
int jimmy [15]; // (3 * 5 = 15)
size = sizeof(type) * dim0 * dim1 * ....;
所以针对你的问题，是的，你可以安全地将该数组重新转换为一维数组。T[X][Y]强制转换为T[X*Y]。一个是int **类型，另一个是int *类型。 - Vivickint(*)[15]，另一个是类型为 int(*)[3][5]。 - Killzone Kid[3][5] 与 [15] 相同并不意味着你可以安全地在它们之间进行转换，它们仍然属于不同的类型。 - 463035818_is_not_a_numberconstexpr提供了一种方便的方法来评估未定义行为。当评估constexpr时，编译器需要检测UB。因此，可以进行简单的测试。这个函数在编译时评估时将检测访问超出数组范围的值。// sum "n" sequential ints
constexpr int sum(const int* pi, int n) {
int sum = 0;
while (n-- > 0)
sum += *pi++;
return sum;
};
int main()
{
constexpr int i0{1};
constexpr int i1[2]{ 1,2 };
constexpr int i2[2][2] = { { 1,2}, {3,4} };
constexpr int sum0 = sum(&i0, 1); // fails for n>1
constexpr int sum1 = sum(&i1[0], 2); // fails for n>2
constexpr int sum2 = sum(&i2[0][0], 2); // fails for n>2
const int sum3 = sum(&i2[0][0], 4); // runtime calc, UB. fails if constexpr
return sum0 + sum1 + sum2 + sum3; // 17
}
是的，它是合法有效的。
根据dcl.array:
如果 E 是 i×j×⋯×k 级别为 n 的 n 维数组，则出现在受到"数组到指针"转换影响的表达式中的 E 将被转换为一个级别为 j×⋯×k 的(n−1)维数组的指针。如果对此指针应用了"*"运算符（无论是显式地还是隐式地作为下标引用的结果），则结果是指向(n−1)维数组的指针，这个指针本身会立即被转换为指针。
int a[3][4] 可以转换为 int (*)[4]。OP 想要一直到 int*... - Jarod42
int *p = a[0];怎么样？ - chux - Reinstate Monica