通过其他结构体成员的偏移指针访问结构体成员是否合法？

在这两个示例中，通过偏移其他成员的指针来访问结构体成员是否会导致未定义/未指定/实现定义的行为？

struct {
  int a;
  int b;
} foo1 = {0, 0};

(&foo1.a)[1] = 1;
printf("%d", foo1.b);


struct {
  int arr[1];
  int b;
} foo2 = {{0}, 0};

foo2.arr[1] = 1;
printf("%d", foo2.b);

C11 § 6.7.2.1 第 14 段似乎表明这应该是实现定义的：

结构或联合对象的每个非位域成员都以适合其类型的实现定义方式对齐。

然后接着说：

结构对象内可能有未命名的填充，但不是在其开头。

然而，像下面这样的代码似乎相当常见：

union {
  int arr[2];
  struct {
    int a;
    int b;
  };
} foo3 = {{0, 0}};

foo3.arr[1] = 1;
printf("%d", foo3.b);

(&foo3.a)[1] = 2; // appears to be illegal despite foo3.arr == &foo3.a
printf("%d", foo3.b);

该标准似乎保证foo3.arr是相同的&foo3.a，并且以一种方式引用它是合法的而另一种方式不合法是没有意义的，但同样，将外部联合与数组相加应该突然使(&foo3.a)[1] legal.

因此，我认为第一个例子也必须是合法的：

1. foo3.arr保证与&foo.a
2. foo3.arr + 1 and &foo3.b指向同一个内存位置
3. &foo3.a + 1 and &foo3.b因此必须指向相同的内存位置（来自 1 和 2）
4. 结构布局需要一致，所以&foo1.a and &foo1.b应该布置得与&foo3.a and &foo3.b
5. &foo1.a + 1 and &foo1.b因此必须指向相同的内存位置（来自 3 和 4）

我发现一些外部消息来源表明foo3.arr[1] and (&foo3.a)[1]示例是非法的，但是我无法在标准中找到可以实现这一点的具体声明。 即使它们都是非法的，也可以使用灵活的数组指针构造相同的场景，据我所知，does具有标准定义的行为。

union {
  struct {
    int x;
    int arr[];
  };
  struct {
    int y;
    int a;
    int b;
  };
} foo4;

原始应用程序正在考虑从一个结构体字段到另一个结构体字段的缓冲区溢出是否严格来说是由标准定义的：

struct {
  char buffer[8];
  char overflow[8];
} buf;
strcpy(buf.buffer, "Hello world!");
println(buf.overflow);

我希望这个输出"rld!"几乎在任何现实世界的编译器上，但是此行为是由标准保证的，还是未定义或实现定义的行为？

介绍：该领域的标准是不够的，并且关于该主题和严格别名的争论已有数十年的历史，没有令人信服的解决方案或建议来解决。

这个答案反映了我的观点，而不是该标准的任何强加。

首先：人们普遍认为第一个代码示例中的代码是未定义的行为，因为通过直接指针算术访问数组的边界之外。

规则是 C11 6.5.6/8 。它表示指针的索引必须保留在“数组对象”内（或超出末尾的一个）。它没有说which数组对象，但普遍认为在这种情况下int *p = &foo.a;那么“数组对象”是foo.a，而不是任何更大的物体foo.a是一个子对象。

相关链接：one https://stackoverflow.com/questions/47224138/is-it-ok-to-access-past-the-size-of-a-structure-via-member-address-with-enough/47224596#47224596, two https://stackoverflow.com/questions/48147422/is-it-legal-to-alias-a-struct-and-an-array.

其次：人们普遍认为你们俩union例子是正确的。该标准明确规定联盟的任何成员都可以被读取；无论相关内存位置的内容是什么，都将被解释为正在读取的联合成员的类型。

你建议union正确意味着第一个代码也应该是正确的，但事实并非如此。问题不在于指定读取的内存位置；而在于指定读取的内存位置。问题在于我们如何得出指定该内存位置的表达式。

尽管我们知道&foo.a + 1 and &foo.b是相同的内存地址，访问是有效的int通过第二个并且无法有效访问int通过第一个。

人们普遍认为，您可以通过不违反 6.5.6/8 规则的其他方式计算其地址来访问 int，例如：

((int *)((char *)&foo + offsetof(foo, b))[0]

or

((int *)((uintptr_t)&foo.a + sizeof(int)))[0]

相关链接：one https://stackoverflow.com/questions/5524552/, two https://stackoverflow.com/questions/37412887/

It's not普遍同意是否((int *)&foo)[1]已验证。有人说它与您的第一个代码基本相同，因为标准说“指向对象的指针，经过适当转换，指向元素的第一个对象”。别人说和我的基本一样(char *)上面的例子是因为它遵循指针转换的规范。有些人甚至声称这是严格的别名违规，因为它将结构别名为数组。

也许相关的是N2090 - 指针来源提案 http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2090.htm。这并不直接解决该问题，也不建议废除 6.5.6/8。