C 结构中的内存对齐

Question

我在 32 位机器上工作，所以我认为内存对齐应该是 4 个字节。假设我有这个结构：

typedef struct {
    unsigned short v1;
    unsigned short v2;
    unsigned short v3;
} myStruct;

普通添加的大小是 6 个字节，我认为对齐的大小应该是 8，但是 sizeof(myStruct) 返回我 6。

但是如果我写：

typedef struct {
    unsigned short v1;
    unsigned short v2;
    unsigned short v3;
    int i;
} myStruct;

普通添加的大小为 10 字节，对齐大小应为 12，这次 sizeof(myStruct) == 12。

有人可以解释一下有什么区别吗？

Answer 1

至少在大多数机器上，类型仅与与类型本身一样大的边界对齐[编辑：您实际上不能要求比这更多的对齐，因为您必须能够创建数组，并且您无法将填充插入数组]。在您的实现中，short 显然是 2 个字节，而 int 是 4 个字节。

这意味着您的第一个结构与 2 字节边界对齐。由于所有成员均为 2 个字节，因此在它们之间不插入任何填充。

第二个包含一个 4 字节项目，它与 4 字节边界对齐。由于它前面有 6 个字节，因此在 v3 和 i 之间插入 2 个字节的填充，从而在 short 中提供 6 个字节的数据，两个填充字节，以及 int 中的 4 个字节的数据，总共 12 个字节。

Answer 2

忘记拥有不同的成员，即使您编写的两个结构体的成员完全相同，但差异是它们声明的顺序不同，然后大小每个结构体的结构可以（并且经常是）不同。

例如，请参阅此内容，

#include <iostream>
using namespace std;
struct A
{
   char c;
   char d;
   int i; 
};
struct B
{
   char c;
   int i;   //note the order is different!
   char d;
};
int main() {
        cout << sizeof(A) << endl;
        cout << sizeof(B) << endl;
}

使用 gcc-4.3.4 编译它，您会得到以下输出：

8
12

也就是说，即使两个结构具有相同的成员，大小也不同！

Ideone 上的代码：http://ideone.com/HGGVl

底线是标准没有讨论如何应该进行填充，因此编译器可以自由地做出任何决定，并且您不能假设所有编译器都会做出相同的决定。

Answer 3

默认情况下，值根据其大小对齐。因此，像 short 这样的 2 字节值在 2 字节边界上对齐，而像 int 这样的 4 字节值在 4 字节边界上对齐

。在您的示例中，在 i 之前添加 2 个字节的填充，以确保 i 落在 4 字节边界上。

（整个结构在至少与结构中的最大值一样大的边界上对齐，因此您的结构将与 4 字节边界对齐。）

实际规则根据平台而异 - 维基百科页面 数据结构对齐有更多详细信息。

编译器通常允许您通过（例如）#pragma pack 指令控制打包。

Answer 4

假设：

sizeof(unsigned short) == 2
sizeof(int)            == 4

那么我个人会使用以下内容（您的编译器可能有所不同）：

unsigned shorts are aligned to 2 byte boundaries
int will be aligned to 4 byte boundaries.


typedef struct
{
   unsigned short v1;    // 0 bytes offset
   unsigned short v2;    // 2 bytes offset
   unsigned short v3;    // 4 bytes offset
} myStruct;              // End 6 bytes.


// No part is required to align tighter than 2 bytes. 
// So whole structure can be 2 byte aligned.

typedef struct
{
    unsigned short v1;      // 0 bytes offset
    unsigned short v2;      // 2 bytes offset
    unsigned short v3;      // 4 bytes offset
    /// Padding             // 6-7 padding (so i is 4 byte aligned)
    int i;                  // 8 bytes offset
} myStruct;                 // End 12 bytes

// Whole structure needs to be 4 byte aligned.
// So that i is correctly aligned.

Answer 5

首先，虽然填充的细节由编译器决定，但操作系统也强加了一些关于对齐要求的规则。这个答案假设您正在使用 gcc，尽管操作系统可能有所不同

要确定给定结构及其元素占用的空间，您可以遵循以下规则：

首先，假设该结构始终从与 < 正确对齐的地址开始em>所有数据类型。

然后对于结构中的每个条目：

• 所需的最小空间是由 sizeof(element) 给出的元素的原始大小。
• 元素的对齐要求是元素基类型的对齐要求。
  值得注意的是，这意味着 char[20] 数组的对齐要求与
  对普通 char 的要求。

最后，结构体作为一个整体的对齐要求是其每个元素的对齐要求的最大值。

gcc 将在给定元素之后插入填充，以确保下一个元素（或结构，如果我们谈论的是最后一个元素）正确对齐。它永远不会重新排列结构中元素的顺序，即使这会节省内存。

现在对齐要求本身也有点奇怪。

• 32位Linux要求2字节数据类型具有2字节对齐（它们的地址必须是偶数）。所有较大的数据类型必须具有 4 字节对齐（以 0x0、0x4、0x8 或 0xC 结尾的地址） 。请注意，这也适用于大于 4 字节的类型（例如 double 和 long double）。
• 32位Windows更加严格，如果一个类型的大小是K字节，那么它必须是K字节对齐的。这意味着 double 只能放置在以 0x0 或 0x8 结尾的地址处。唯一的例外是 long double，尽管它实际上是 12 字节长，但它仍然是 4 字节对齐的。
• 对于 Linux 和 Windows，在 64 位计算机上，K 字节类型必须是 K 字节对齐的。同样，long double 是一个例外，它必须是 16 字节对齐的。

Answer 6

每种数据类型都需要在其自身大小的内存边界上对齐。因此，short 需要在 2 字节边界上对齐，而 int 需要在 4 字节边界上对齐。同样，long long 需要位于 8 字节边界上。

Answer 7

第二个 sizeof(myStruct) 为 12 的原因是在 v3 和 i 之间插入填充以在 32 位边界处对齐 i。它有两个字节。

维基百科相当清楚地解释了填充和对齐。

Answer 8

在您的第一个结构中，由于每个项目的大小都是 short，因此整个结构可以在 short 边界上对齐，因此不需要在末尾添加任何填充。

在第二个结构中，int（大概是 32 位）需要字对齐，因此它在 v3 和 i 之间插入填充以对齐 i。

Answer 9

该标准没有过多说明具有完整类型的结构的布局 - 这取决于编译器。它决定需要 int 从边界开始才能访问它，但由于它必须对 Shorts 进行子边界内存寻址，因此不需要填充它们

Answer 10

听起来它是根据每个 var 的大小与边界对齐的，因此如果您在之后移动了其中一个 Shorts，则该地址是正在访问的大小的倍数（因此 Shorts 对齐到 2，ints 对齐到 4 等） int, sizeof(mystruct) 应该是 10。当然，这一切都取决于所使用的编译器及其依次使用的设置。