struct与union字节对齐问题

C 语言的一大优势就是对内存空间的控制，当然，在面向对象语言的压力下，程序员更喜欢轻松的语言，不喜欢自己还要顾虑内存空间。

        可是，C 语言仍然有很强的生命力，尤其是在操作系统、嵌入式系统这两方面，因为要直接操作硬件，C语言就显现出自己强大的体制、机制、逻辑优势。

        C语言对内存控制，有一个始终困扰初学者的问题：字节对齐！

看一段程序：

 

[cpp]  view plain copy

1. struct stExample  
2. {  
3.     char    a;  
4.     char    b  
5.     short   c;  
6.     int     d;  
7. }; //  
8. sizeof( char ) == 1  
9. sizeof( short ) == 2  
10. sizeof( int ) == 4  
11. /  
12. sizeof( struct stExample ) == 8  

stExample结构体的大小是8 Byte. 看起来符合预期。

可是下面这个例子：

 

[cpp]  view plain copy

1. struct stExample  
2. {  
3.     char    a;  
4.     int     b;  
5.     short   c;  
6. }; //  
7. sizeof( char ) == 1  
8. sizeof( short ) == 2  
9. sizeof( int ) == 4  
10. /  
11. sizeof( struct stExample ) == 12  //?  

stExample结构体的大小就变成了12 Byte. 为什么元素少了，反而占用空间会多出来4 Byte？

/

       先让我们看四个重要的基本概念：
1.数据类型自身的对齐值：
    ： 对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，单位字节。
2.结构体或者类的自身对齐值：

    ：其成员中自身对齐值最大的那个值。
3.指定对齐值：

    ：#pragma pack (value)时的指定对齐值value。
4.数据成员、结构体和类的有效对齐值：

    ：自身对齐值和指定对齐值中小的那个值。

/
        有效对齐值N是最终用来决定数据存放地址方式的值，最重要。有效对齐N，就是 表示“对齐在N上”，也就是说该数据的"存放起始地址%N=0".

       而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放。
    例子分析：

[cpp]  view plain copy

1. struct stExample  
2. {  
3.     char    a;  
4.     int     b;  
5.     short   c;  
6. }; //  
7. sizeof( char ) == 1  
8. sizeof( short ) == 2  
9. sizeof( int ) == 4  
10. /  
11. sizeof( struct stExample ) == 12  //?  

假设stExample从地址空间0x0000开始排放。该例子中没有定义指定对齐值，在笔者环境下，该值默认为4。三个成员的存储位置如图：

1. 第一个成员变量a的自身对齐值是1，比指定或者默认指定 对齐值4小，所以其有效对齐值为1，所以其存放地址0x0000符合0x0000%1=0.

2. 第二个成员变量b，其自身对齐值为4，所以有效对齐值也为4， 所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中，复核0x0004%4=0,且紧靠第一个变量。

3. 第三个变量c,自身对齐值为 2，所以有效对齐值也是2，可以存放在0x0008到0x0009这两个字节空间中，符合0x0008%2=0。

        所以从0x0000到0x0009存放的 都是stExample内容。再看数据结构stExample的自身对齐值为其变量中最大对齐值(这里是b）所以就是4，所以结构体的有效对齐值也是4。根据结构体圆整的要求， 0x0009到0x0000=10字节，（10＋2）％4＝0。所以0x0000A到0x000B也为结构体stExample所占用。故stExample从0x0000到0x000B 共有12个字节,sizeof( struct stExample )=12.

        其实如果就这一个就来说它已将满足字节对齐了, 因为它的起始地址是0,因此肯定是对齐的,之所以在后面补充2个字节,是因为编译器为了实现结构数组的存取效率。

        试想如果我们定义了一个结构体stExample的数组,那么第一个结构起始地址是0没有问题,但是第二个结构呢?按照数组的定义,数组中所有元素都是紧挨着的,如果我们不把结构的大小补充为4的整数倍,那么下一个结构的起始地址将是0x0000A,这显然不能满足结构的地址对齐了,因此我们要把结构补充成有效对齐大小的整数倍.

        其实诸如:对于char型数据，其自身对齐值为1，short类型为2，int,float,double类型，其自身对齐值为4，这些已有类型的自身对齐值也是基于数组考虑的,只是因为这些类型的长度已知了,所以他们的自身对齐值也就已知了.
分析下面例子：

[cpp]  view plain copy

1. #pragma pack (2) /*指定按2字节对齐*/  
2. struct stExample  
3. {  
4.     char   a;  
5.     int    b;  
6.     short  c;  
7. };  
8. #pragma pack () /*取消指定对齐，恢复缺省对齐*/  
9. ///  
10. sizeof( struct stExample ) == 8   

1. 第 一个变量a的自身对齐值为1，指定对齐值为2，所以，其有效对齐值为1，假设stExample 从0x0000开始，那么a存放在0x0000，符合0x0000%1= 0;

2. 第二个变量b，自身对齐值为4，指定对齐值为2，所以有效对齐值为2，所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续 字节中，符合0x0002%2=0。

3. 第三个变量c的自身对齐值为2，所以有效对齐值为2，顺序存放在0x0006、0x0007中，符合 0x0006%2=0。

所以从0x0000到0x00007共八字节存放的是stExample 的变量。又因为stExample 的自身对齐值为4，所以stExample 的有效对齐值为2。又8%2=0, stExample  只占用0x0000到0x0007的八个字节。所以sizeof( struct stExample ) == 8.

 

//

struct 结构体的嵌套结构也是类似的对齐方式。

看下面的例子：

[c-sharp]  view plain copy

1. struct stExample  
2. {  
3.     char    a;  
4.     struct  b  
5.     {  
6.         char    aa;  
7.         short   bb;  
8.         int     cc;  
9.     }  
10.     short   c;  
11. };  
12. //  
13. sizeof( struct stExample ) == 16   

内存中的字节对齐如下图所示：

 

struct b 结构体的自身对齐值是4（由成员cc决定的），所以存储地址必须是4的整数倍。

struct stExample 结构体的自身对齐值也是4（由成员struct b决定），所以最后两个字节用来补齐（即0x000E 和 0x0010）。

union 共用体的字节对齐情况类似，共用体的自身对齐值决定于成员的最大自身对齐值。

      字节对齐，在一般情况下，在编写上层应用程序时一般是不用顾虑的。

      但是有两种情况要特别小心，一是涉及到硬件memory操作，一是涉及到网络报文传输。

      对网络报文定义结构体时，字节不对齐的话就会造成大错。有两种方法解决：

1. 可以使用pack(1)声明为1字节对齐。但是操作效率会下降，而且有些嵌入式系统的编译器支持不够好。

2. 可以将网络报文结构体内的成员变量，定义时最大使用short型，可以使用char型，但要保持偶数字节对齐。（一般标准的网络报文结构就是偶数字节对齐的）。遇到需要int型的变量,可以定义一个小共用体typedef union{ char cMem[]4;   short  sMem[2] } UNION_INT ; 用它来代替int在报文结构体中使用，只是程序中注意点就行了。

转自http://blog.csdn.net/keyearth/article/details/6129882。