这个结构的大小是如何变成 4 字节的

发布于 2024-11-30 07:45:59 字数 297 浏览 1 评论 0原文

我确实有一个包含位字段的结构。根据我的说法，它是 2 个字节，但结果是 4 个字节。我已经在 stackoverflow 上阅读了一些与此相关的问题，但无法与我的问题相关。这是我确实拥有的结构

struct s{
char b;
int c:8;
};
int main()
{
printf("sizeof struct s = %d bytes \n",sizeof(struct s));
return 0;
}

，如果 int 类型必须位于其内存边界上，那么输出应该是 8 个字节，但它显示 4 个字节？

原文

I do have a structure having bit-fields in it.Its comes out to be 2 bytes according to me but its coming out to be 4 .I have read some question related to this here on stackoverflow but not able to relate to my problem.This is structure i do have

struct s{
char b;
int c:8;
};
int main()
{
printf("sizeof struct s = %d bytes \n",sizeof(struct s));
return 0;
}

if int type has to be on its memory boundary,then output should be 8 bytes but its showing 4 bytes??

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

微凉徒眸意 2024-12-07 07:45:59

在此处输入图像描述

来源：http://geeksforgeeks.org/?p=9705

总之：它正在优化位的打包（这就是位字段的用途）在不影响对齐的情况下尽可能最大化。

变量的数据对齐涉及数据存储在这些存储体中的方式。例如，int在32位机器上的自然对齐是4个字节。当数据类型自然对齐时，CPU 会以最少的读取周期获取它。

同样，short int 的自然对齐是 2 个字节。这意味着，一个短整型可以存储在bank 0 –bank 1对或bank 2 –bank 3对中。 double 需要 8 个字节，并占用存储体中的两行。双精度的任何未对齐都会强制两个以上的读取周期来获取双精度数据。

请注意，双精度变量将在 32 位机器上分配在 8 字节边界上，并且需要两个内存读取周期。在 64 位机器上，根据存储体数量，双精度变量将分配在 8 字节边界上，并且只需要一个内存读取周期。

因此编译器会对每个结构体引入对齐要求。它将作为结构中最大的成员。如果您从 struct 中删除 char，您仍将获得 4 个字节。

在您的 struct 中，char 是 1 字节对齐的。它后面是一个 int 位字段，它是 4 字节对齐的整数，但您定义了一个位字段。

8 位 = 1 字节。 Char 可以是任何字节边界。所以 Char + Int:8 = 2 个字节。嗯，这是一个奇数字节边界，因此编译器添加了额外的 2 个字节来维持 4 字节边界。

要使其为 8 个字节，您必须声明一个实际的 int（4 个字节）和一个 char（1 个字节）。那是 5 个字节。嗯，这是另一个奇数字节边界，因此 struct 被填充为 8 字节。

我过去控制填充的常用做法是在我的 struct 之间放置填充符，以始终保持 4 字节边界。因此，如果我有一个像这样的 struct：

struct s {
    int id;
    char b;
};

我将按如下方式插入分配：

struct d {
    int id;
    char b;
    char temp[3];
}

这将为我提供一个大小为 4 个字节 + 1 个字节 + 3 个字节的 struct = 8 字节！这样我就可以确保我的 struct 按照我想要的方式填充，特别是当我通过网络将其传输到某个地方时。另外，如果我改变了我的实现（例如，如果我可能将此struct保存到二进制文件中，填充符从一开始就在那里，所以只要我保持了最初的结构，一切都很好！）

最后，您可以在 带位字段的 C 结构大小以获取更多说明。

enter image description here

Source: http://geeksforgeeks.org/?p=9705

In sum: it is optimizing the packing of bits (that's what bit-fields are meant for) as maximum as possible without compromising on alignment.

A variable’s data alignment deals with the way the data stored in these banks. For example, the natural alignment of int on 32-bit machine is 4 bytes. When a data type is naturally aligned, the CPU fetches it in minimum read cycles.

Similarly, the natural alignment of short int is 2 bytes. It means, a short int can be stored in bank 0 – bank 1 pair or bank 2 – bank 3 pair. A double requires 8 bytes, and occupies two rows in the memory banks. Any misalignment of double will force more than two read cycles to fetch double data.

Note that a double variable will be allocated on 8 byte boundary on 32 bit machine and requires two memory read cycles. On a 64 bit machine, based on number of banks, double variable will be allocated on 8 byte boundary and requires only one memory read cycle.

So the compiler will introduce alignment requirement to every structure. It will be as that of the largest member of the structure. If you remove char from your struct, you will still get 4 bytes.

In your struct, char is 1 byte aligned. It is followed by an int bit-field, which is 4 byte aligned for integers, but you defined a bit-field.

8 bits = 1 byte. Char can be any byte boundary. So Char + Int:8 = 2 bytes. Well, that's an odd byte boundary so the compiler adds an additional 2 bytes to maintain the 4-byte boundary.

For it to be 8 bytes, you would have to declare an actual int (4 bytes) and a char (1 byte). That's 5 bytes. Well that's another odd byte boundary, so the struct is padded to 8 bytes.

What I have commonly done in the past to control the padding is to place fillers in between my struct to always maintain the 4 byte boundary. So if I have a struct like this:

struct s {
    int id;
    char b;
};

I am going to insert allocation as follows:

struct d {
    int id;
    char b;
    char temp[3];
}

That would give me a struct with a size of 4 bytes + 1 byte + 3 bytes = 8 bytes! This way I can ensure that my struct is padded the way I want it, especially if I transmit it somewhere over the network. Also, if I ever change my implementation (such as if I were to maybe save this struct into a binary file, the fillers were there from the beginning and so as long as I maintain my initial structure, all is well!)

Finally, you can read this post on C Structure size with bit-fields for more explanation.

回复收藏 0 原文