“结构继承”如何不违反严格的别名规则？

Question

C 中的“结构继承技术”(as described in this question) 之所以成为可能，是因为 C 标准保证结构的第一个成员在它之前永远不会有任何填充 (?)，并且第一个成员将始终等于结构本身的地址。

这允许如下用法：

typedef struct {
    // some fields
} A;

typedef struct {
    A base;
    // more fields
} B;

typedef struct {
    B base;
    // yet more fields
} C;

C* c = malloc(sizeof(C));
// ... init c or whatever ...
A* a = (A*) c;
// ... access stuff on a etc.
B* b = (B*) c;
// ... access stuff on b etc.

这个问题有两个部分：

A.在我看来，这种技术打破了严格的别名规则。我错了吗？如果是，为什么？

B.假设这种技术确实是合法的。在这种情况下，如果 A: 我们首先将对象存储在其特定类型的左值中，然后向下或向上转换为不同的类型，或者 B: 如果我们直接将其转换为当前所需的特定类型，而不首先将其存储在特定类型的左值中？

例如，这三个选项是否都同样合法？

选项 1：

C* make_c(void) {
    return malloc(sizeof(C));
}    

int main(void) {
    C* c = make_c(); // First store in a lvalue of the specific type
    A* a = (A*) c;
    // ... do stuff with a
    C* c2 = (C*) a; // Cast back to C
    // ... do stuff with c2

    return 0;
}

选项 2：

C* make_c(void) {
    return malloc(sizeof(C));
}    

int main(void) {
    A* a = (A*) make_c(); // Don't store in an lvalue of the specific type, cast right away
    // ... do stuff with a
    C* c2 = (C*) a; // Cast back to C
    // ... do stuff with c2

    return 0;
}

选项 3：

int main(void) {
    A* a = (A*) malloc(sizeof(C)); // Don't store in an lvalue of the specific type, cast right away
    // ... do stuff with a
    C* c2 = (C*) a; // Cast to C - even though the object was never actually stored in a C* lvalue
    // ... do stuff with c2

    return 0;
}

Answer 1

A.在我看来，这种技术打破了严格的别名规则。我错了吗？如果是，为什么？

是的，你错了。我会考虑两种情况：

案例 1：C 已完全初始化

就是这样，例如：

C *c = malloc(sizeof(*c));
*c = (C){0};  // or equivalently, "*c = (C){{{0}}}" to satisfy overzealous compilers

在这种情况下，C 表示的所有字节都被设置，并且包含这些字节的对象的有效类型是C。这来自标准的第 6.5/6 段：

如果一个值通过 lvalue 的类型不是字符类型，然后是 左值成为该访问的对象的有效类型 以及不修改存储值的后续访问。

但结构和数组类型是聚合类型，这意味着这种类型的对象中包含其他对象。特别是，每个C 都包含一个B，标识为它的成员base。因为此时分配的对象实际上是C，它包含一个实际上是B 的子对象。引用B 的左值的一种语法是c->base。该表达式的类型是B，因此使用它访问它所引用的B 符合严格别名规则。必须没问题，否则结构（和数组）将根本不起作用，无论是否动态分配。^*

但是，正如my answer to your previous question 中所讨论的，(B *)c 保证等于（在值 和 类型中）&c->base。因此*(B *)c 是另一个左值，指的是B，它是*c 的第一个成员。该表达式的语法与我们考虑的先前左值的语法不同是没有关系的。它是B 类型的左值，与B 类型的对象相关联，因此使用它来访问它所引用的对象是SAR 允许的情况之一。

这与静态和自动分配的案例没有任何不同。

案例 2：C 未完全初始化

可能是这样的：

C *c = malloc(sizeof(*c));
*(B *)c = (B){0};

因此，我们通过B 类型的左值将分配对象的初始B 大小部分分配给，因此该初始部分的有效类型是B。此时分配的空间不包含（有效）类型C 的对象。我们可以通过引用它们的任何可接受类型的左值访问B 及其成员，读取或写入，如上所述。但是我们有一个严格的别名违规，如果我们

• 尝试整体读取*c（例如C c2 = *c;）；
• 尝试读取C 以外的base 成员（例如 X x = c->another;）；或
• 尝试通过大多数不相关类型的左值读取分配的对象（例如Unrelated_but_not_char u = *(Unrelated_but_not_char *) c;

前两种情况在这里很有趣，它们在动态分配的对象方面是有意义的，当解释为 C 时，没有完全初始化。自动分配的对象也会出现类似的不完全初始化情况；它们也会产生未定义的行为，但遵循不同的规则。

但是请注意，对分配空间的任何写入都不会违反严格的别名冲突，因为任何此类写入都会（重新）分配（至少）写入区域的有效类型。

这将我们带到主要的诡计位。如果我们这样做会怎样：

C *c = malloc(sizeof(*c));
c->base = (B){0};

？或者这样：

C *c = malloc(sizeof(*c));
c->another = 0;

分配的对象在第一次写入之前没有任何有效类型（特别是它没有有效类型C），那么通过*c 写入成员表达式是否有意义？它们定义明确吗？标准的文字可能支持他们不支持的论点，但没有实现采用这种解释，并且没有理由认为任何人都会这样做。

最符合标准和通用实践的解释是，通过成员访问左值写入构成同时写入成员及其主机聚合，从而设置整个区域的有效类型，即使只写入一个成员的值。当然，这仍然无法读取尚未写入值的成员——因为它们的值是不确定的，而不是因为 SAR。

剩下的就是这种情况：

C *c = malloc(sizeof(*c));
*(B *)c = (B){0};
B b2 = c->base;            // What about this?

也就是说，如果分配空间的初始区域的有效类型是B，我们可以使用基于类型C的成员访问左值来读取该B区域的存储值吗？同样，有人可能会争辩说没有实际的C，但在实践中，没有实现做出这种解释。正在读取的对象的有效类型——分配空间的初始区域——与用于访问的左值的类型相同，因此从这个意义上说，不存在 SAR 违规。主机C 完全是假设性的，主要是语法的问题，而不是语义问题，因为同一个区域肯定可以通过替代表达式被读取为同类型的对象。

---

^* 但是 SAR 通过提供“在其成员中包含上述类型之一的聚合或联合类型（递归地，包括子聚合的成员或包含的联合）”是可以访问的类型之一。这消除了围绕位置的任何歧义，即访问成员也构成访问包含它的任何对象。

Answer 2

我相信来自 C11（ISO/IEC 9899:2011 §6.5 7）的这句话应该可以回答您的一些问题（我的重点已添加）：

对象的存储值只能由具有以下类型之一的左值表达式访问：
— 与对象的有效类型兼容的类型，
— 与对象的有效类型兼容的类型的限定版本，
— 对应于对象有效类型的有符号或无符号类型，
— 有符号或无符号类型，对应于对象有效类型的限定版本，
— 一种聚合或联合类型，其中包括上述类型之一 成员（递归地包括子聚合或包含联合的成员），或
— 一种字符类型。

然后可以回答更多问题（ISO/IEC 9899:2011 §6.7.2.1 15）：

一个指向结构对象的指针，经过适当的转换，指向它的初始成员（或者如果该成员是位域，则指向它所在的单元），反之亦然。结构对象中可能有未命名的填充，但不是在其开头。

其余的可以通过这个 sn-p 来回答（ISO/IEC 9899:2011 §7.22.3 1）：

连续调用分配的存储的顺序和连续性 aligned_alloc、calloc、malloc 和 realloc 函数未指定。如果分配成功，则返回的指针经过适当对齐，以便可以将其分配给具有基本对齐要求的任何类型对象的指针，然后用于访问分配的空间中的此类对象或此类对象的数组（直到空间被显式释放）。

总结：

A.你错了。推理见第一个和第二个引号。

B.不，这没有什么区别。请参阅第三个引用（也许是第一个）以了解推理。

Answer 3

是的，结构的第一个元素之前没有任何填充。

其次，当匿名字段的类型是结构或联合的 typedef 时，代码可以使用 typedef 的名称来引用该字段。 这是 GCC 手册中的一个很好的做法：

typedef struct {
    // some fields
} A;

typedef struct {
    A;
    // more fields
} B;

typedef struct {
    B;
    // yet more fields
} C;

B get_B (struct C *c) { return c->B; } /* access B */ 

请查看Unnamed Structure and Union Fields