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个字节上对齐，8位字节上的64位变量等等。

在第二种情况下，在

之间添加了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的情况下，填充基于最大原始元素的大小。对于第二个struct B，var5类型为uint64_t。

带有隐式填充的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]之后为20个字节，a[2]将在a[1]之后为20个字节，并且等等。向struct A添加填充会浪费空间，因为所有子字段仍然在所需的4字节边界上对齐。

Answer 5

struct B中的填充几乎肯定不在最后，但在第三个32位成员之后：

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

这是因为var1到var3最多加24个字节，不能被8整除。你的编译器想要一个8字节整数类型在一个可被8整除的地址上。

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

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

该填充是为memb1数组struct C中的struct C c_array[13]; 对齐而设的：

c_array[0].memb1

当然c_array[1].memb1是对齐的，因为它位于数组的基址。但是 Dim bm As New Bitmap(NomeFile) 呢？如果没有结构中的填充，它就不会对齐。

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

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))。但是，必须谨慎使用这些功能，因为它们很容易导致对齐冲突。