64位机器上的结构填充

Question

struct A
{
    uint32_t var1;
    uint32_t var2;
    uint32_t var3;
    uint32_t var4;
    uint32_t var5;
};

在上述结构中，编译器不填充并分配 20 个字节。

现在我们有另一个结构，它包含一个 8 字节变量而不是两个 4 字节。在这种情况下，编译器填充并分配 24 字节给这个结构。

struct B
{
    uint32_t var1;
    uint32_t var2;
    uint32_t var3;
    uint64_t var5;
};

为什么会有这种行为？ 如果编译器将数据对齐到 8 字节边界，则第一个结构中应该填充 4 个字节，并且在这种情况下不应填充第二个结构。 并且如果编译器将数据对齐到 4 字节边界，那么为什么在第二个结构中有 4 字节的填充？

编译器：GCC 平台：64 位 linux，x86_64

Answer 1

对齐规则（在 x86 和 x86_64 上）通常是根据变量的大小对齐变量。

换句话说，32 位变量在 4 个字节上对齐，64 位变量在 8 个字节上对齐，等等。

在你的第二种情况下，4 个字节的填充被添加到

uint32_t var3;
uint64_t var5;

让var5对齐 8 个字节。

出于这个原因，最好将数据成员从大到小排序（但由于数据局部性、可读性等原因，这并不那么简单）。

Answer 2

首先，结构对齐不是一门精确的科学，可能取决于体系结构和编译器。

在许多情况下，所有结构成员都根据最大的变量（以字节为单位）进行填充。 在您的第一个结构中，所有变量都是uint32_t ，长度为 4 个字节。 然后，您的结构大小等于sizeof(uint32_t) * 5 = 4 * 5 = 20 。

在您的第二个结构中，最大的元素是uint64_t ，其大小为 8 个字节。 所以所有元素都将根据 8 个字节进行填充。

前两个uint32_t被填充在一起，但第三个不能正确填充：如果用下一个整数填充，则uint64_t将一分为二！ 所以编译器决定让这个uint32_t自己独立以避免分裂uint64_t 。

以下是您的结构示例以及所有变量的地址：

struct A
{
  uint32_t var1;   /* ..00 */
  uint32_t var2;   /* ..04 */
  uint32_t var3;   /* ..08 */
  uint32_t var4;   /* ..12 */
  uint32_t var5;   /* ..16 */
};

struct B
{
  uint32_t var1;   /* ..00 */
  uint32_t var2;   /* ..04 */
  uint32_t var3;   /* ..08 */
  uint64_t var5;   /* ..16 */
};

Answer 3

#include <stdio.h>

typedef struct __atribute__((packed)) A {
    uint32_t var1;
    uint32_t var2;
    uint32_t var3;
    uint32_t var4;
    uint32_t var5;
} A ;


typedef struct __atribute__((packed)) B {
    uint32_t var1;
    uint32_t var2;
    uint32_t var3;
    uint64_t var4;
} B;


int main()
{
    printf("sizeof(A): {%d} sizeof(B): {%d}", sizeof(A), sizeof(B));

    return 0;
}

试试这个，它对我有用

Answer 4

struct B的填充几乎肯定不在末尾，而是在第三个 32 位成员之后：

struct B
{
    uint32_t var1;
    uint32_t var2;
    uint32_t var3;
    // 4-byte padding here
    uint64_t var5;
};

这是因为var1到var3加起来为 12 个字节，不能被 8 整除。您的编译器希望 8 字节整数类型位于可被 8 整除的地址上。

在这种情况下，您还将在结构的末尾获得填充：

struct C
{
   uint64_t memb1;
   uint32_t memb2;
   // Padding here
};

该填充是为了在struct C数组中对齐memb1 ：

struct C c_array[13];

当然c_array[0].memb1是对齐的，因为它位于数组的基地址。 但是c_array[1].memb1呢？ 如果结构中没有填充，它就不会对齐。

C 的定义方式是数组元素之间不能添加填充； 数组的元素是紧密分配的。 因此，如果需要填充，则必须将其硬塞到元素类型中。 结构的布局必须考虑可能的数组聚合。

Answer 5

尽管编译器可以按照他们认为合适的方式自由填充或不填充，但通常它们会在变量大小的倍数的边界上对齐变量。

在struct的情况下，填充基于最大原始元素的大小。 在第二个struct B的情况下，这将是类型为uint64_t var5 。

带有隐式填充的struct B的布局如下：

struct B
{
    uint32_t var1;      // offset 0
    uint32_t var2;      // offset 4
    uint32_t var3;      // offset 8
    uint32_t padding;   // offset 12
    uint64_t var5;      // offset 16
};

如果var5紧跟在var3 ，它将位于字节偏移量 12，这不是 8 的倍数。因此需要在var3之后填充 4 个字节以允许var5正确对齐。

在struct A的情况下，所有字段的大小都是 4 个字节，因此不需要填充。 如果您创建了这种类型的数组，例如struct A a[5] ，则a[1]将是a[0]之后a[0] 20 个字节， a[2]将是a[1]之后a[1] 20 个字节，依此类推。 向struct A添加填充会浪费空间，因为所有子字段仍然在它们需要的 4 字节边界上对齐。

Answer 6

虽然我确定有例外，但通常编译器会插入足够的填充来满足对齐要求，无论是对于结构中的字段还是对于整个结构。 C 编译器不允许对结构中的字段重新排序。

不同的类型可以有不同的对齐要求，一个类型的大小必须是它的对齐要求的倍数。 在大多数 64 位系统上，标准 C 基元类型的对齐要求与其大小相同。 结构通常具有与其成员的最高对齐要求相等的对齐要求。

有时必须填充结构以确保其成员满足对齐要求，并且结构作为一个整体的大小是其对齐要求的倍数。

所以让我们看看你的结构，加上第三个结构。

struct A
{
    uint32_t var1; //size 4, alignment 4, offset 0
    uint32_t var2; //size 4, alignment 4, offset 4
    uint32_t var3; //size 4, alignment 4, offset 8
    uint32_t var4; //size 4, alignment 4, offset 12
    uint32_t var5; //size 4, alignment 4, offset 16
};

所有字段都是 uint32_t 类型，大小为 4，对齐方式为 4。因此不需要填充，结构的整体大小为 20 字节，整体对齐方式为 4 字节。

struct B
{
    uint32_t var1; //size 4, alignment 4, offset 0
    uint32_t var2; //size 4, alignment 4, offset 4
    uint32_t var3; //size 4, alignment 4, offset 8
    //4 bytes of padding.
    uint64_t var5; //size 8, alignment 8, offset 16
};

前三个字段的大小和对齐方式为 4，因此可以在不填充的情况下分配它们。 但是var5的大小和对齐是8，所以不能在12偏移处分配。必须插入填充，var5在偏移16分配。整个结构的大小是24，对齐是8。

struct C
{
    uint32_t var1; //size 4, alignment 4, offset 0
    uint32_t var2; //size 4, alignment 4, offset 4
    uint64_t var3; //size 8, alignment 8, offset 8
    uint32_t var5; //size 4, alignment 4, offset 16
    //4 bytes of padding
};

在这种情况下，所有变量都可以分配到合适的偏移量，而无需插入填充。 然而，结构的总大小必须是其对齐要求的倍数（否则数组会破坏对齐），因此必须填充结构的末尾。 同样，整个结构的大小为 24，对齐为 8。

一些编译器具有覆盖结构的正常打包的机制，例如另一个答案中提到的__attribute__((packed)) 。 然而，必须极其谨慎地使用这些功能，因为它们很容易导致对齐违规。