结构体的大小是否需要是该结构体对齐方式的精确倍数？

Question

我再一次质疑一个长期存在的信念。

直到今天，我相信以下结构的对齐通常为 4，大小通常为 5...

struct example
{
  int   m_Assume_32_Bits;
  char  m_Assume_8_Bit_Bytes;
};

由于这个假设，我有数据结构代码，使用 offsetof 来确定中两个相邻项之间的字节距离一个数组。今天，我发现一些旧代码在不应该使用 sizeof 的地方使用了 sizeof，无法理解为什么我没有从中发现错误，编写了一个单元测试 - 测试的通过让我感到惊讶。

一些调查表明，我用于测试的类型的大小（类似于上面的结构）是对齐的精确倍数 - 即 8 个字节。它在最后一个成员之后有填充。这是为什么我从未预料到这一点的一个例子...

struct example2
{
  example m_Example;
  char    m_Why_Cant_This_Be_At_Offset_6_Bytes;
};

一些谷歌搜索显示了一些示例，这些示例清楚地表明最终成员之后的填充是允许的 - 例如 http://en.wikipedia.org/wiki/Data_struct_alignment#Data_struct_padding（“或位于结构末尾”位）。

这有点尴尬，因为我最近发表了此评论 - Use of struct padding（我对该答案的第一条评论）。

我似乎无法确定这种填充到对齐的精确倍数是否由 C++ 标准保证，或者它是否只是允许的并且某些（但可能不是全部）编译器会这样做。

那么 - 根据 C++ 标准，结构体的大小是否需要是该结构体对齐方式的精确倍数？

如果 C 标准做出不同的保证，我也对此感兴趣，但重点是 C++。

Answer 1

5.3.3/2

当应用于类时，[sizeof] 的结果是该类的对象中的字节数，包括将该类型的对象放入数组中所需的任何填充。

所以是的，对象大小是其对齐方式的倍数。

Answer 2

alignment 大小的一种定义：

结构体的 alignment 大小是当您拥有该结构体的数组时从一个元素到下一个元素的偏移量。

就其本质而言，如果您有一个包含两个元素的结构体数组，那么两个元素都需要具有对齐的成员，因此这意味着是的，大小必须是对齐的倍数。 （我不确定是否有任何标准明确强制执行此操作，但因为结构的大小和对齐方式不取决于该结构是单独的还是在数组内，所以相同的规则适用于两者，所以它不能真正可以是任何其他方式。）

Answer 3

标准说（[dcl.array] 部分：

数组类型的对象包含连续分配的非空 N 个类型为 T 的子对象。

因此数组元素之间没有填充。

标准不要求结构内部填充，但标准不允许任何其他方式对齐数组元素。

Answer 4

C++ 没有明确这么说，但它是其他两个要求的结果：

首先，所有 对象必须良好对齐。

3.8/1 说

T 类型的对象的生命周期开始于 [...]具有正确对齐方式的存储以及 T 类型的大小获得

，并且 3.9 /5：

对象类型具有*对齐要求（3.9.1、3.9.2）。完整对象类型的对齐是一个实现定义的表示字节数的整数值；对象被分配到满足其对象类型对齐要求的地址。

因此每个对象都必须根据其对齐要求进行对齐。

另一个要求是数组中的对象是连续分配的：

8.3.4/1：

数组类型的对象包含连续分配的非空集 N 个 T 类型的子对象。

对于连续分配的数组中的对象，它们之间不能有填充。但为了使数组中的每个对象正确对齐，必须填充每个单独的对象，以便紧邻对象末尾之后的字节也正确对齐。换句话说，对象的大小必须是其对齐方式的倍数。

Answer 5

我不确定这是否在实际的 C/C++ 标准中，我倾向于说这取决于编译器（只是为了安全起见）。然而，几个月前，我度过了一段“有趣”的时光，当时我必须将动态生成的 C 结构作为字节数组作为协议的一部分通过网络发送，以便与芯片进行通信。所有结构的对齐和大小必须与芯片上运行的代码中的结构一致，该代码是使用 MIPS 架构的 GCC 变体编译的。我将尝试给出算法，它应该适用于 gcc 的所有变体（希望也适用于大多数其他编译器）。

所有基本类型，如 char、short 和 int 都与其大小对齐，并且它们对齐到下一个可用位置，无论父级的对齐。回答最初的问题，是的，总大小是对齐的倍数。

// size 8
struct {
    char A; //byte 0
    char B; //byte 1
    int C; //byte 4
};

尽管结构的对齐方式是 4 个字节，但字符仍然尽可能紧密地排列在一起。

结构体的对齐方式等于其成员的最大对齐方式。

示例：

//size 4, but alignment is 2!
struct foo {
    char A; //byte 0
    char B; //byte 1
    short C; //byte 3
}

//size 6
struct bar {
    char A;         //byte 0
    struct foo B;   //byte 2
}

这也适用于工会，而且以一种奇怪的方式。联合的大小可以大于其成员的任何大小，这仅仅是由于对齐：

//size 3, alignment 1
struct foo {
    char A; //byte 0
    char B; //byte 1
    char C; //byte 2
};

//size 2, alignment 2
struct bar {
    short A; //byte 0
};

//size 4! alignment 2
union foobar {
    struct foo A;
    struct bar B;
}

使用这些简单的规则，您应该能够计算出任何可怕的嵌套联合的对齐/大小/struct 你遇到过。这全都是凭记忆，所以如果我错过了无法从这些规则中决定的极端情况，请告诉我！

Answer 6

可以生成一个 C 或 C++ typedef，其对齐方式不是其大小的倍数。这是最近在 这个bindgen错误。这是一个最小的示例，我将在下面将其称为 test.c：

#include <stdio.h>
#include <stdalign.h>

__attribute__ ((aligned(4))) typedef struct {
    char x[3];
} WeirdType;

int main() {
    printf("sizeof(WeirdType) = %ld\n", sizeof(WeirdType));
    printf("alignof(WeirdType) = %ld\n", alignof(WeirdType));
    return 0;
}

在我的 Arch Linux x86_64 机器上，gcc -dumpversion && gcc test.c && ./a.out 打印：

9.3.0
sizeof(WeirdType) = 3
alignof(WeirdType) = 4

类似地 clang -dumpversion && clang test.c && ./a.out 打印：

9.0.1
sizeof(WeirdType) = 3
alignof(WeirdType) = 4

将文件保存为 test.cc 并使用 g++/clang++ 给出相同的结果。 （几年后更新：我从 GCC 11.1.0 和 Clang 13.0.0 得到了相同的结果。）

但是值得注意的是，Windows 上的 MSVC 似乎没有重现任何类似的行为。

Answer 7

因此，将您的问题分为两个：

1。合法吗？

[5.3.3.2] 当应用于类时，[sizeof() 运算符]的结果是该类的对象中的字节数，包括所需的任何填充将该类型的对象放入数组中。

所以，不，不是。

2.那么，为什么不是呢？

在这里，我只能推测。

2.1。指针算术变得更奇怪
如果对齐是“在数组元素之间”但不会影响大小，则 zthigns 会变得不必要的复杂，例如

(char *)(X+1) != ((char *)X) + sizeof(X)

（我有一种预感，即使没有上述声明，标准也隐含地要求这样做，但我无法证明它)

2.2 简单性
如果对齐影响大小，则可以通过查看单个类型来决定对齐和大小。考虑一下：

struct A  {  int x; char y;  }
struct B  { A left, right;   }

根据当前标准，我只需要知道 sizeof(A) 即可确定 B 的大小和布局。
使用您建议的替代方案，我需要了解 A 的内部结构。与您的 example2 类似：对于“更好的包装”， sizeof(example) 是不够的，您需要考虑 example 的内部结构。

Answer 8

该标准很少提及填充和对齐。得到保证的很少。您唯一可以押注的是第一个元素位于结构的开头。之后...对齐和填充可以是任何东西。

Answer 9

似乎 C++03 标准没有说（或者我没有找到）对齐填充字节是否应该包含在对象表示中。

C99 标准表示结构类型或联合类型的“sizeof”包括内部和尾随填充，但我不确定所有对齐填充是否都包含在该“尾随填充”中。

现在回到你的例子。确实没有什么混乱。 sizeof(example) == 8 表示该结构确实需要 8 个字节来表示自身，包括尾部 3 个填充字节。如果第二个结构中的字符偏移量为 6，它将覆盖 m_Example 使用的空间。某种类型的布局是实现定义的，并且应该在整个实现中保持稳定。

不过，p+1 是否等于 (T*)((char*)p + sizeof(T)) 仍不确定。我希望能找到答案。