什么是 VC++打包位域时做什么？

Question

为了澄清我的问题，让我们从一个示例程序开始：

#include <stdio.h>

#pragma pack(push,1)
struct cc {
    unsigned int a   :  3;  
    unsigned int b   : 16;
    unsigned int c   :  1;
    unsigned int d   :  1;
    unsigned int e   :  1;
    unsigned int f   :  1;
    unsigned int g   :  1;
    unsigned int h   :  1;
    unsigned int i   :  6;  
    unsigned int j   :  6;  
    unsigned int k   :  4;  
    unsigned int l   : 15;
};
#pragma pack(pop)

struct cc c;

int main(int argc, char **argv)

{   printf("%d\n",sizeof(c));
}

输出是“8”，这意味着我要打包的56位（7字节）被打包成8字节，看起来浪费了整个字节。出于对编译器如何在内存中放置这些位的好奇，我尝试将特定值写入 &c，例如：

int main(int argc, char **argv)

{
unsigned long long int* pint = &c;
*pint = 0xFFFFFFFF;
printf("c.a = %d", c.a);
...
printf("c.l = %d", c.l);
}

可以预见的是，在 x86_64 上使用 Visual Studio 2010 年，会发生以下情况：

*pint = 0x00000000 000000FF :

c[0].a = 7
c[0].b = 1
c[0].c = 1
c[0].d = 1
c[0].e = 1
c[0].f = 1
c[0].g = 0
c[0].h = 0
c[0].i = 0
c[0].j = 0
c[0].k = 0
c[0].l = 0

*pint = 0x00000000 0000FF00 :

c[0].a = 0
c[0].b = 0
c[0].c = 0
c[0].d = 0
c[0].e = 0
c[0].f = 0
c[0].g = 1
c[0].h = 127
c[0].i = 0
c[0].j = 0
c[0].k = 0
c[0].l = 0


*pint = 0x00000000 00FF0000 :

c[0].a = 0
c[0].b = 0
c[0].c = 0
c[0].d = 0
c[0].e = 0
c[0].f = 0
c[0].g = 0
c[0].h = 32640
c[0].i = 0
c[0].j = 0
c[0].k = 0
c[0].l = 0

等等。

暂时忘记可移植性，假设您关心一个 CPU、一个编译器和一个运行时环境。为什么VC++不能把这个结构打包成7个字节呢？是字长的问题吗？ 上的 MSDN 文档 #pragma pack 表示“成员的对齐方式将位于 n 的倍数 [在我的例子中为 1] 或成员大小的倍数（以较小者为准）的边界上。”谁能告诉我为什么我得到的是 8 号而不是 7 号？

Answer 1

MSVC++ 始终至少分配一个与您用于位字段的类型相对应的内存单元。您使用了unsigned int，这意味着最初会分配一个unsigned int，当第一个unsigned int耗尽时会分配另一个unsigned int。无法强制 MSVC++ 修剪第二个 unsigned int 的未使用部分。

基本上，MSVC++ 将您的 unsigned int 解释为表达整个结构的对齐要求的一种方式。

对位字段使用较小的类型（unsigned short 和 unsigned char）并重新组合位字段，以便它们完全填充分配的单元 - 这样您应该能够将东西包装得尽可能紧密。

Answer 2

位域以您定义的类型存储。由于您使用的是 unsigned int，并且它不适合单个 unsigned int，因此编译器必须使用第二个整数并将最后 24 位存储在最后一个整数中。

Answer 3

好吧，您使用的是 unsigned int，在本例中恰好是 32 位。 unsigned int 的下一个边界（适合位域）是 64 位 => 8 字节。

Answer 4

pst 是正确的。 成员在 1 字节边界上对齐（或更小，因为它是位字段）。整个结构的大小为 8，并在 8 字节边界上对齐。这符合标准和 pack 选项。文档从未说过最后不会有填充。

Answer 5

为了给出另一个有趣的说明，请考虑您想要打包跨越类型边界的结构的情况。例如

struct state {
    unsigned int cost     : 24; 
    unsigned int back     : 21; 
    unsigned int a        :  1; 
    unsigned int b        :  1; 
    unsigned int c        :  1;
};

，据我所知，这个结构不能使用 MSVC 打包成 6 个字节。不过，我们可以通过拆开前两个字段来得到想要的打包效果：

struct state_packed {
    unsigned short cost_1   : 16; 
    unsigned char  cost_2   :  8;
    unsigned short back_1   : 16; 
    unsigned char  back_2   :  5;
    unsigned char  a        :  1; 
    unsigned char  b        :  1; 
    unsigned char  c        :  1; 
};

这样确实可以打包成6个字节。然而，访问原始成本字段是极其尴尬和丑陋的。一种方法是将 state_packed 指针转换为专门的虚拟结构：

struct state_cost {
    unsigned int cost     : 24;
    unsigned int junk     :  8; 
};

state_packed    sc;
state_packed *p_sc = ≻

sc.a = 1;
(*(struct state_cost *)p_sc).cost = 12345;
sc.b = 1;

如果有人知道更优雅的方法，我很想知道！