zoukankan      html  css  js  c++  java

  • 大端和小端--内存对齐问题

    什么是大端和小端

            Big-Endian和Little-Endian的定义如下：
    1) Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。
    2) Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。
    举一个例子，比如数字0x12 34 56 78在内存中的表示形式为：

    1)大端模式：

    低地址 -----------------> 高地址
    0x12  |  0x34  |  0x56  |  0x78

    2)小端模式：

    低地址 ------------------> 高地址
    0x78  |  0x56  |  0x34  |  0x12

    可见，大端模式和字符串的存储模式类似。

    3)下面是两个具体例子：

    16bit宽的数0x1234在Little-endian模式（以及Big-endian模式）CPU内存中的存放方式（假设从地址0x4000开始存放）为：
     
    内存地址 小端模式存放内容 大端模式存放内容
    0x4000 0x34 0x12
    0x4001 0x12 0x34

    32bit宽的数0x12345678在Little-endian模式以及Big-endian模式）CPU内存中的存放方式（假设从地址0x4000开始存放）为：

    内存地址 小端模式存放内容 大端模式存放内容
    0x4000 0x78 0x12
    0x4001 0x56 0x34
    0x4002 0x34 0x56
    0x4003 0x12 0x78
     

     4)大端小端没有谁优谁劣，各自优势便是对方劣势：

    小端模式 ：强制转换数据不需要调整字节内容，1、2、4字节的存储方式一样。
    大端模式 ：符号位的判定固定为第一个字节，容易判断正负。

     

    数组在大端小端情况下的存储：

    　　以unsigned int value = 0x12345678为例，分别看看在两种字节序下其存储情况，我们可以用unsigned char buf[4]来表示value：
    　　Big-Endian: 低地址存放高位，如下：
    高地址
            ---------------
            buf[3] (0x78) -- 低位
            buf[2] (0x56)
            buf[1] (0x34)
            buf[0] (0x12) -- 高位
            ---------------
            低地址
    Little-Endian: 低地址存放低位，如下：
    高地址
            ---------------
            buf[3] (0x12) -- 高位
            buf[2] (0x34)
            buf[1] (0x56)
            buf[0] (0x78) -- 低位
            --------------

    低地址

     

    为什么会有大小端模式之分呢？

          这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如果将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。我们常用的X86结构是小端模式，而KEIL C51则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

    如何判断机器的字节序

    可以编写一个小的测试程序来判断机器的字节序：

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. BOOL IsBigEndian()    
    2. {    
    3.     int a = 0x1234;    
    4.     char b =  *(char *)&a;  //通过将int强制类型转换成char单字节，通过判断起始存储位置。即等于 取b等于a的低地址部分    
    5.     if( b == 0x12)    
    6.     {    
    7.         return TRUE;    
    8.     }    
    9.     return FALSE;    
    10. }  

    联合体union的存放顺序是所有成员都从低地址开始存放，利用该特性可以轻松地获得了CPU对内存采用Little-endian还是Big-endian模式读写

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. BOOL IsBigEndian()    
    2. {    
    3.     union NUM    
    4.     {    
    5.         int a;    
    6.         char b;    
    7.     }num;    
    8.     num.a = 0x1234;    
    9.     if( num.b == 0x12 )    
    10.     {    
    11.         return TRUE;    
    12.     }    
    13.     return FALSE;    
    14. }  

    内存对齐问题

    怎么判断内存对齐规则,sizeof的结果怎么来的,请牢记以下3条原则:(在没有#pragma pack宏的情况下，务必看完最后一行)

    １:数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如说是数组，结构体等）的整数倍开始(比如int在３２位机为４字节,则要从４的整数倍地址开始存储。

    ２:结构体作为成员:如果一个结构里有某些结构体成员,则结构体成员要从其内部最大元素大小的整数倍地址开始存储.(struct a里存有struct b,b里有char,int ,double等元素,那b应该从8的整数倍开始存储.)

    ３:收尾工作:结构体的总大小,也就是sizeof的结果,.必须是其内部最大成员的整数倍.不足的要补齐.

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. typedef struct bb  
    2. {  
    3.  int id;             //[0]....[3]  
    4.  double weight;      //[8].....[15]　　　　　　原则１  
    5.  float height;      //[16]..[19],总长要为８的整数倍,补齐[20]...[23]　　　　　原则３  
    6. }BB;  
    7.   
    8. typedef struct aa  
    9. {  
    10.  char name[2];     //[0],[1]  
    11.  int  id;         //[4]...[7]　　　　　　　　　　原则１   
    12.  double score;     //[8]....[15]　　　　  
    13.  short grade;    //[16],[17]　　　　　　　　  
    14.  BB b;             //[24]......[47]　　　　　　　原则２  
    15. }AA;  
    16.   
    17. int main()  
    18. {  
    19.   AA a;  
    20.   cout<<sizeof(a)<<" "<<sizeof(BB)<<endl;  
    21.   return 0;  
    22. }   

    结果是

    48 24
    ok,上面的全看明白了,内存对齐基本过关.

    再讲讲#pragma pack().

    在代码前加一句#pragma pack(1),你会很高兴的发现,上面的代码输出为

    32 16
    bb是4+8+4=16,aa是2+4+8+2+16=32;

    这不是理想中的没有内存对齐的世界吗.没错,#pragmapack(1),告诉编译器,所有的对齐都按照1的整数倍对齐,换句话说就是没有对齐规则.

    明白了不?

    那#pragma pack(2)的结果又是多少呢?对不起,５分钟到了,自己去测试吧. 

    ps:Vc,Vs等编译器默认是#pragma pack(8)，所以测试我们的规则会正常；注意gcc默认是#pragma pack(4)，并且gcc只支持1,2,4对齐。套用三原则里计算的对齐值是不能大于#pragma pack指定的n值。

    内存对齐二

    VC对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。VC 中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况：

    第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式；

    第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。

    结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；否则必须为n的倍数。下面举例说明其用法：

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #pragma pack(push) //保存对齐状态   
    2. #pragma pack(4)//设定为4字节对齐   
    3. struct test   
    4. {   
    5. char m1;   
    6. double m4;   
    7. int m3;   
    8. };   
    9. #pragma pack(pop)//恢复对齐状态   

    以上结构的大小为16，下面分析其存储情况，首先为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1占用1个字节。接着开始为 m4分配空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。接着为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。这时已经为所有成员变量分配了空间，共分配了4+8+4=16个字节，满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以得到结构的大小为24。

    再看下面这个例子：

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #pragma pack(8)  
    2. struct S1{  
    3.  char a;  
    4.  long b;  
    5. };   
    6.   
    7. struct S2 {  
    8.  char c;  
    9.  struct S1 d;  
    10.  long long e;  
    11. };  
    12. #pragma pack()  

    成员对齐有一个重要的条件,即每个成员分别对齐.即每个成员按自己的方式对齐.

    也就是说上面虽然指定了按8字节对齐,但并不是所有的成员都是以8字节对齐.其对齐的规则是,每个成员按其类型的对齐参数(通常是这个类型的大小)和指定对齐参数(这里是8字节)中较小的一个对齐.并且结构的长度必须为所用过的所有对齐参数的整数倍,不够就补空字节.

    S1中,成员a是1字节默认按1字节对齐,指定对齐参数为8,这两个值中取1,a按1字节对齐;成员b是4个字节,默认是按4字节对齐,这时就按4字节对齐,所以sizeof(S1)应该为8;

    S2 中,c和S1中的a一样,按1字节对齐,而d 是个结构,它是8个字节,它按什么对齐呢?对于结构来说,它的默认对齐方式就是它的所有成员使用的对齐参数中最大的一个,S1的就是4.所以,成员d就是 按4字节对齐.成员e是8个字节,它是默认按8字节对齐,和指定的一样,所以它对到8字节的边界上,这时,已经使用了12个字节了,所以又添加了4个字节的空,从第16个字节开始放置成员e.这时,长度为24,已经可以被8(成员e按8字节对齐)整除.这样,sizeof(S2)为24个字节.

    这里有三点很重要:

    1.每个成员分别按自己的方式对齐,并能最小化长度。

    2.复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度。

    3.对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐。
  • 相关阅读:
    Google 面试准备清单
    Two sorted array. Find kth smallest element, 要求O(logK)
    MVC（demo）
    UE4学习心得：Scene Component蓝图的一个简单应用
    UE4中如何使物体始终朝向摄像头？
    响应式Web设计
    Nodejs的express使用教程
    安装express遇到的问题
    致自己
    上传文件的方法
  • 原文地址：https://www.cnblogs.com/ranjiewen/p/5363353.html
Copyright © 2011-2022 走看看