使用“memcpy”复制二维数组在技术上是未定义的行为吗？

评论中出现了一个有趣的讨论最近的这个问题 https://stackoverflow.com/q/69329303/10871073: 现在，虽然有语言C，讨论已经转向什么C++标准指定了使用以下函数访问多维数组的元素时构成未定义行为的内容std::memcpy.

首先，这是该问题的代码，转换为 C++ 并使用const只要有可能：

#include <iostream>
#include <cstring>

void print(const int arr[][3], int n)
{
    for (int r = 0; r < 3; ++r) {
        for (int c = 0; c < n; ++c) {
            std::cout << arr[r][c] << " ";
        }
        std::cout << std::endl;
    }
}

int main()
{
    const int arr[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
    int arr_copy[3][3];
    print(arr, 3);
    std::memcpy(arr_copy, arr, sizeof arr);
    print(arr_copy, 3);
    return 0;
}

问题在于调用std::memcpy: the arr参数将产生（通过衰减）指向第一个的指针int[3]子数组所以，根据讨论的一方面（由特德·林莫 https://stackoverflow.com/users/7582247/ted-lyngmo?tab=topactivity）， 当。。。的时候memcpy函数访问该子数组第三个元素之外的数据，有formally未定义的行为（同样适用于目的地，arr_copy).

然而，辩论的另一方（平庸蔬菜1 https://stackoverflow.com/users/13188071/mediocrevegetable1?tab=topactivity我订阅）使用每个二维数组的基本原理，根据定义，占用连续内存，并且作为参数memcpy只是void*指向这些位置的指针（以及第三个，size论证有效），那么这里不可能有 UB。

以下是与辩论最相关的一些评论的摘要，以防原始问题发生任何“清理”（粗体表示我的强调）：

我不认为这里有任何越界。就像memcpy适用于数组ints，它适用于数组int [3]s，并且两者应该是连续的（但我不是 100% 确定）。 – 平庸蔬菜1

当您从以下位置复制第一个字节时，就会发生越界访问：arr[0][3]。我从未见过它真正失败，但是，在 C++ 中，它有 UB。 ——特德·林莫

But the memcpy函数/调用不执行任何数组索引 - 它只是给出两个void*指针并将内存从一个对象复制到另一个对象。 ——阿德里安·莫尔

我不能肯定地说这在 C 中是否重要。在 C++ 中则不然。你得到一个指向第一个的指针int[3]任何超出其范围的访问都有UB。我在 C++ 标准中没有发现任何例外。——特德·林莫

我不认为arr[0][3]事情适用。按照这个逻辑，我认为复制第二个int of an int数组通过memcpy也会是UB。int [3]只是类型arr的元素，以及边界arr整体以字节为单位应该是sizeof (int [3]) * 3。我可能错过了一些东西：/ – 平庸的蔬菜 1

是否有任何 C++ 语言律师可以解决这个问题 – 最好有 C++ 标准的适当引用？

另外，C 标准的相关引用可能会有所帮助 - 特别是如果两种语言标准不同 - 因此我在这个问题中包含了 C 标签。

std::memcpy(arr_copy, arr, sizeof arr);（你的例子）是明确定义的。

std::memcpy(arr_copy, arr[0], sizeof arr);另一方面，会导致未定义的行为（至少在 C++ 中；对于 C 不完全确定）。

多维数组是数组的一维数组。据我所知，与真正的一维数组（即具有非数组类型元素的数组）相比，它们没有得到太多（如果有的话）特殊待遇。

考虑一个一维数组的示例：

int a[3] = {1,2,3}, b[3];
std::memcpy(b, a, sizeof(int) * 3);

This is obviously legal.¹

请注意memcpy接收指向数组第一个元素的指针，并且可以访问其他元素。

元素类型不影响此示例的有效性。如果使用二维数组，元素类型变为int[N]而不是int，但有效性不受影响。

现在，考虑一个不同的例子：

int a[2][2] = {{1,2},{3,4}}, b[4];
std::memcpy(b, a[0], sizeof(int) * 4);
//             ^~~~

This one causes UB², because since memcpy is given a pointer to the first element of a[0], it can only access the elements of a[0] (a[0][i]), and not a[j][i].

但是，如果你想听我的意见，这是一种“驯服”的 UB，在实践中可能不会造成问题（但是，一如既往，如果可能的话，应该避免 UB）。

¹ The C++ standard doesn't explain memcpy, and instead refers to the C standard. The C standard uses somewhat sloppy wording:

C11 (N1570)[7.24.2.1]/2 http://port70.net/%7Ensz/c/c11/n1570.html#7.24.2.1p2

The memcpy函数副本n指向的对象中的字符s2进入指向的对象s1.

指向数组的第一个（或任何）元素的指针仅指向该元素，而不指向整个数组，即使可以通过所述指针访问整个数组。因此，如果按字面解释，@LanguageLawyer 似乎是正确的：如果你给出memcpy指向数组元素的指针，您只能复制该单个元素，而不能复制连续的元素。

这种解释与常识相矛盾，而且很可能不是有意的。

例如。考虑中的例子[basic.types.general]/2 http://eel.is/c++draft/basic#types.general-example-1，这适用于memcpy使用指向第一个元素的指针到数组：（即使示例是非规范的）

constexpr std::size_t N = sizeof(T);
char buf[N];
T obj;
std::memcpy(buf, &obj, N);
std::memcpy(&obj, buf, N);

² This is moot, because of the problematic wording for memcpy described above.

我对 C 不太确定，但对于 C++，有强烈的暗示这是 UB。

首先，考虑一个使用的类似示例std::copy_n，尝试执行按元素复制而不是按字节复制：

#include <algorithm>

consteval void foo()
{
    int a[2][2] = {{1,2},{3,4}}, b[2][2] = {{1,2},{3,4}};
    std::copy_n(a[0], 4, b[0]);
}

int main() {foo();} 

在编译时运行函数会捕获大多数形式的 UB（它使代码格式错误），并且编译此代码片段确实会给出：

error: call to consteval function 'foo' is not a constant expression
note: cannot refer to element 4 of array of 2 elements in a constant expression

情况与memcpy不太确定，因为它执行按字节复制。整个主题似乎是模糊且不明确 https://stackoverflow.com/q/62329008/2752075.

考虑以下措辞：std::launder:

[ptr.launder]/4 http://eel.is/c++draft/ptr.launder#4

一个字节的存储空间b可以通过指向对象的指针值访问Y如果有一个物体Z, 指针可与Y，使得b位于占用的存储空间内Z，或直接封闭的数组对象，如果Z是一个数组元素。

换句话说，给定一个指向数组元素的指针，该数组的所有元素都可以通过该指针访问（非递归地，即通过&a[0][0] only a[0][i]是可达的）。

形式上，这个定义仅用于描述std::launder（事实上​​，它无法扩展给定的指针的可到达区域）。但其含义似乎是该定义总结了标准其他部分描述的可达性规则（[static.cast]/13 http://eel.is/c++draft/expr#static.cast-13，请注意reinterpret_cast is 定义通过 http://eel.is/c++draft/expr.reinterpret.cast#7相同的措辞；还[basic.compound]/4 http://eel.is/c++draft/basic.compound#4).

目前尚不完全清楚上述规则是否适用于memcpy，但他们应该。因为否则，程序员将能够使用库函数忽略可达性，这将使可达性的概念几乎毫无用处。