标准布局和尾部填充

Question

David Hollman 最近在推特上发布了以下示例（我稍微简化了）：

struct FooBeforeBase {
    double d;
    bool b[4];
};

struct FooBefore : FooBeforeBase {
    float value;
};

static_assert(sizeof(FooBefore) > 16);

//----------------------------------------------------

struct FooAfterBase {
protected:
    double d;
public:  
    bool b[4];
};

struct FooAfter : FooAfterBase {
    float value;
};

static_assert(sizeof(FooAfter) == 16);

您可以检查布局 in clang on godbolt 并查看大小更改的原因是在 FooBefore 中，成员 value 放置在偏移量 16 处（与 FooBeforeBase 保持完全对齐 8）而在FooAfter，成员 value 放置在偏移量 12 处（有效使用 FooAfterBase 的尾部填充）。

我很清楚FooBeforeBase 是标准布局，但FooAfterBase 不是（因为它的非静态数据成员并不都具有相同的访问控制，[class.prop]/3）。但是，FooBeforeBase 的标准布局需要这种填充字节，这又是什么呢？

gcc 和 clang 都重用了 FooAfterBase 的填充，以 sizeof(FooAfter) == 16 结尾。但 MSVC 没有，以 24 结尾。是否有符合标准的布局要求，如果没有，为什么 gcc 和 clang 会这样做？

---

有一些混乱，所以只是为了澄清：

• FooBeforeBase 是标准布局
• FooBefore 不是（它和基类都有非静态数据成员，类似于this example 中的E）
• FooAfterBase 不是（它具有不同访问权限的非静态数据成员）
• FooAfter 不是（出于上述两个原因）

Answer 1

这个问题的答案不是来自标准，而是来自 Itanium ABI（这就是为什么 gcc 和 clang 有一种行为而 msvc 做其他事情的原因）。该 ABI 定义了a layout，就本问题而言，其相关部分是：

出于规范内部的目的，我们还指定：

• dsize(O)：对象的数据大小，即不带尾边距的O大小。

和

我们忽略 POD 的尾部填充，因为该标准的早期版本不允许我们将其用于其他任何事情，而且它有时允许更快地复制类型。

虚拟基类以外的成员的放置定义为：

从偏移量 dsize(C) 开始，如果需要对齐基类的 nvalign(D) 或数据成员的 align(D)，则递增。除非 [... 不相关 ...]，否则将 D 放置在此偏移处。

POD 一词已从 C++ 标准中消失，但它意味着标准布局和可轻松复制。在这个问题中，FooBeforeBase 是一个 POD。 Itanium ABI 忽略尾部填充 - 因此 dsize(FooBeforeBase) 是 16。

但FooAfterBase 不是 POD（它可以简单地复制，但它不是标准布局）。结果，尾部填充没有被忽略，所以dsize(FooAfterBase) 只是 12，float 可以直接到那里。

这会产生有趣的后果，正如 Quuxplusone 在 related answer 中指出的那样，实现者通常还假设尾部填充没有被重用，这对这个示例造成了严重破坏：

#include <algorithm>
#include <stdio.h>

struct A {
    int m_a;
};

struct B : A {
    int m_b1;
    char m_b2;
};

struct C : B {
    short m_c;
};

int main() {
    C c1 { 1, 2, 3, 4 };
    B& b1 = c1;
    B b2 { 5, 6, 7 };

    printf("before operator=: %d\n", int(c1.m_c));  // 4
    b1 = b2;
    printf("after operator=: %d\n", int(c1.m_c));  // 4

    printf("before std::copy: %d\n", int(c1.m_c));  // 4
    std::copy(&b2, &b2 + 1, &b1);
    printf("after std::copy: %d\n", int(c1.m_c));  // 64, or 0, or anything but 4
}

这里，= 做了正确的事情（它不会覆盖 B 的尾部填充），但是 copy() 有一个库优化，可以减少到 memmove() - 它不关心尾部填充，因为它假设它不存在。

Answer 2

FooBefore derived;
FooBeforeBase src, &dst=derived;
....
memcpy(&dst, &src, sizeof(dst));

如果额外的数据成员被放置在洞中，memcpy 会覆盖它。

正如在 cmets 中正确指出的那样，该标准不要求此 memcpy 调用应该有效。然而，Itanium ABI 的设计似乎考虑到了这种情况。或许以这种方式指定 ABI 规则是为了使混合语言编程更加健壮，或者为了保持某种向后兼容性。

相关ABI规则可以在here找到。

可以在here 找到相关答案（这个问题可能与那个问题重复）。

Answer 3

这是一个具体案例，说明了为什么第二种情况不能重用填充：

union bob {
  FooBeforeBase a;
  FooBefore b;
};

bob.b.value = 3.14;
memset( &bob.a, 0, sizeof(bob.a) );

这无法清除bob.b.value。

union bob2 {
  FooAfterBase a;
  FooAfter b;
};

bob2.b.value = 3.14;
memset( &bob2.a, 0, sizeof(bob2.a) );

这是未定义的行为。

Answer 4

FooBefore 也不是标准布局；两个类声明非静态数据成员（FooBefore 和 FooBeforeBase）。因此允许编译器任意放置一些数据成员。因此，出现了不同工具链上的差异。 在标准布局层次结构中，至多一个类（最派生类或至多一个中间类）应声明非静态数据成员。

Answer 5

这是与 n.m. 的回答类似的情况。

首先，让我们有一个函数，它清除FooBeforeBase：

void clearBase(FooBeforeBase *f) {
    memset(f, 0, sizeof(*f));
}

这很好，因为clearBase 得到一个指向FooBeforeBase 的指针，它认为FooBeforeBase 具有标准布局，所以memsetting 是安全的。

现在，如果你这样做：

FooBefore b;
b.value = 42;
clearBase(&b);

您不会想到，clearBase 会清除 b.value，因为 b.value 不是 FooBeforeBase 的一部分。但是，如果将FooBefore::value 放入FooBeforeBase 的尾部填充中，它也会被清除。

是否有符合标准的布局要求？如果没有，为什么 gcc 和 clang 会这样做？

不，不需要尾部填充。这是一个优化，gcc 和 clang 做的。