使用指向元素的指针进行多维数组索引

Question

据我所知，栈上的多维数组会按行顺序占用连续的内存。根据 ISO C++ 标准使用指向元素的指针来索引多维数组是未定义的行为吗？例如：

#include <iostream>
#include <type_traits>
int main() {
  int a[5][4]{{1,2,3,4},{},{5,6,7,8}};
  constexpr auto sz = sizeof(a) / sizeof(std::remove_all_extents<decltype(a)>::type);
  int *p = &a[0][0];
  int i = p[11];  // <-- here
  p[19] = 20;  // <-- here
  for (int k = 0; k < sz; ++k)
    std::cout << p[k] << ' ';  // <-- and here
  return 0;
}

如果指针没有超出数组a 的边界，上述代码将正确编译并运行。但这是因为编译器定义的行为或语言标准而发生的吗？任何来自 ISO C++ 标准的参考都是最好的。

Answer 1

这里的问题是 严格的别名规则，它存在于我的草案 n3337 for C++11 in 3.10 Lvalues and rvalues [basic.lval] § 10 中。这是一个详尽的列表，没有明确允许将多维数组别名为整个大小的一维数组。

因此，即使确实需要在内存中连续分配数组，这也证明了多维数组的大小，例如T arr[n][m] 是维度乘以元素大小的乘积：n * m *sizeof(T) .当转换为 char 指针时，您甚至可以对整个数组进行算术指针操作，因为任何指向对象的指针都可以转换为 char 指针，并且该 char 指针可用于访问对象的连续字节（*） .

但不幸的是，对于任何其他类型，标准只允许在一个数组内进行算术指针操作（并且根据定义取消引用数组元素与取消引用指针相同在指针算术之后：a[i] 是 *(a + i))。因此，如果您同时遵守指针运算规则和严格的别名规则，则 C++11 标准未定义多维数组的全局索引，除非您通过 char 指针运算：

int a[3][4];
int *p = &a[0][0]; // perfectly defined
int b = p[3];      // ok you are in same row which means in same array
b = p[5];          // OUPS: you dereference past the declared array that builds first row

char *cq = (((char *) p) + 5 * sizeof(int)); // ok: char pointer arithmetics inside an object
int *q = (int *) cq; // ok because what lies there is an int object
b = *q;            // almost the same as p[5] but behaviour is defined

char 指针算法 以及对破坏大量现有代码的恐惧解释了为什么所有众所周知的编译器都默默地接受具有相同全局大小的一维数组的多维数组的别名（它导致相同的内部代码），但从技术上讲，全局指针算法仅对 char 指针有效。

---

(*) 标准在 1.7 中声明的 C++ 内存模型 [intro.memory] ​​

C++ 内存模型中的基本存储单元是字节... C++ 程序可用的内存由一个或多个连续字节序列组成。每一个 byte 有一个唯一的地址。

3.9 之后的类型 [basic.types] §2

对于普通可复制类型 T 的任何对象（基类子对象除外），无论该对象是否 持有类型 T 的有效值，构成对象的底层字节可以复制到数组中 字符或无符号字符。

要复制它们，您必须通过char * 或unsigned char * 访问它们

Answer 2

我相信您示例中的行为在技术上是未定义的。

该标准没有多维数组的概念。您实际声明的是“由 5 个 4 个整数组成的数组的数组”。也就是说a[0]和a[1]实际上是两个不同的4个int数组，都包含在数组a中。这意味着a[0][0] 和a[1][0] 不是同一个数组的元素。

[expr.add]/4 说以下（强调我的）

当一个具有整数类型的表达式被添加到指针或从指针中减去时，结果具有类型 的指针操作数。如果指针操作数指向数组对象的一个​​元素，并且数组是 足够大，结果指向与原始元素偏移的元素，使得 结果和原始数组元素的下标等于整数表达式。换句话说，如果 表达式 P 指向数组对象的第 i 个元素，表达式 (P)+N（等价于 N+(P)） 和 (P)-N（其中 N 的值为 n）分别指向数组的第 i + n 个和第 i - n 个元素 对象，只要它们存在。此外，如果表达式 P 指向数组对象的最后一个元素， 表达式 (P)+1 指向数组对象的最后一个元素，如果表达式 Q 指向 超过数组对象的最后一个元素，表达式 (Q)-1 指向数组的最后一个元素 目的。 如果指针操作数和结果都指向同一个数组对象的元素，或者一个过去 数组对象的最后一个元素，评估不应产生溢出；否则，行为是 未定义

因此，由于p[11] 扩展为*(p + 11)，并且由于p 和p + 11 不是同一个数组的元素（一个是a[0] 的元素，另一个是结束后的多个元素a[0])，添加的行为是未定义的。

然而，我会非常惊讶地发现这样的添加会导致与您期望的结果不同的任何实现。

Answer 3

如果你声明

int  arr[3][4][5];

arr 的类型是int[3][4][5]，arr[3] 的类型是int[4][5]，等等。数组数组的数组，但不是指针数组。让我们看看如果我们增加第一个索引会发生什么？它会将指针向前移动数组元素的大小，但 arr 的数组元素是二维数组！相当于递增：arr + sizeof(int[4][5])/sizeof(int) 或 arr + 20。

以这种方式迭代我们会发现 arr[a][b][c] 等于 *(*(*(arr + a) + b) + c)，前提是数组永远不会有任何填充（以符合 POD 类型与 C99 的强制兼容性）：

*((int*)arr + 20*a +  5*b + c)

当具有整数类型的表达式被添加或减去时 从一个指针，结果具有指针操作数的类型。如果 指针操作数指向数组对象的一个​​元素，而数组 足够大，结果指向一个元素偏移量 原始元素使得下标的差异 结果和原始数组元素等于积分表达式