C语言内存中结构体对齐分析

一、字节对齐作用和原因:

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

二、字节对齐规则:

32位系统中,结构体内成员地址分配时,编译器默认考虑4字节对齐; 
64位系统中, 编译器默认考虑8字节对齐。 

四个重要的概念:
  1.数据类型自身的对齐值:对于char型的数据,其自身对齐值为1,对于short型为2,对于int,float,double long long类型,其自身对齐值为4个字节。
  2.结构体或者类的自身对齐值:其成员中自身对齐值最大的那个值。
  3.指定对齐值:#pragma pack (value)时指定的对齐value。
  4.数据成员、结构体和类的有效对齐值:自身对齐值和指定对齐值中小的那个值。

补充:

1).每个成员分别按自己的方式对齐,并能最小化长度。
 2).复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度。
 3).对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐。

  1. #pragma pack(1)  
  2. struct test  
  3. {  
  4. static int a; //static var  
  5. double m4;  
  6. char m1;  
  7. int m3;  
  8. }  
  9. #pragma pack()  
  10. //sizeof(test)=13;  
  11.   
  12. Class test1{ };  
  13. //sizeof(test1)=1;  
  14.   
  15. /* 注明:  
  16. 1、结构或者类中的静态成员不对结构或者类的大小产生影响,因为静态变量的存储位置与结构或者类的实例地址无关;  
  17. 2、没有成员变量的结构或类的大小为1,因为必须保证结构或类的每一个实例在内存中都有唯一的地址。*/  
[c-sharp] view plaincopy
  1. #pragma pack(1)  
  2. struct test  
  3. {  
  4. static int a; //static var  
  5. double m4;  
  6. char m1;  
  7. int m3;  
  8. }  
  9. #pragma pack()  
  10. //sizeof(test)=13;  
  11.   
  12. Class test1{ };  
  13. //sizeof(test1)=1;  
  14.   
  15. /* 注明: 
  16. 1、结构或者类中的静态成员不对结构或者类的大小产生影响,因为静态变量的存储位置与结构或者类的实例地址无关; 
  17. 2、没有成员变量的结构或类的大小为1,因为必须保证结构或类的每一个实例在内存中都有唯一的地址。*/  

 示例:

  1. //分析下面的例子C:  
  2. //  
  3. #pragma pack (2)     /*指定按2字节对齐*/  
  4. struct C  
  5. {  
  6.   char b;  
  7.   int a;  
  8.   short c;  
  9. };  
  10. #pragma pack () //恢复对齐状态  
  11. /*  
  12. 第一个变量b的自身对齐值为1,指定对齐值为2,所以,其有效对齐值为1,假设C从0x0000开始,那么b存放在0x0000,符合0x0000%1 = 0;  
  13. 第二个变量,自身对齐值为4,指定对齐值为2,所以有效对齐值为2,所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续的字节空间中,符合0x0002%2=0。  
  14. 第三个变量c的自身对齐值为2,所以有效对齐值为2,顺序在0x0006、0x0007中,符合0x0006%2=0。  
  15. 所以从0x0000到0x0007共八字节存放的是struct C的变量。又struct C的自身对齐值为4,所以struct C的有效对齐值为2。  
  16. 又8%2=0,struct C只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8。  
  17. 如果把上面的#pragma pack(2)改为#pragma pack(4),那么我们可以得到结构的大小为12。  
  18. */  


  1. //再看下面这个例子  
  2. //  
  3. #pragma pack(8)  
  4. struct S1  
  5. {  
  6.   char a;  
  7.   long b;  
  8. };  
  9. struct S2 {  
  10.   char c;  
  11.   struct S1 d;  
  12.   long long e;  
  13. };  
  14. #pragma pack()  
  15.   
  16. sizeof(S2)结果为24.  
  17. /*  
  18. S1中:  
  19. 成员a是1字节默认按1字节对齐,指定对齐参数为8,这两个值中取1,a按1字节对齐;  
  20. 成员b是4个字节,默认是按4字节对齐,这时就按4字节对齐,所以sizeof(S1)应该为8;  
  21.   
  22. S2 中:  
  23. c和S1中的a一样,按1字节对齐,  
  24. d 是个结构,它是8个字节,它按什么对齐呢?对于结构来说,它的默认对齐方式就是它的所有成员使用的对齐参数中最大的一个,S1的就是4.所以,成员d就是按4字节对齐.  
  25. 成员e是8个字节,它是默认按8字节对齐,和指定的一样,所以它对到8字节的边界上,这时,已经使用了12个字节了,所以又添加了4个字节的空,从第16个字节开始放置成员e;  
  26. 长度为24,已经可以被8(成员e按8字节对齐)整除.一共使用了24个字节.  
  27. a b  
  28. S1的内存布局:11**,1111,  
  29. c S1.a S1.b d  
  30. S2的内存布局:1***,11**,1111,****11111111  
  31. */  

  1. //再看下面这个例子  
  2. //  
  3. #pragma pack(8)  
  4. struct S1  
  5. {  
  6.   char a;  
  7.   long b;  
  8. };  
  9. struct S2 {  
  10.   char c;  
  11.   struct S1 d;  
  12.   long long e;  
  13. };  
  14. #pragma pack()  
  15.   
  16. sizeof(S2)结果为20.  
  17. /* 
  18. S1中: 
  19. 成员a是1字节默认按1字节对齐,指定对齐参数为8,这两个值中取1,a按1字节对齐; 
  20. 成员b是4个字节,默认是按4字节对齐,这时就按4字节对齐,所以sizeof(S1)应该为8; 
  21.  
  22. S2 中: 
  23. c和S1中的a一样,按1字节对齐, 
  24. d 是个结构,它是8个字节,它按什么对齐呢?对于结构来说,它的默认对齐方式就是它的所有成员使用的对齐参数中最大的一个,S1的就是4.所以,成员d就是按4字节对齐. 
  25. 成员e是8个字节,它是默认按4字节对齐,比指定的小,所以它对到4字节的边界上,这时,已经使用了12个字节了,所以从第12个字节开始放置成员e; 
  26. 长度为20,对于结构体的有效对齐值,在结构体成员最大的有效对齐值和指定的对齐值中取较小者,也就是4字节对齐。现在已经可以被4(成员e按4字节对齐)整除.一共使用了20个字节. 
  27. a b 
  28. S1的内存布局:11**,1111, 
  29. c S1.a S1.b d 
  30. S2的内存布局:1***,11**,1111,11111111 
  31. 还有一种分析是上面那种情况,分析不同的原因在于不知道long long 默认是多少字节对齐,我在linux 32位系统测试过以后,最终sizeof(S2)结果为20.  说明long long默认
  32. 对齐是4字节  上面的一种解释是错误的
  33. */  
   

三、针对字节对齐,我们在编程中如何考虑?
  如果在编程的时候要考虑节约空间的话,那么我们只需要假定结构的首地址是0, 然后各个变量按照上面的原则进行排列即可,基本的原则就是把结构中的变量按照类型大小从小到大声明,尽量减少中间的填补空间。还有一种就是为了以空间换取时间的效率,我们显示的进行填补空间进行对齐,比如:有一种使用空间换时间做法是显式的插入reserved成员:
struct A
{
  char a;
  char reserved[3];    //使用空间换时间
  int b;
};
reserved成员对我们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,当然即使不加这个成员通常编译器也会给我们自动填补对齐,我们自己加上它只是起到显示的提醒作用。

 四、字节对齐可能带来的隐患
  代码中关于对齐的隐患,很多是隐式的。比如在强制类型转换的时候。例如:
  unsigned int i = 0x12345678;
  unsigned char *p = NULL;
  unsigned short *p1 = NULL;
  p=&i;
  *p=0x00;
  p1=(unsigned short*)(p+1);
  *p1=0x0000;
  最后两行代码,从奇数边界去访问unsigned short型变量,显然不符合对齐的规定。在X86上,类似的操作只会影响效率,但是在MIPS或者sparc上,可能就是一个error,因为它们要求字节必须对齐。

 五、如何查找与字节对齐方面的问题
  如果出现对齐或者赋值问题首先查看
  1.编译器设置的对齐值
  2.看这种体系本身是否支持非对齐访问
  3.如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作。

C语言内存中结构体对齐分析,布布扣,bubuko.com

C语言内存中结构体对齐分析

上一篇:JAVA循环迭代中删除或添加集合数据报java.util.ConcurrentModificationException错误


下一篇:python微信交流群,零基础、入门、大牛都可加入!