假设我们有一个二维 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);
}

演示:https://ideone.com/tlm190

据我所知，该标准保证二维数组的对齐在内存中是连续的，尽管 p + X*Y 在技术上超出范围，但永远不会被访问，因此不应导致未定义行为任何一个。

我是否可以在需要时将 2D 数组完全视为 1D 数组？

最佳答案

感谢大家的回复和评论，但我认为正确的答案是 - 就目前而言，代码展示了技术 UB，尽管可以纠正。我已经查看了其中一些问题 [ 1 , 2 ] @xskxzr 链接，它引导我到 this quote from the standard :

If two objects are pointer-interconvertible, then they have the same address, and it is possible to obtain a pointer to one from a pointer to the other via a reinterpret_­cast. [ Note: An array object and its first element are not pointer-interconvertible, even though they have the same address. — end note ]

然后在 reinterpret_cast page有一个例子如下注释:

Assuming that alignment requirements are met, a reinterpret_cast does not change the value of a pointer outside of a few limited cases dealing with pointer-interconvertible objects:

int arr[2];
int* p5 = reinterpret_cast<int*>(&arr); // value of p5 is unchanged by reinterpret_cast and
                                        // is "pointer to arr"

尽管这compiles without warning and runs ，这在技术上是一个 UB，因为 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);
}

但它也可能是 UB，因为指针 p 指向第一个 T 数组的第一个 T Y 元素。 p + X*Y 因此将指向第一个 Ts 数组的范围之外，因此是 UB(再次感谢 @xskxzr 的 link 和评论) .

If the expression P points to element x[i] of an array object x with n elements, the expressions P + J and J + P (where J has the value j) point to the (possibly-hypothetical) element x[i+j] if 0≤i+j≤n; otherwise, the behavior is undefined.

所以这是我放弃前的最后一次尝试:

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 中转换为迭代器。

TL；DR 版本

由于 reinterpret_cast 使用不当，OP 中的行为未定义。将二维数组转换为一维数组的正确方法是:

//-- T arr2d[X][Y]
T(&arr1d)[X*Y] = reinterpret_cast<T(&)[X*Y]>(arr2d);

An lvalue expression of type T1 can be converted to reference to another type T2. The result is an lvalue or xvalue referring to the same object as the original lvalue, but with a different type. No temporary is created, no copy is made, no constructors or conversion functions are called. The resulting reference can only be accessed safely if allowed by the type aliasing rules

Aliasing rules :

Whenever an attempt is made to read or modify the stored value of an object of type DynamicType through a glvalue of type AliasedType, the behavior is undefined unless one of the following is true:

• AliasedType and DynamicType are similar.

Type similarity :

Informally, two types are similar if, ignoring top-level cv-qualification

• they are both arrays of the same size or both arrays of unknown bound, and the array element types are similar.

Array element type :

In a declaration T D where D has the form

D1 [ constant-expression opt ] attribute-specifier-seq opt

and the type of the identifier in the declaration T D1 is “derived-declarator-type-list T”, then the type of the identifier of D is an array type; if the type of the identifier of D contains the auto type-specifier, the program is ill-formed. T is called the array element type;

关于c++ - 将二维数组视为一维数组，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50795498/