C语言当中位段的使用

妖狐艹你老母 2022-07-24 04:06 172阅读 0赞

文章来源 [http://hi.baidu.com/colin719/blog/item/3f1783138e635f806538db40.html][http_hi.baidu.com_colin719_blog_item_3f1783138e635f806538db40.html]

C语言当中位段的使用

2007-01-13 20:54

<table style="width: 100%; table-layout: fixed;"> 
 <tbody> 
 <tr> 
 <td> 
 <div> 
 位段以位为单位定义结构体（或共用体）中成员所占存储空间的长度。 &nbsp;含有位段的结构体类型称为位段结构。 
 位段结构也是一种结构体类型，只不过其中含有以位为单位定义存储长度的整数类型位段成员。采用位段结构既节省存储空间，又可方便操作。 
 位段结构中位段的定义格式为： &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; unsigned &lt;成员名&gt;:&lt;二进制位数&gt; 例如： struct bytedata {unsigned a:2;&nbsp;&nbsp; /*位段a，占2位*/ &nbsp;unsigned:6;&nbsp; /*无名位段，占6位，但不能访问*/ &nbsp;unsigned:0;&nbsp;&nbsp;&nbsp;&nbsp; /*无名位段，占0位，表下一位段从下一字边界开始*/ &nbsp;unsigned b:10;&nbsp; /*位段b，占10位*/ &nbsp;int i;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /*成员i，从下一字边界开始*/ }data; 
 位段数据的引用: 同结构体成员中的数据引用一样，但应注意位段的最大取值范围不要超出二进制位数定的范围，否则超出部分会丢弃。 例如：data.a=2;&nbsp;&nbsp; 但&nbsp; data.a=10;就超出范围（a占2位，最大3） 
 关于位段数据，注意以下几点: 
 （1）一个位段必须存储在同一存储单元（即字）之中，不能跨两个单元。如果其单元空间不够，则剩余空间不用，从下一个单元起存放该位段。 （2）可以通过定义长度为0的位段的方式使下一位段从下一存储单元开始。 （3）可以定义无名位段。 （4）位段的长度不能大于存储单元的长度。 （5）位段无地址，不能对位段进行取地址运算。 （6）位段可以以%d，%o，%x格式输出。 （7）位段若出现在表达式中，将被系统自动转换成整数。 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

from  [http://blog.csdn.net/junli0310/archive/2007/09/02/1769406.aspx][http_blog.csdn.net_junli0310_archive_2007_09_02_1769406.aspx]

C语言中的结构是有实现位段的能力的，噢！你问它到底是什么形式是吧？这个问题呆会给你答案。让我们先看看位段的作用：位段是在字段的声明后面加一个冒号以及一个表示字段位长的整数来实现的。这种用法又被就叫作“深入逻辑元件的编程”，如果你对系统编程感兴趣，那么这篇文章你就不应该错过！  
　　我把使用位段的几个理由告诉大家：1、它能把长度为奇数的数据包装在一起，从而节省存储的空间；2、它可以很方便地访问一个整型值的部分内容。  
　　首先我要提醒大家注意几点：1、位段成员只有三种类型：int ,unsigned int 和signed int这三种（当然了，int型位段是不是可以取负数不是我说了算的，因为这是和你的编译器来决定的。位段，位段，它是用来表示字段位长（bit）的，它只有整型值，不会有7.2这种float类型的，如果你说有，那你就等于承认了有7.2个人这个概念，当然也没有char这个类型的）；2、成员名后面的一个冒号和一个整数，这个整数指定该位段的位长（bit）;3、许多编译器把位段成员的字长限制在一个int的长度范围之内；4、位段成员在内存的实现是从左到右还是从右到左是由编译器来决定的，但二者皆对。  
　　下面我们就来看看，它到底是什么东西（我先假定大家的机器字长为32位）：  
　　Struct WORD  
　　\{  
unsigned int chara: 6:  
unsigned int font : 7;  
unsigned int maxsize : 19;  
　　\};  
　　Struct WORD chone;  
　　这一段是从我编写的一个文字格式化软件摘下来的，它最多可以容纳64（既我说的unsigned int chara :6; 它总共是6位）个不同的字符值，可以处理128（既unsigned int font : 7 ;既2的7次方）种不同的字体，和2的19次方的单位长度的字。大家都可以看到maxsize是19位，它是无法被一个short int 类型的值所容纳的，我们又可以看到其余的成员的长度比char还小，这就让我们想起让他们共享32位机器字长，这就避免用一个32位的整数来表示maxsize的位段。怎么样？还要注意的是刚才的那一段代码在16位字长的机器上是无法实现的，为什么？提醒你一下，看看上面提醒的第3点，你会明白的！  
你是不是发现这个东西没有用啊？如果你点头了，那你就错了！这么伟大的创造怎么会没有用呢（你对系统编程不感兴趣，相信你会改变这么一个观点的）？磁盘控制器大家应该知道吧？软驱与它的通信我们来看看是怎么实现的下面是一个磁盘控制器的寄存器：  
│←5→│←5→│←9→│←8→│←1→│←1→∣←1→∣←1→∣←1→∣  
　　上面位段从左到右依次代表的含义为：5位的命令，5位的扇区，9位的磁道，8位的错误代码，1位的HEAD LOADED,1位的写保护，1位的DISK SPINNING，1位的错误判断符，还有1位的READY位。它要怎么来实现呢？你先自己写写看：  
　　struct DISK\_FORMAT  
　　\{  
　　　unsigned int command : 5;  
　　　　　unsigned sector : 5;  
　　　unsigned track : 9 ;  
　　　unsigned err\_code : 8;  
　　　unsigned ishead\_loaded : 1;  
　　　unsigned iswrit\_protect : 1;  
　　　unsigned isdisk\_spinning : 1;  
　　　unsigned iserr\_ocur : 1;  
　　　undigned isready :1 ;  
　　\};  
　　注：代码中除了第一行使用了unsigned int 来声明位段后就省去了int ，这是可行的，详见ANCI C标准。  
　　如果我们要对044c18bfH的地址进行访问的话，那就这样：  
　　\#define DISK ((struct DISK\_FORMAT \*)0x044c18bf)  
　　DISK->sector=fst\_sector;  
　　DISK->track=fst\_track;  
　　DISK->command=WRITE;  
　　当然那些都是要宏定义的哦！  
　　我们用位段来实现这一目的是很方便的，其实这也可以用移位或屏蔽来实现，你尝试过就知道哪个更方便了！  
　　我们今天的话题就到这儿，如果诸位还有疑问，可e-mail给我:arhuwen@163.com;  
　　特别声明哦：不要把以上内容用于不法行为，否则后果自负。另外本文不可用于任何谋取商业利益的举动，否则同上！

C编译器对结构空间缺省的分配  
　　在C语言中，结构是一种复合数据类型，其构成元素既可以是基本数据类型（如int、long、float等）的变量，也可以是一些复合数据类型（如数组、结构、联合等等）的数据单元。在结构中，编译器为结构的每个成员按其自然对界（alignment）条件分配空间；各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。在缺省情况下，C编译器为每一个变量或是数据单元按其自然对界条件分配空间，见表1：

表1：Win32下的自然对界条件  
例如，下面的结构各成员空间分配情况如图1：  
struct test \{  
char x1;  
short x2;  
float x3;  
char x4;  
\};  
　　  
　　　　　　　　　　　　　　　　　图1：缺省结构空间分配  
　　结构的第一个成员x1，其偏移地址为0，占据了第1个字节。第二个成员x2为short类型，其起始地址必须2字节对界，因此，编译器在x2和x1之间填充了一个空字节。结构的第三个成员x3和第四个成员x4恰好落在其自然对界地址上，在它们前面不需要额外的填充字节。在test结构中，成员x3要求4字节对界，是该结构所有成员中要求的最大对界单元，因而test结构的自然对界条件为4字节，编译器在成员x4后面填充了3个空字节。整个结构所占据空间为12字节。

结构中的位段  
　　所谓位段是以位为单位定义长度的结构体类型中的成员。编译器对结构中位段的分配遵从下面几点原则：  
? 对于长度为0的位段，其下一个位段从下一个存储单元开始存放：  
如：  
struct T \{  
unsigned char a : 1;  
unsigned char b : 2;  
unsigned : 0;  
unsigned c : 3;  
\};  
　　结构T的成员a和b在一个存储单元中，c则在另一个存储单元中。  
　　? 一个位段必须存储在同一存储单元中，不能跨两个单元：  
如：  
struct T \{  
unsigned char a : 4;  
unsigned char b : 6;  
\};  
　　结构T的成员a在一个存储单元中，b则在另一个存储单元中。

更改C编译器的缺省分配策略  
　　一般地，可以通过下面的两种方法改变缺省的对界条件：  
　　? 使用伪指令\#pragma pack (\[n\])  
　　? 在编译时使用命令行参数  
\#pragma pack (\[n\])伪指令允许你选择编译器为数据分配空间所采取的对界策略，见表2：

表2：更改缺省对界条件  
　　在Microsfot Visual C++中，命令行参数/Zp\[n\]可以改变缺省对界条件；在Borland C++ Builder中，命令行参数-a\[n\]可以改变缺省对界条件。n的含义和\#pragma pack中的n相同。  
　　例如，在使用了\#pragma pack (1)伪指令后，test结构各成员的空间分配情况如图2所示：  
　　  
　　  
　　　　　　　　　　　　图2：使用\#pragma pack (1)后的结构空间分配

应用实例

我们在日常编程工作中，特别是对一些网络事务的处理，经常会同其他人有着各种各样的协议：如我传给你20字节的头，前4个字节表示……等等。很多人都是通过指针偏移的方法来得到各种信息，这样做，不仅编程复杂，而且一旦协议有变化，程序修改起来也比较麻烦。在了解了编译器对结构空间的分配原则之后，我们完全可以利用这一特性定义自己的协议结构，通过访问结构的成员来获取各种信息。这样做，不仅简化了编程，而且即使协议发生变化，我们也只需修改协议结构的定义即可，其它程序无需修改，省时省力。下面以TCP协议首部为例，说明如何定义协议结构。  
　　TCP协议首部如图3所示：  
　　  
　　  
　　　　　　　　　　 图3：TCP首部  
其协议结构定义如下：  
struct TCPHEADER \{  
short SrcPort; // 16位源端口号  
short DstPort; // 16位目的端口号  
int SerialNo; // 32位序列号  
int AckNo; // 32位确认号  
unsigned char HaderLen : 4; // 4位首部长度  
unsigned char Reserved1 : 4; // 保留6位中的4位  
unsigned char Reserved2 : 2; // 保留6位中的2位  
unsigned char URG : 1;  
unsigned char ACK : 1;  
unsigned char PSH : 1;  
unsigned char RST : 1;  
unsigned char SYN : 1;  
unsigned char FIN : 1;  
short WindowSize; // 16位窗口大小  
short TcpChkSum; // 16位TCP检验和  
short UrgentPointer; // 16位紧急指针  
\};  
其协议结构还可以定义为如下的形式：  
struct TCPHEADER \{  
short SrcPort; // 16位源端口号  
short DstPort; // 16位目的端口号  
int SerialNo; // 32位序列号  
int AckNo; // 32位确认号  
unsigned char HaderLen : 4; // 4位首部长度  
unsigned char : 0; // 保留6位中的4位  
unsigned char Reserved : 2; // 保留6位中的2位  
unsigned char URG : 1;  
unsigned char ACK : 1;  
unsigned char PSH : 1;  
unsigned char RST : 1;  
unsigned char SYN : 1;  
unsigned char FIN : 1;  
short WindowSize; // 16位窗口大小  
short TcpChkSum; // 16位TCP检验和  
short UrgentPointer; // 16位紧急指针

本文来自CSDN博客，转载请标明出处：[http://blog.csdn.net/junli0310/archive/2007/09/02/1769406.aspx][http_blog.csdn.net_junli0310_archive_2007_09_02_1769406.aspx]

from [http://hi.baidu.com/%B8%F8%EB%DE%CC%ED%CD%EB%B7%B9/blog/item/8ab4ae1f9d15fa0d304e15f4.html][http_hi.baidu.com_B8_F8_EB_DE_CC_ED_CD_EB_B7_B9_blog_item_8ab4ae1f9d15fa0d304e15f4.html]

### 1.什么是位段 ###

> 在前面各章中, 我们已经讨论过字节概念了。在大多数的计算机系统中, 一个字节是由八个更小的, 称作为位的单位组成的。位是比字节更小的单位。位只有两个值, 1 或 0 。因此, 存储在计算机存储器中的一个字节可以看成由八个二进制数字形成的串。  
>   
> 例如, 一个存放值 36 的字节是八个二进制数字的串: 可以表示成 00100100。 存入值24 的字节可以表示成 00010100。  
>   
> 有时, 我们希望不仅对字节进行操作, 也要能对位进行操作。例如, 用布尔真或假条件表示的标志, 在计算机中可用位来表示。  
>   
> 但是, 说明一个用作标志的普通变量至少要用一个字节---8 位, 而在某些计算机系统中则可能是 16 位。 如果我们想在一个很大的表中存储很多标志, 那么 "被浪费" 的内存空间是很可观的。在 C 语言中, 一种方法是用叫做位段的构造类型来定义一个压缩信息的结构。
> 
> ![weid1.jpg][]什么是位段呢? 位段是 C 语言特有的数据结构, 它允许我们定义一个由位组成的段, 并可为它赋以一个名字。
> 
>  
> 
> [  
> ][Link 1]

--------------------

### 2.位段的用法 ###

> 我们已经了解什么是位段了, 现在我们继续讨论位段的使用方法。 
> 
> 先看一个例子: 我们需要用到五个变量。 假定, 其中三个用作标志, 称为 f1, f2 和 f3。 
> 第四个称为 type, 取值范围为 1 至 12。 最后一个变量称为 index, 值的范围为 0 至 500。 
> 
> 通常, 我们用下面的语句来说明这些变量: 
> char f1,f2,f3; 
> unsigned int type; 
> unsigned int index; 
> 
> 但是, 实际上标志 f1, f2, f3 分别只需要 1 位。变量 type 只需要 4 位, 而变量 index 只需要 9 位。 总共是 16位 ---- 2 个字节。我们用两个字节就够了。 
> 
> 我们可这样来做: 
> struct packed\_struct 
> \{ 
>     unsigned int f1 :1; 
>     unsigned int f2 :1; 
>     unsigned int f3 :1; 
>     unsigned int type :4; 
>     unsigned int index :9;
> 
> \}; 
> 
> 该例中, 我们定义了一个结构 packed\_struct。该结构定义了五个成员
> 
> ![weid2.jpg][]
> 
> 。第一个成员叫做 f1, 是 unsigned int 类型的。紧跟在该成员名之后的 :1 规定了它以 1 位存放。类似地, 标志 f2 和 f3 被定义为长度只有 1 位的。定义成员 type 占有 4 位。定义成员 index 占有 9 位。C 编译器自动地把上面的位段定义压缩在一起。位段的划分如图所示。packed\_struct 总共使用了 16 位。 
> 
> 这种方法的好处是, 定义成 packed\_struct 类型的变量的位段, 可以如引用一般的结构成员一样方便地引用。同时, 使用了更少的内存单元数。 
> 
> 我们已经定义了一个称作为 packed\_struct 的包含着位段的结构。现在, 我们象下面那样定义一个称作为 packet\_data 的变量: struct packed\_struct packed\_data; 于是, 我们就可以用简单的语句, 把 packed\_data 的 type 位段设置为 7: 
> packed\_data.type = 7; 类似地, 我们可以用下面的语句把这个位段的值设为 n: 
> packed\_data.type = n; 我们不必担心 n 的值太长, 以致不能放入 type 位段中, C 编译器会自动地仅取出 n 的低四位, 把它赋值给 packed\_data.type。取出位段的值也自动地处理的, 因此语句 n = packed\_data.type; 将从 packed\_data 中取出 type 位段, 并把它的值赋给 n。 
> 
> 在一般的表达式中可以使用位段, 此时, 位段自动地转换成整数。因此, 表达式 
> i = packed\_data.index/5+1; 是完全有效的。 
> 
> 在包含位段的结构中, 也可以包括 "通常的" 数据类型。因此, 如果我们想定义一个结构, 它包含一个 int, 一个 char, 和二个 1 位的标志, 那么, 下面的定义是有效的: 
> struct table\_entry 
> \{ 
>     int     count ; 
>     char     c; 
>     unsigned int f1 :1; 
>     unsigned int f2 :1; 
> \}; 
> 
> 当位段出现在结构定义中时, 它们就被压缩成字。如果某个位段无法放入一个字中, 那么该字的剩余部分跳过不用, 该位段被放入下一个字中。 
> 
> 使用位段时, 必须注意下列事项:
> 
> * 在某些机器上, 位段总是作为 unsigned 处理, 而不管它们是否被说明成 unsigned 的。
> * 大多数C 编译器都不支持超过一个字长的位段。
> * 位段不可标明维数; 即, 不能说明位段数组, 例如 flag:l\[2\]。
> * 最后, 不可以取位段地址。原因是, 在这种情况不, 显然没有称作为 "位段指针" 类型的变量。
> 
>                                                                                   ![weid3.jpg][]
> 
> 这里, 我们再深入讨论一下位段。如果使用下面的结构定义:
> 
> struct bits 
> \{ 
>     unsigned int f1:1; 
>     int     word; 
>     unsigned int f3:1; 
> \}; 
> 那么, 位段是怎样压缩的呢? 由于成员 word 出现于其间, 故 f1, f3 不会压缩在同一个字内。C 编译器不会重新安排位段定义来试图优化存储空间。 
> 
> 可以指定无名位段, 使得一个字中的某些位被 "跳过"。因此, 定义: 
> 
> 
> ![weid4.jpg][]
> 
> struct x\_entry 
> \{ 
>     unsigned int type :4; 
>     unsigned int :3; 
>     unsigned int count :9; 
> \}; 
> 将定义一个结构 x\_entry, 它包含两个位段变量 type 和 count, 而无名位段规定了 type 和 count 间隔三位。 
> 
> 来自：http://its.nbtvu.net.cn/xhyu/cai\_c/c\_web/c/c8/c83.htm 
> 
> 
>  
> 
> [http://www.cnblogs.com/jincwfly/archive/2007/09/14/892341.html][http_www.cnblogs.com_jincwfly_archive_2007_09_14_892341.html]
> 
>  
> 
> [关于结构体内存对齐][http_www.cnblogs.com_jincwfly_archive_2007_09_14_892341.html]
> 
>  
> 
> 内存对齐”应该是编译器的“管辖范围”。编译器为程序中的每个“数据单元”安排在适当的位置上。但是C语言的一个特点就是太灵活，太强大，它允许你干预“内存对齐”。如果你想了解更加底层的秘密，“内存对齐”对你就不应该再透明了。
> 
> 一、内存对齐的原因 
> 大部分的参考资料都是如是说的： 
> 1、平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。 
> 2、性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
> 
> 二、对齐规则 
> 每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令\#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。
> 
> 对齐步骤： 
> 1、数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照\#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。 
> 2、结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照\#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。 
> 3、结合1、2颗推断：当\#pragma pack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果。 
> 备注：数组成员按长度按数组类型长度计算，如char t\[9\],在第1步中数据自身长度按1算，累加结构体时长度为9;第2步中，找最大数据长度时，如果结构体T有复杂类型成员A的，该A成员的长度为该复杂类型成员A的最大成员长度。
> 
> 三、试验 
> 我们通过一系列例子的详细说明来证明这个规则吧! 
> 我试验用的编译器包括GCC 3.4.2和VC6.0的C编译器，平台为Windows XP + Sp2。
> 
> 我们将用典型的struct对齐来说明。首先我们定义一个struct： 
> \#pragma pack(n) /\* n = 1, 2, 4, 8, 16 \*/ 
> struct test\_t \{ 
>  int a; 
>  char b; 
>  short c; 
>  char d; 
> \}; 
> \#pragma pack(n) 
> 首先我们首先确认在试验平台上的各个类型的size，经验证两个编译器的输出均为： 
> sizeof(char) = 1 
> sizeof(short) = 2 
> sizeof(int) = 4
> 
> 我们的试验过程如下：通过\#pragma pack(n)改变“对齐系数”，然后察看sizeof(struct test\_t)的值。
> 
> 1、1字节对齐(\#pragma pack(1)) 
> 输出结果：sizeof(struct test\_t) = 8 \[两个编译器输出一致\] 
> 分析过程： 
> 1) 成员数据对齐 
> \#pragma pack(1) 
> struct test\_t \{ 
>  int a;  /\* 长度4 < 1 按1对齐；起始offset=0 0%1=0；存放位置区间\[0,3\] \*/ 
>  char b;  /\* 长度1 = 1 按1对齐；起始offset=4 4%1=0；存放位置区间\[4\] \*/ 
>  short c; /\* 长度2 > 1 按1对齐；起始offset=5 5%1=0；存放位置区间\[5,6\] \*/ 
>  char d;  /\* 长度1 = 1 按1对齐；起始offset=7 7%1=0；存放位置区间\[7\] \*/ 
> \}; 
> \#pragma pack() 
> 成员总大小=8
> 
> 2) 整体对齐 
> 整体对齐系数 = min((max(int,short,char), 1) = 1 
> 整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 8 /\* 8%1=0 \*/ \[注1\]
> 
> 2、2字节对齐(\#pragma pack(2)) 
> 输出结果：sizeof(struct test\_t) = 10 \[两个编译器输出一致\] 
> 分析过程： 
> 1) 成员数据对齐 
> \#pragma pack(2) 
> struct test\_t \{ 
>  int a;  /\* 长度4 > 2 按2对齐；起始offset=0 0%2=0；存放位置区间\[0,3\] \*/ 
>  char b;  /\* 长度1 < 2 按1对齐；起始offset=4 4%1=0；存放位置区间\[4\] \*/ 
>  short c; /\* 长度2 = 2 按2对齐；起始offset=6 6%2=0；存放位置区间\[6,7\] \*/ 
>  char d;  /\* 长度1 < 2 按1对齐；起始offset=8 8%1=0；存放位置区间\[8\] \*/ 
> \}; 
> \#pragma pack() 
> 成员总大小=9
> 
> 2) 整体对齐 
> 整体对齐系数 = min((max(int,short,char), 2) = 2 
> 整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 10 /\* 10%2=0 \*/
> 
> 3、4字节对齐(\#pragma pack(4)) 
> 输出结果：sizeof(struct test\_t) = 12 \[两个编译器输出一致\] 
> 分析过程： 
> 1) 成员数据对齐 
> \#pragma pack(4) 
> struct test\_t \{ 
>  int a;  /\* 长度4 = 4 按4对齐；起始offset=0 0%4=0；存放位置区间\[0,3\] \*/ 
>  char b;  /\* 长度1 < 4 按1对齐；起始offset=4 4%1=0；存放位置区间\[4\] \*/ 
>  short c; /\* 长度2 < 4 按2对齐；起始offset=6 6%2=0；存放位置区间\[6,7\] \*/ 
>  char d;  /\* 长度1 < 4 按1对齐；起始offset=8 8%1=0；存放位置区间\[8\] \*/ 
> \}; 
> \#pragma pack() 
> 成员总大小=9
> 
> 2) 整体对齐 
> 整体对齐系数 = min((max(int,short,char), 4) = 4 
> 整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 12 /\* 12%4=0 \*/
> 
> 4、8字节对齐(\#pragma pack(8)) 
> 输出结果：sizeof(struct test\_t) = 12 \[两个编译器输出一致\] 
> 分析过程： 
> 1) 成员数据对齐 
> \#pragma pack(8) 
> struct test\_t \{ 
>  int a;  /\* 长度4 < 8 按4对齐；起始offset=0 0%4=0；存放位置区间\[0,3\] \*/ 
>  char b;  /\* 长度1 < 8 按1对齐；起始offset=4 4%1=0；存放位置区间\[4\] \*/ 
>  short c; /\* 长度2 < 8 按2对齐；起始offset=6 6%2=0；存放位置区间\[6,7\] \*/ 
>  char d;  /\* 长度1 < 8 按1对齐；起始offset=8 8%1=0；存放位置区间\[8\] \*/ 
> \}; 
> \#pragma pack() 
> 成员总大小=9
> 
> 2) 整体对齐 
> 整体对齐系数 = min((max(int,short,char), 8) = 4 
> 整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 12 /\* 12%4=0 \*/
> 
> 
> 5、16字节对齐(\#pragma pack(16)) 
> 输出结果：sizeof(struct test\_t) = 12 \[两个编译器输出一致\] 
> 分析过程： 
> 1) 成员数据对齐 
> \#pragma pack(16) 
> struct test\_t \{ 
>  int a;  /\* 长度4 < 16 按4对齐；起始offset=0 0%4=0；存放位置区间\[0,3\] \*/ 
>  char b;  /\* 长度1 < 16 按1对齐；起始offset=4 4%1=0；存放位置区间\[4\] \*/ 
>  short c; /\* 长度2 < 16 按2对齐；起始offset=6 6%2=0；存放位置区间\[6,7\] \*/ 
>  char d;  /\* 长度1 < 16 按1对齐；起始offset=8 8%1=0；存放位置区间\[8\] \*/ 
> \}; 
> \#pragma pack() 
> 成员总大小=9
> 
> 2) 整体对齐 
> 整体对齐系数 = min((max(int,short,char), 16) = 4 
> 整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 12 /\* 12%4=0 \*/

[http_hi.baidu.com_colin719_blog_item_3f1783138e635f806538db40.html]: http://hi.baidu.com/colin719/blog/item/3f1783138e635f806538db40.html
[http_blog.csdn.net_junli0310_archive_2007_09_02_1769406.aspx]: http://blog.csdn.net/junli0310/archive/2007/09/02/1769406.aspx
[http_hi.baidu.com_B8_F8_EB_DE_CC_ED_CD_EB_B7_B9_blog_item_8ab4ae1f9d15fa0d304e15f4.html]: http://hi.baidu.com/%B8%F8%EB%DE%CC%ED%CD%EB%B7%B9/blog/item/8ab4ae1f9d15fa0d304e15f4.html
[weid1.jpg]: /images/20220722/949a2fe810404241b7bb64570e02afd1.png
[Link 1]: http://its.nbtvu.net.cn/xhyu/cai_c/c_web/c/c8/c83.htm#_top
[weid2.jpg]: /images/20220722/8dca79257f1e41acb2a48491f4531115.png
[weid3.jpg]: /images/20220722/14f68a79e33f48d8a751a72f8e7c62f9.png
[weid4.jpg]: /images/20220722/84e095fd5a3a4d11ab42ac288b994240.png
[http_www.cnblogs.com_jincwfly_archive_2007_09_14_892341.html]: http://www.cnblogs.com/jincwfly/archive/2007/09/14/892341.html