结构填充和包装

Question

考虑：

struct mystruct_A
{
   char a;
   int b;
   char c;
} x;

struct mystruct_B
{
   int b;
   char a;
} y;

结构的大小分别为 12 和 8。

这些结构是填充的还是包装的？

何时进行填充或包装？

Answer 1

填充 将结构成员与“自然”地址边界对齐 - 例如，< code>int 成员会有偏移量，在 32 位平台上为 mod(4) == 0。默认情况下，填充处于启用状态。它将以下“间隙”插入到您的第一个结构中：

struct mystruct_A {
    char a;
    char gap_0[3]; /* inserted by compiler: for alignment of b */
    int b;
    char c;
    char gap_1[3]; /* -"-: for alignment of the whole struct in an array */
} x;

打包，另一方面，会阻止编译器进行填充 - 这必须明确请求 - 在 GCC 下它是 __attribute__((__packed__))，因此以下内容：

struct __attribute__((__packed__)) mystruct_A {
    char a;
    int b;
    char c;
};

将在 32 位体系结构上生成大小为 6 的结构。

但需要注意的是，未对齐的内存访问在允许的架构（如 x86 和 amd64）上速度较慢，并且在 SPARC 等严格对齐架构上被明确禁止。

Answer 2

（上面的答案很清楚地解释了原因，但似乎对填充的大小并不完全清楚，所以，我将根据我从 结构打包的失落艺术，它已经发展到不仅限于C，而是也适用于Go、Rust。）

---

内存对齐（对于结构）

规则：

• 在每个单独的成员之前，都会有填充以便使其从可被其对齐要求整除的地址开始。
  例如，在许多系统上，int 应该从可被 4 整除的地址开始，而 short 则应从可被 2 整除的地址开始。
• char 和 char[ ] 很特殊，可以是任何内存地址，因此它们之前不需要填充。
• 对于struct，除了每个单独成员的对齐需要之外，整个结构本身的大小将通过在末尾进行填充来对齐到可被其任何成员的最严格对齐要求整除的大小。
  例如，在许多系统上，如果结构的最大成员是int，则可以被4整除，如果short，则可以被2整除。

成员顺序：

• 成员的顺序可能会影响结构的实际大小，因此请记住这一点。
  例如，下面示例中的 stu_c 和 stu_d 具有相同的成员，但顺序不同，并导致这两个结构的大小不同。

---

内存中的地址（对于结构）

空空间：

• 两个结构之间的空空间可以被适合的非结构变量使用。
  例如，在下面的 test_struct_address() 中，变量 x 位于相邻的结构 g 和 h 之间。
  无论x是否声明，h的地址都不会改变，x只是复用了g的空白空间代码>浪费了。
  y 的情况类似。

---

示例

（对于 64 位系统）

memory_align.c：

/**
 * Memory align & padding - for struct.
 * compile: gcc memory_align.c
 * execute: ./a.out
 */ 
#include <stdio.h>

// size is 8, 4 + 1, then round to multiple of 4 (int's size),
struct stu_a {
    int i;
    char c;
};

// size is 16, 8 + 1, then round to multiple of 8 (long's size),
struct stu_b {
    long l;
    char c;
};

// size is 24, l need padding by 4 before it, then round to multiple of 8 (long's size),
struct stu_c {
    int i;
    long l;
    char c;
};

// size is 16, 8 + 4 + 1, then round to multiple of 8 (long's size),
struct stu_d {
    long l;
    int i;
    char c;
};

// size is 16, 8 + 4 + 1, then round to multiple of 8 (double's size),
struct stu_e {
    double d;
    int i;
    char c;
};

// size is 24, d need align to 8, then round to multiple of 8 (double's size),
struct stu_f {
    int i;
    double d;
    char c;
};

// size is 4,
struct stu_g {
    int i;
};

// size is 8,
struct stu_h {
    long l;
};

// test - padding within a single struct,
int test_struct_padding() {
    printf("%s: %ld\n", "stu_a", sizeof(struct stu_a));
    printf("%s: %ld\n", "stu_b", sizeof(struct stu_b));
    printf("%s: %ld\n", "stu_c", sizeof(struct stu_c));
    printf("%s: %ld\n", "stu_d", sizeof(struct stu_d));
    printf("%s: %ld\n", "stu_e", sizeof(struct stu_e));
    printf("%s: %ld\n", "stu_f", sizeof(struct stu_f));

    printf("%s: %ld\n", "stu_g", sizeof(struct stu_g));
    printf("%s: %ld\n", "stu_h", sizeof(struct stu_h));

    return 0;
}

// test - address of struct,
int test_struct_address() {
    printf("%s: %ld\n", "stu_g", sizeof(struct stu_g));
    printf("%s: %ld\n", "stu_h", sizeof(struct stu_h));
    printf("%s: %ld\n", "stu_f", sizeof(struct stu_f));

    struct stu_g g;
    struct stu_h h;
    struct stu_f f1;
    struct stu_f f2;
    int x = 1;
    long y = 1;

    printf("address of %s: %p\n", "g", &g);
    printf("address of %s: %p\n", "h", &h);
    printf("address of %s: %p\n", "f1", &f1);
    printf("address of %s: %p\n", "f2", &f2);
    printf("address of %s: %p\n", "x", &x);
    printf("address of %s: %p\n", "y", &y);

    // g is only 4 bytes itself, but distance to next struct is 16 bytes(on 64 bit system) or 8 bytes(on 32 bit system),
    printf("space between %s and %s: %ld\n", "g", "h", (long)(&h) - (long)(&g));

    // h is only 8 bytes itself, but distance to next struct is 16 bytes(on 64 bit system) or 8 bytes(on 32 bit system),
    printf("space between %s and %s: %ld\n", "h", "f1", (long)(&f1) - (long)(&h));

    // f1 is only 24 bytes itself, but distance to next struct is 32 bytes(on 64 bit system) or 24 bytes(on 32 bit system),
    printf("space between %s and %s: %ld\n", "f1", "f2", (long)(&f2) - (long)(&f1));

    // x is not a struct, and it reuse those empty space between struts, which exists due to padding, e.g between g & h,
    printf("space between %s and %s: %ld\n", "x", "f2", (long)(&x) - (long)(&f2));
    printf("space between %s and %s: %ld\n", "g", "x", (long)(&x) - (long)(&g));

    // y is not a struct, and it reuse those empty space between struts, which exists due to padding, e.g between h & f1,
    printf("space between %s and %s: %ld\n", "x", "y", (long)(&y) - (long)(&x));
    printf("space between %s and %s: %ld\n", "h", "y", (long)(&y) - (long)(&h));

    return 0;
}

int main(int argc, char * argv[]) {
    test_struct_padding();
    // test_struct_address();

    return 0;
}

执行结果 - test_struct_padding()：< /strong>

stu_a: 8
stu_b: 16
stu_c: 24
stu_d: 16
stu_e: 16
stu_f: 24
stu_g: 4
stu_h: 8

执行结果 - test_struct_address():

stu_g: 4
stu_h: 8
stu_f: 24
address of g: 0x7fffd63a95d0  // struct variable - address dividable by 16,
address of h: 0x7fffd63a95e0  // struct variable - address dividable by 16,
address of f1: 0x7fffd63a95f0 // struct variable - address dividable by 16,
address of f2: 0x7fffd63a9610 // struct variable - address dividable by 16,
address of x: 0x7fffd63a95dc  // non-struct variable - resides within the empty space between struct variable g & h.
address of y: 0x7fffd63a95e8  // non-struct variable - resides within the empty space between struct variable h & f1.
space between g and h: 16
space between h and f1: 16
space between f1 and f2: 32
space between x and f2: -52
space between g and x: 12
space between x and y: 12
space between h and y: 8

因此每个变量的起始地址为 g:d0 x:d h:e0 y:e8

Answer 3

我知道这个问题很老了，这里的大多数答案都很好地解释了填充，但是在尝试自己理解它时，我认为对正在发生的事情有一个“视觉”图像会有所帮助。

处理器以一定大小（字）的“块”读取内存。假设处理器字长为 8 个字节。它将内存视为一大排 8 字节构建块。每当它需要从内存中获取一些信息时，它就会到达这些块之一并获取它。

如上图所示，Char（1 字节长）在哪里并不重要，因为它会位于这些块之一内，只需要 CPU 处理 1 个字。

当我们处理大于 1 字节的数据时，例如 4 字节 int 或 8 字节 double，它们在内存中的对齐方式会影响 CPU 必须处理的字数。如果 4 字节块以某种方式对齐，它们总是适合块内部（内存地址是 4 的倍数），则只需处理一个字。否则，一块 4 字节的块可能会在一个块上有一部分，在另一个块上有一部分，从而需要处理器处理 2 个字才能读取该数据。

这同样适用于 8 字节双精度数，只不过现在它必须位于 8 倍的内存地址中，以保证它始终位于块内。

这里考虑的是 8 字节字处理器，但该概念也适用于其他大小的字。

填充的工作原理是填充这些数据之间的间隙，以确保它们与这些块对齐，从而提高读取内存时的性能。

然而，正如其他答案所述，有时空间比性能本身更重要。也许您正在一台没有太多 RAM 的计算机上处​​理大量数据（可以使用交换空间，但速度要慢得多）。您可以在程序中排列变量，直到完成最少的填充（因为在其他一些答案中得到了很好的例证），但如果这还不够，您可以显式禁用填充，这就是打包。

Answer 4

结构填充抑制结构填充，当对齐最重要时使用填充，当空间最重要时使用填充。

一些编译器提供#pragma 来抑制填充或将其打包为 n 个字节。有些提供关键字来执行此操作。通常用于修改结构填充的编译指示将采用以下格式（取决于编译器）：

#pragma pack(n)

例如 ARM 提供 __packed 关键字来抑制结构填充。请阅读编译器手册以了解有关此内容的更多信息。

因此，压缩结构是一种没有填充的结构。

通常，压缩结构将用于

• 节省空间

• 格式化数据结构以通过网络传输，使用一些
  协议（这当然不是一个好的做法，因为你需要
  处理字节顺序）

Answer 5

填充和打包只是同一件事的两个方面：

• 打包或对齐是每个成员四舍五入的大小
• 填充是为匹配对齐而添加的额外空间

在mystruct_A中，假设默认对齐为4、每个成员按4字节的倍数对齐。由于 char 的大小为 1，因此 a 和 c 的填充为 4 - 1 = 3 个字节，而 不需要填充>int b 已经是 4 个字节了。 mystruct_B 的工作方式相同。

Answer 6

变量存储在可被其对齐方式（通常是其大小）整除的任何地址。因此，填充/打包不仅仅适用于结构。实际上，所有数据都有自己的对齐要求：

int main(void) {
    // We assume the `c` is stored as first byte of machine word
    // as a convenience! If the `c` was stored as a last byte of previous
    // word, there is no need to pad bytes before variable `i`
    // because `i` is automatically aligned in a new word.

    char      c;  // starts from any addresses divisible by 1(any addresses).
    char pad[3];  // not-used memory for `i` to start from its address.
    int32_t   i;  // starts from any addresses divisible by 4.

这与struct类似，但也有一些区别。首先，我们可以说有两种填充 - a) 为了正确地从每个成员的地址开始，在成员之间插入一些字节。 b) 为了正确地从其地址开始下一个结构实例，需要将一些字节附加到每个结构：

// Example for rule 1 below.
struct st {
    char      c;  // starts from any addresses divisible by 4, not 1.
    char pad[3];  // not-used memory for `i` to start from its address.
    int32_t   i;  // starts from any addresses divisible by 4.
};

// Example for rule 2 below.
struct st {
    int32_t   i;  // starts from any addresses divisible by 4.
    char      c;  // starts from any addresses.
    char pad[3];  // not-used memory for next `st`(or anything that has same
                  // alignment requirement) to start from its own address.
};

1. 结构的第一个成员始终从可被结构自身的对齐要求整除的任何地址开始，该对齐要求由最大成员的对齐要求确定（此处 4< /code>，int32_t 的对齐方式）。这与普通变量不同。普通变量可以从任何可被其对齐整除的地址开始，但结构体的第一个成员的情况并非如此。如您所知，结构体的地址与其第一个成员的地址相同。
2. 结构体内部可以有额外的填充尾随字节，使下一个结构体（或结构体数组中的下一个元素）从其自己的地址开始。想想 struct st arr[2]; 。为了使 arr[1]（arr[1] 的第一个成员）从可被 4 整除的地址开始，我们应该在每个结构体的末尾附加 3 个字节。

这是我从失落的结构包装艺术中学到的。

注意：您可以通过_Alignof运算符研究数据类型的对齐要求。另外，您可以通过 offsetof 宏获取结构体中成员的偏移量。

Answer 7

填充规则：

1. 结构体的每个成员都应位于可被其大小整除的地址处。
   在元素之间或结构的末尾插入填充以确保满足此规则。这样做是为了让硬件更轻松、更高效地访问总线。
2. 结构体末尾的填充是根据结构体最大成员的大小决定的。

为什么规则 2：
考虑以下结构，

如果我们要创建此结构的数组（包含 2 个结构），
末尾不需要填充：

因此，结构的大小 = 8 字节

假设我们要创建另一个结构，如下所示：

png" rel="nofollow noreferrer">

如果我们要创建此结构的数组，
末尾所需的填充字节数有两种可能性。

A. 如果我们在末尾添加 3 个字节并将其对齐为 int 而不是 Long：

B. 如果我们在末尾添加 7 个字节并将其对齐为 Long：

< /a>

第二个数组的起始地址是8的倍数（即24）。
结构的大小 = 24 字节

因此，通过将结构的下一个数组的起始地址对齐到最大成员的倍数（即，如果我们要创建此结构的数组，则第二个数组的首地址必须从结构体最大成员的倍数开始，我们可以计算出末尾所需的填充字节数。

Answer 8

这些结构是填充的还是包装的？

它们有衬垫。

最初浮现在脑海中的唯一可能的情况是，如果 char 和 int 的大小相同，那么最小的char/int/char 结构的大小不允许填充，int/char 结构也是如此。

但是，这需要 sizeof(int) 和 sizeof(char) 都为4（以获得十二个和八个大小）。整个理论分崩离析，因为标准保证 sizeof(char) 始终为 1。

如果 char 和 int 宽度相同，则大小将是一加一，而不是四加四。因此，为了获得 12 的大小，必须在最后一个字段之后进行填充。

---

什么时候进行填充或打包？

每当编译器实现需要它时。编译器可以自由地在字段之间以及最后一个字段之后插入填充（但不在第一个字段之前）。

这样做通常是为了性能，因为某些类型在特定边界上对齐时性能更好。甚至有一些架构在您尝试访问未对齐的数据时会拒绝运行（即崩溃）（是的，我正在看您， ARM）。

通常，您可以使用#pragma pack 等特定于实现的功能来控制打包/填充（这实际上是同一范围的两端）。即使您在特定实现中无法做到这一点，您也可以在编译时检查代码以确保其满足您的要求（使用标准 C 功能，而不是特定于实现的内容）。

例如：

// C11 or better ...
#include <assert.h>
struct strA { char a; int  b; char c; } x;
struct strB { int  b; char a;         } y;
static_assert(sizeof(struct strA) == sizeof(char)*2 + sizeof(int), "No padding allowed");
static_assert(sizeof(struct strB) == sizeof(char)   + sizeof(int), "No padding allowed");

如果这些结构中有任何填充，类似的东西将拒绝编译。

Answer 9

仅当您明确告诉编译器打包结构时，才会完成结构打包。填充就是您所看到的。您的 32 位系统正在填充每个字段以进行字对齐。如果您告诉编译器打包结构，它们将分别为 6 和 5 字节。但不要这样做。它不可移植，并使编译器生成速度慢得多（有时甚至有错误）的代码。

Answer 10

没有什么但是！想要掌握这个主题，必须做到以下几点，

• 仔细阅读 Eric S. Raymond 撰写的失落的结构打包艺术< /里>
• 浏览Eric 的代码示例
• 最后但并非最不重要的一点是，不要忘记以下关于填充的规则：结构与最大类型的对齐方式对齐
  要求。

Answer 11

数据结构对齐是数据在计算机内存中排列和访问的方式。它由两个独立但相关的问题组成：数据对齐和数据结构填充。当现代计算机读取或写入内存地址时，它将以字大小的块（例如，32 位系统上的 4 字节块）或更大的形式执行此操作。数据对齐意味着将数据放置在等于字大小的某个倍数的内存地址处，这会由于 CPU 处理内存的方式而提高系统的性能。为了对齐数据，可能需要在最后一个数据结构的末尾和下一个数据结构的开头之间插入一些无意义的字节，这就是数据结构填充。

1. 为了对齐内存中的数据，在内存分配时，在为其他结构成员分配的内存地址之间插入（或留空）一个或多个空字节（地址）。这个概念称为结构填充。
2. 计算机处理器的架构是这样的：一次可以从内存中读取 1 个字（32 位处理器中为 4 个字节）。
3. 为了利用处理器的这一优势，数据总是按 4 字节包对齐，这会导致在其他成员地址之间插入空地址。
4. 由于C中的这种结构填充概念，结构的大小总是与我们想象的不一样。