C/C++ 结构体字节对齐详解

偏执的太偏执、 2022-08-27 00:28 206阅读 0赞

http://blog.csdn.net/yusiguyuan/article/details/23103169

发现在当前很多对结构体字节对齐的分析都有错误，这里从实际测试到理论分析，使用的平台是linux 32位。

### 一.什么是字节对齐,为什么要对齐? ###

现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特 定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。

对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。显然在读取效率上下降很多。（可见程序员面试宝典第三版 P49）

### 二.字节对齐对程序的影响: ###

先让我们看几个例子吧(32bit,x86环境,gcc编译器):  
设结构体如下定义：

[cpp] view plaincopy 
      
       struct A   {     int a;     char b;     short c;   };      struct B   {     char b;     int a;     short c;   };

现在已知32位机器上各种数据类型的长度如下:  
char:1(有符号无符号同)  
short:2(有符号无符号同)  
int:4(有符号无符号同)  
long:4(有符号无符号同)  
float:4 double:8  
那么上面两个结构大小如何呢?  
结果是:  
sizeof(strcut A)值为8  
sizeof(struct B)的值却是12

结构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一个,B也一样;按理说A,B大小应该都是7字节。  
之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么我们是不是可以改变编译器的这种默认对齐设置呢,当然可以.例如:

[cpp] view plaincopy 
      
       #pragma pack (2) /*指定按2字节对齐*/   struct C   {     char b;     int a;     short c;   };   #pragma pack ()   /*取消指定对齐，恢复缺省对齐*/

sizeof(struct C)值是8。  
修改对齐值为1：

#pragma pack (1) /*指定按1字节对齐*/
    struct D
    {
      char b;
      int a;
      short c;
    };
    #pragma pack () /*取消指定对齐，恢复缺省对齐*/

sizeof(struct D)值为7。  
后面我们再讲解\#pragma pack()的作用.

### 三.编译器是按照什么样的原则进行对齐的? ###

先让我们看四个重要的基本概念：  
**1.数据类型自身的对齐值：  
对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，单位字节。  
2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。  
3.指定对齐值：\#pragma pack (value)时的指定对齐值value。  
4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值。**  
有了这些值，我们就可以很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值，最重要。有效对齐N，就是表示“对齐在N上”，也就是说该数据的"存放起始地址%N=0".而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放，结构体本身也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度需要是对结构体有效对齐值的整数倍，结合下面例子理解)。这样就不能理解上面的几个例子的值了。  
例子分析：  
分析例子B:

[cpp] view plaincopy 
      
       struct B   {     char b;     int a;     short c;   };

假设B从地址空间0×0000开始排放。该例子中没有定义指定对齐值，在笔者环境下，该值默认为4。第一个成员变量b的自身对齐值是1，比指定或者默认指定对齐值4小，所以其有效对齐值为1，所以其存放地址0×0000符合0×0000%1=0.第二个成员变量a，其自身对齐值为4，所以有效对齐值也为4，所以只能存放在起始地址为0×0004到0×0007这四个连续的字节空间中，复核0×0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐值为 2，所以有效对齐值也是2，可以存放在0×0008到0×0009这两个字节空间中，符合0×0008%2=0。所以从0×0000到0×0009存放的都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b）所以就是4，所以结构体的有效对齐值也是4。根据结构体圆整的要求， 0×0009到0×0000=10字节，（10＋2）％4＝0。所以0x0000A到0x000B也为结构体B所占用。故B从0×0000到0x000B 共有12个字节,sizeof(struct B)=12;其实如果就这一个就来说它已将满足字节对齐了, 因为它的起始地址是0,因此肯定是对齐的,之所以在后面补充2个字节,是因为编译器为了实现结构数组的存取效率,试想如果我们定义了一个结构B的数组,那么第一个结构起始地址是0没有问题,但是第二个结构呢?按照数组的定义,数组中所有元素都是紧挨着的,如果我们不把结构的大小补充为4的整数倍,那么下一个结构的起始地址将是0x0000A,这显然不能满足结构的地址对齐了（不能整除数据结构B的自身对齐值）,因此我们要把结构补充成有效对齐大小的整数倍.其实诸如:对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，这些已有类型的自身对齐值也是基于数组考虑的,只是因为这些类型的长度已知了,所以他们的自身对齐值也就已知了.  
同理,分析上面例子C：

#pragma pack (2) /*指定按2字节对齐*/
    struct C
    {
      char b;
      int a;
      short c;
    };
    #pragma pack () /*取消指定对齐，恢复缺省对齐*/

第一个变量b的自身对齐值为1，指定对齐值为2，所以，其有效对齐值为1，假设C从0×0000开始，那么b存放在0×0000，符合0×0000%1= 0;第二个变量，自身对齐值为4，指定对齐值为2，所以有效对齐值为2，所以顺序存放在0×0002、0×0003、0×0004、0×0005四个连续字节中，符合0×0002%2=0。第三个变量c的自身对齐值为2，所以有效对齐值为2，顺序存放  
在0×0006、0×0007中，符合 0×0006%2=0。所以从0×0000到0×00007共八字节存放的是C的变量。又C的自身对齐值为4，所以C的有效对齐值为2。又8%2=0,C 只占用0×0000到0×0007的八个字节。所以sizeof(struct C)=8.

下面列举一个例子（默认采用4字节对齐）

**\[cpp\]** [ view plain][view plain][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  struct S0\{  \};   
2.    
3.  struct S1\{   
4.    
5.      char a;   
6.    
7.      long b;   
8.    
9.  \};   
10.   
11. struct S2\{   
12.   
13.     long b;   
14.   
15.     char a;   
16.   
17. \};   
18.   
19. struct S3 \{   
20.   
21.     char c;   
22.   
23.     struct S1 d;//结构体   
24.   
25.     long e;   
26.   
27. \};   
28.   
29. struct S4\{   
30.   
31.     char a;   
32.   
33.     long b;   
34.   
35.     static long c; //静态   
36.   
37. \};   
38.   
39. struct S5\{   
40.   
41.     char a;   
42.   
43.     long b;   
44.   
45.     char name\[5\]; //数组   
46.   
47. \};   
48.   
49. //含有一个数组   
50.   
51. struct S6\{   
52.   
53.     char a;   
54.   
55.     long b;   
56.   
57.     int name\[5\]; //数组   
58.   
59. \};   
60.   
61. struct student0   
62.   
63. \{   
64.   
65.     char name\[5\];   
66.   
67.     int num;   
68.   
69.     short score;   
70.   
71. \};   
72.   
73. struct student1   
74.   
75. \{   
76.   
77.     int num;   
78.   
79.     char name\[5\];   
80.   
81.     short score;   
82.   
83. \};   
84.   
85. struct student2   
86.   
87. \{   
88.   
89.     int num;   
90.   
91.     short score;   
92.   
93.     char name\[5\];   
94.   
95. \};   
96.   
97. union union1   
98.   
99. \{   
100.   
101.     long a;   
102.   
103.     double b;   
104.   
105.     char name\[9\];   
106.   
107. \};   
108.   
109. union   union2\{      
110.   
111.     char a;   
112.   
113.     int b\[5\];    
114.   
115.     double  c;   
116.   
117.     int d\[3\];    
118.   
119. \};      
120.   
121. int main(int argc, char\* argv\[\])   
122.   
123. \{   
124.   
125.     cout << "char: " << sizeof(char) << endl; //1   
126.   
127.     cout << "long: " << sizeof(long) << endl; //4   
128.   
129.     cout << "int:  " << sizeof(int) << endl; //4   
130.   
131.     cout << "S0: " << sizeof(S0) << endl; //1   
132.   
133.     cout << "S1: " << sizeof(S1) << endl; //8   
134.   
135.     cout << "S2: " << sizeof(S2) << endl; //8   
136.   
137.     cout << "S3: " << sizeof(S3) << endl; //16
138.   
139.     cout << "S4: " << sizeof(S4) << endl; //8   
140.   
141.     cout << "S5: " << sizeof(S5) << endl; //16   
142.   
143.     cout << "S6: " << sizeof(S6) << endl; //28   
144.   
145.     cout << "union1 :" << sizeof(union1) << endl;   
146.   
147.     cout << "union2 :" << sizeof(union2) << endl;   
148.   
149.     cout << "student0: " << sizeof(student0) << endl;   
150.   
151.     cout << "student1: " << sizeof(student1) << endl;   
152.   
153.     cout << "student2: " << sizeof(student2) << endl;   
154.   
155.     system("pause");   
156.   
157.     return 0;   
158.   
159. \}

输出值为：

**\[cpp\]** [ view plain][view plain][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  char: 1  
2.  long: 4  
3.  int:  4  
4.  S0: 1  
5.  S1: 8  
6.  S2: 8  
7.  S3: 16  
8.  S4: 8  
9.  S5: 16  
10. S6: 28  
11. union1 :12  //联合 ：按其包含的长度最大的数据类型对齐。以里面size最大的为union的size
12. union2 :20  
13. student0: 16  
14. student1: 12  //多出的1个char补一个字节，然后和short正好构成4字节
15. student2: 12  //short和2个char成4字节，剩下的3个char补一个字节成4字节

上面的输出结果可以按照上述原则严格分析。

结构体内部存在static类型的变量

**\[cpp\]** [ view plain][view plain][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  struct S4\{   
2.    
3.      char a;   
4.    
5.      long b;   
6.    
7.      static long c; //静态   
8.    
9.  \};

静态变量存放在全局数据区内，而sizeof计算栈中分配的空间的大小，故不计算在内，S4的大小为4+4=8。

（PS：在自然对齐的结构体中，在32位系统内，对于某一个成员变量，如果前面的变量所占空间比自身小，那么前面的空间填充为满4字节，使得这个成员的地址从4字节整数倍开始，最后结构体的总体字节调整为4字节的整数倍即可，比如以下例子：）

**\[cpp\]** [ view plain][view plain][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  struct test  
2.  \{  
3.       char a;  
4.      short  b;  
5.       int c;  
6.      double d;  
7.       char e;  
8.      // char f;  
9.   //    char g  
10. \}

sizeof（struct test）= 20. 如果将最后两行注释去掉 仍然是20字节 规则是这样的，嘉盛从0x00000000地址开始存储成员，那么a偏移为1，但是b必须从2的地址开始，那么a就必须填充一个字节，那么a b 共占用4个字节，c需要从4字节的整数倍开始，现在正好，上述不用填充，d也从可以被4整除的字节数开始存储（现在正好，其实也是8字节的整数倍，这是凑巧了），连续填充8个字节，现在便宜0x0000010，那么e的大小为0x00000011，但是整个结构体的大小不是4字节的整数倍，最后需要填充3个字节，整体是0x00000014,如果将最后两行注释去掉，那么仍然是20字节，需要填充的就是g填充1个字节。

[view plain]: http://blog.csdn.net/yusiguyuan/article/details/23103169#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/278850
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/278850/fork