精华内容
下载资源
问答
  • C语言结构体字节对齐规则
    万次阅读 多人点赞
    2019-04-12 10:55:40

    C语言结构体字节对齐规则

    基本规则

    规则1 :结构体(struct)的数据成员,第一个数据成员放在offset为0的地方,以后每个数据成员存放在offset为该数据成员大小的整数倍的地方(比如int在32位机为4字节,则要从4的整数倍地址开始存储)。

    规则2:如果一个结构体B里嵌套另一个结构体A,则结构体A应从offset为A内部最大成员的整数倍的地方开始存储。(struct B里存有struct A,A里有char,int,double等成员,那A应该从8的整数倍开始存储。),结构体A中的成员的对齐规则仍满足原则1、原则2。

    Tips:

    • 结构体A所占的大小为该结构体成员内部最大元素的整数倍,不足补齐。
    • 不是直接将结构体A的成员直接移动到结构体B中

    规则3:结构体的总大小,也就是sizeof的结果,必须是其内部最大成员的整数倍,不足的要补齐。

    案例解析

    例1

    typedef struct A{
        int a;
        short b;
    }A;
    /** 
      * 内存对齐规则:
      * 按最长的类型的长度为最长长度
      * 4*0 = 0 所以从 0 位置开始放
      * 2*0 = 0 0位置已经有内容
      * 2*1 = 2 2位置已经有内容
      * 2*2 = 4 4位置空,可以存放
      * short长度 为2 而基准长度为4,因此 需要将剩余的两字节补空
      * 故 A大小为8字节
      * a a a a
      * b b - - 
      */ 
     printf("%d\n",sizeof(A));//8
    

    例2

    typedef struct B{
       double a;
       short b;
       int c;
    }B;
    /** 
      * 最长基准长度为8
      * 8*0 = 0 放于0位置起的8个字节
      * 2*0 = 0 此处有内容
      * ...
      * 2*4 = 8 此处空闲可以存放 8-10用于存放 short
      * 4*0 = 0 此处已经有内容
      * ...
      * 4*3 = 12 此处可以存放 12-15
      * a a a a a a a a
      * b b - - c c c c
      * 所以B共占用 16字节
      */
     printf("%d\n",sizeof(B)); 
    

    例3

    typedef struct C{
      short a;
      double b;
      int c;
    }C;
    /** 
     * 最长基准长度为:8
     * 2*0 = 0 0-1位置用于存放a
     * 8*0 = 0 此处已有内容
     * 8*1 = 8 8-16位置用于存放b
     * 4*0 = 0 此处已有内容
     * 4*3 = 12 12-16存放c
     * a a - - - - - -
     * b b b b b b b b
     * c c c c - - - -
     */
    printf("%d\n",sizeof(C)); //24
    

    例4

    typedef struct D{
      int a;
      double b;
    }D;
    typedef struct E{
      short a;
      int b;
      D c;
    }E;
    /** 
       * 当结构体内部嵌套结构体时,以两个结构体内部最长的类型为基准长度
       * 此处结构体D与E最长的长度为D中的double,因此基准长度为:8
       * 2 * 0 = 0 0-1位置存放E.a
       * 4 * 0 = 0 
       * 4 * 1 = 4 4-7位置存放E.b
       * 8 + 4 * 0 = 8 8-11位置存放D.a
       * 8 + 8 * 0 = 8
       * 8 + 8 * 1 = 16 16-23位置存放D.b
       */
      printf("%d\n",sizeof(E)); //24
    
    更多相关内容
  • struct 字节对齐详解

    万次阅读 多人点赞 2017-02-16 17:49:50
    但实际情况是在访问特定类型变量的时候经常在特 定的内存地址访问,这就需要各种类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就是对齐。  对齐的作用和原因:各个硬件平台对存储空间的...

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

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

    先让我们看几个例子吧(32bit,x86环境,gcc编译器):
    设结构体如下定义:
    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字节。
    之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么我们是不是可以改变编译器的这种默认对齐设置呢,当然可以.例如:
    #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;
    struct B
    {
        char b;
        int a;
        short c;
    };
    假 设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值,在笔者环境下,该值默认为4。第一个成员变量b的自身对齐值是1,比指定或者默认指定 对齐值4小,所以其有效对齐值为1,所以其存放地址0x0000符合0x0000%1=0.第二个成员变量a,其自身对齐值为4,所以有效对齐值也为4, 所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中,复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐值为 2,所以有效对齐值也是2,可以存放在0x0008到0x0009这两个字节空间中,符合0x0008%2=0。所以从0x0000到0x0009存放的 都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b)所以就是4,所以结构体的有效对齐值也是4。根据结构体圆整的要求, 0x0009到0x0000=10字节,(10+2)%4=0。所以0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B 共有12个字节,sizeof(struct B)=12;其实如果就这一个就来说它已将满足字节对齐了, 因为它的起始地址是0,因此肯定是对齐的,之所以在后面补充2个字节,是因为编译器为了实现结构数组的存取效率,试想如果我们定义了一个结构B的数组,那 么第一个结构起始地址是0没有问题,但是第二个结构呢?按照数组的定义,数组中所有元素都是紧挨着的,如果我们不把结构的大小补充为4的整数倍,那么下一 个结构的起始地址将是0x0000A,这显然不能满足结构的地址对齐了,因此我们要把结构补充成有效对齐大小的整数倍.其实诸如:对于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从0x0000开始,那么b存放在0x0000,符合0x0000%1= 0;第二个变量,自身对齐值为4,指定对齐值为2,所以有效对齐值为2,所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续 字节中,符合0x0002%2=0。第三个变量c的自身对齐值为2,所以有效对齐值为2,顺序存放
    在0x0006、0x0007中,符合 0x0006%2=0。所以从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4,所以C的有效对齐值为2。又8%2=0,C 只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8.

    四.如何修改编译器的默认对齐值?

    1.在VC IDE中,可以这样修改:[Project]|[Settings],c/c++选项卡Category的Code Generation选项的Struct Member Alignment中修改,默认是8字节。
    2.在编码时,可以这样动态修改:#pragma pack .注意:是pragma而不是progma.

    五.针对字节对齐,我们在编程中如何考虑?

        如果在编程的时候要考虑节约空间的话,那么我们只需要假定结构的首地址是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;
    最后两句代码,从奇数边界去访问unsignedshort型变量,显然不符合对齐的规定。
    在x86上,类似的操作只会影响效率,但是在MIPS或者sparc上,可能就是一个error,因为它们要求必须字节对齐.

    七.如何查找与字节对齐方面的问题:

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

    八.相关文章:转自http://blog.csdn.net/goodluckyxl/archive/2005/10/17/506827.aspx

    ARM下的对齐处理 
    from DUI0067D_ADS1_2_CompLib

    3.13 type qulifiers

    有部分摘自ARM编译器文档对齐部分

    对齐的使用:
    1.__align(num)
       这个用于修改最高级别对象的字节边界。在汇编中使用LDRD或者STRD时
       就要用到此命令__align(8)进行修饰限制。来保证数据对象是相应对齐。
       这个修饰对象的命令最大是8个字节限制,可以让2字节的对象进行4字节
       对齐,但是不能让4字节的对象2字节对齐。
       __align是存储类修改,他只修饰最高级类型对象不能用于结构或者函数对象。
       
    2.__packed 
    __packed是进行一字节对齐
    1.不能对packed的对象进行对齐
    2.所有对象的读写访问都进行非对齐访问
    3.float及包含float的结构联合及未用__packed的对象将不能字节对齐
    4.__packed对局部整形变量无影响
    5.强制由unpacked对象向packed对象转化是未定义,整形指针可以合法定
    义为packed。
         __packed int* p; //__packed int 则没有意义
    6.对齐或非对齐读写访问带来问题
    __packed struct STRUCT_TEST
    {
    char a;
    int b;
    char c;
    } ;    //定义如下结构此时b的起始地址一定是不对齐的
             //在栈中访问b可能有问题,因为栈上数据肯定是对齐访问[from CL]
    //将下面变量定义成全局静态不在栈上 
    static char* p;
    static struct STRUCT_TEST a;
    void Main()
    {
    __packed int* q; //此时定义成__packed来修饰当前q指向为非对齐的数据地址下面的访问则可以

    p = (char*)&a;          
    q = (int*)(p+1);      

    *q = 0x87654321; 
    /*   
    得到赋值的汇编指令很清楚
    ldr      r5,0x20001590 ; = #0x12345678
    [0xe1a00005]   mov      r0,r5
    [0xeb0000b0]   bl       __rt_uwrite4 //在此处调用一个写4byte的操作函数 
          
    [0xe5c10000]   strb     r0,[r1,#0]   //函数进行4次strb操作然后返回保证了数据正确的访问
    [0xe1a02420]   mov      r2,r0,lsr #8
    [0xe5c12001]   strb     r2,[r1,#1]
    [0xe1a02820]   mov      r2,r0,lsr #16
    [0xe5c12002]   strb     r2,[r1,#2]
    [0xe1a02c20]   mov      r2,r0,lsr #24
    [0xe5c12003]   strb     r2,[r1,#3]
    [0xe1a0f00e]   mov      pc,r14
    */

    /*
    如果q没有加__packed修饰则汇编出来指令是这样直接会导致奇地址处访问失败
    [0xe59f2018]   ldr      r2,0x20001594 ; = #0x87654321
    [0xe5812000]   str      r2,[r1,#0]
    */

    //这样可以很清楚的看到非对齐访问是如何产生错误的
    //以及如何消除非对齐访问带来问题
    //也可以看到非对齐访问和对齐访问的指令差异导致效率问题
    }

    PS:读后
    1、明确结构的指定对齐值,如VC2005下是8。或者是由语句“#pragma pack (value)”指定的值。
    2、按照结构数据变量顺序相应计算。按照结构的指定对齐值进行占位计算。举例说明(默认对齐为8位):

    以下结构中,
    结构体或者类的自身对齐值(其成员中自身对齐值最大的那个值)为:
    double 长度为8
    指定对齐值为默认对齐值为8位。

    typedef struct
    {
       char x1;    //占据第1个8位的前1位,第1个8位剩下7位
       double x2;    //剩下的7位无法满足长度,本长度为8,开辟一个新的8位,第2个8位刚好用完
       size_t x3;    //开辟第3个8位,占据其中4位,剩余4位。
       unsigned short x4; //将第3个8位的后4位占据,第3个8位刚好用完
       int x5;     //开辟第4个8位,占据前4位
       double x6;    //开辟第5个8位,刚好用完
       char x7;    //开辟第6个8位,占据一位。其余为对齐占位,总计6*8=48位
    }x;

    以下结构中,
    结构体或者类的自身对齐值(其成员中自身对齐值最大的那个值)为:
    double 长度为8,因为指定为4,所以还是为4
    指定对齐值4位。

    #pragma pack (4)
    typedef struct
    {
       char y1;    //占据第1个4位的前1位,第一个4位剩下3位
       double y2;    //剩下的3位无法满足长度,本长度为8,开辟2个新的4位,刚好用完
       size_t y3;    //开辟第4个4位,占据其中4位,刚好用完。
       unsigned short y4; //开辟第5个4位,占用2位
       int y5;     //开辟第6个4位,刚好用完
       double y6;    //开辟第7、8个4位,刚好用完
       char y7;    //开辟第9个4位,占据1位。其余3位补齐。总计4*9=36位
    }y;
    #pragma pack ()

    展开全文
  • Linux 32位 默认4字节对齐,64位默认8字节对齐 (2) 结构体最大成员(基本数据类型变量) (3) 预编译指令#pragma pack(n)手动设置 n–只能填1 2 4 8 16 上面三者取最小的,就是实际对齐单位 相对于结构体地址的偏移量 ...

    一、总结

    1.1 先确定实际对齐单位,其由以下三个因素决定

    (1) CPU周期

    WIN vs qt 默认8字节对齐

    Linux 32位 默认4字节对齐,64位默认8字节对齐

    (2) 结构体最大成员(基本数据类型变量)

    (3) 预编译指令#pragma pack(n)手动设置 n–只能填1 2 4 8 16

    上面三者取最小的,就是实际对齐单位

    1.2相对于结构体地址的偏移量

    除结构体的第一个成员外,其他所有的成员的地址相对于结构体地址(即它首个成员的地址)的偏移量必须为实际对齐单位或自身大小的整数倍(取两者中小的那个)

    大多数处理器要求对某些类型的变量进行特定的内存对齐。通常,最小对齐方式是所讨论的基本类型的大小,例如

    (1) char 变量可以按字节对齐,并且可以出现在任何字节边界

    (2) short(2字节)变量必须对齐2个字节,它们可以出现在任何偶数字节边界。这意味着0x10004567不是short变量的有效位置,而0x10004566是有效位置。

    (3) long(4字节)变量必须对齐4字节,它们只能出现在4字节倍数的字节边界上。这意味着0x10004566不是长变量的有效位置,而0x10004568是有效位置。

    之所以会出现结构成员对齐,是因为结构的成员必须出现在正确的字节边界处,为此,编译器会放入填充字节(如果使用位字段,则填充位),以便结构成员出现在正确的位置。

    1.3结构体的整体大小必须为实际对齐单位的整数倍。

    另外,结构的大小必须使得在结构的数组中,所有结构在内存中都正确对齐,因此结构的末尾也可能存在填充字节

    二、测试验证

    2.1 T1

    struct test1
    {							实际地址		  偏移量
    	uint16_t  a;		//0x24048864		0	  地址为2的倍数
    	uint8_t   b;		//0x24048866		2	  地址为1的倍数
    	uint32_t  c;		//0x24048868		4     地址为4的倍数
    	uint8_t   d;		//0x2404886C		8     地址为1的倍数
    	uint16_t  e;		//0x2404886E		10    地址为2的倍数
    	uint8_t   f;		//0x24048870		12    地址为1的倍数
    	uint32_t  g;		//0x24048874		16    地址为4的倍数
    	uint8_t   h;		//0x24048878		20    地址为1的倍数
    };
    struct test1 t1 = {0};
    sizeof(t1) 值为24   
    t1.b后填充了1个字节
    t1.d后填充了1个字节
    t1.f后填充了3个字节
    t1.h后填充了3个字节
    对齐单位为 4 字节
    
    
    0x640x660x680x6c0x6e0x700x740x78
    aabccccdeefggggh

    2.2 T2

    #pragma pack(4)			//设置4字节对齐,但实际上由于结构体中单个成员的
    						//最大占用字节数为2字节,因此实际还是按2字节对齐
    struct test2
    {							实际地址		  偏移量
    	uint8_t  a;			//0x24048874		0	  地址为1的倍数
    	uint8_t   b;		//0x24048875		1	  地址为1的倍数
    	uint16_t  c;		//0x24048876		2     地址为2的倍数
    	uint8_t   d;		//0x24048878		4     地址为1的倍数
    };
    
    struct test2 t2 = {0};
    sizeof(t2) 值为6  
    t2.d后填充了1个字节
    对齐单位为 2 字节
    
    
    0x740x750x760x78
    abccd

    ————————————————
    参考链接1:
    https://blog.csdn.net/m0_37829435/article/details/81348532
    参考链接2:
    https://bytes.com/topic/c/answers/543879-what-structure-padding

    展开全文
  • 要求数据内存的起始地址的值是某个数k的倍数,这就是所谓的内存对齐,本文就来深入剖析C++中的struct结构体字节对齐,需要的朋友可以参考下
  • struct结构体字节对齐原则及为什么要对齐?

    万次阅读 多人点赞 2019-01-06 11:30:21
    http://blog.sina.com.cn/s/blog_14ecf1a5b0102x27j.html ... //-------------------------------------------------------- 本文目录结构 |-为什么结构体内存对齐 |-结构体内...

    http://blog.sina.com.cn/s/blog_14ecf1a5b0102x27j.html

    https://blog.csdn.net/zhanghow/article/details/55262988

    //--------------------------------------------------------

    本文目录结构

    |-为什么结构体内存对齐

    |-结构体内存对齐规则

    |-具体举例

    //--------------------------------------------------------

    一、为什么结构体内存对齐

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

           其实我们都知道,结构体只是一些数据的集合,它本身什么都没有。我们所谓的结构体地址,其实就是结构体第一个元素的地址。这样,如果结构体各个元素之间不存在内存对齐问题,他们都挨着排放的。对于32位机,32位编译器(这是目前常见的环境,其他环境也会有内存对齐问题),就很可能操作一个问题,就是当你想要去访问结构体中的一个数据的时候,需要你操作两次数据总线,因为这个数据卡在中间,如图:

    struct结构体字节对齐
     

           在上图中,对于第2个short数据进行访问的时候,在32位机器上就要操作两次数据总线。这样会非常影响数据读写的效率,所以就引入了内存对齐的问题。另外一层原因是:某些硬件平台只能从规定的地址处取某些特定类型的数据,否则会抛出硬件异常。

     

    二、结构体内存对齐的规则【未指定#pragma pack时】

          a.第一个成员起始于0偏移处;

          b.每个成员按其类型大小和指定对齐参数n中较小的一个进行对齐;

          c.结构体总长度必须为所有对齐参数的整数倍;

          d.对于数组,可以拆开看做n个数组元素。

         下表是Windows XP/DEV-C++和Linux/GCC中基本数据类型的长度和默认对齐模数。 

     

     

    char

    short

    int

    long

    float

    double

    long long

    long double

    Win-32

    长度

    1

    2

    4

    4

    4

    8

    8

    8

    模数

    1

    2

    4

    4

    4

    8

    8

    8

    Linux-32

    长度

    1

    2

    4

    4

    4

    8

    8

    12

    模数

    1

    2

    4

    4

    4

    4

    4

    4

    Linux-64

    长度

    1

    2

    4

    8

    4

    8

    8

    16

    模数

    1

    2

    4

    8

    4

    8

    8

    16

     

    三、具体举例

    例1:struct {
                     short a1;
                     short a2;
                     short a3;
                     }A;
              struct{
                     long a1;
                     short a2;
                     }B;

    sizeof(A) = 6; 这个很好理解,三个short都为2。

    sizeof(B) = 8; long为4,short为2,整个为8,因为规则b。

    例2:struct A{
                      int a;
                      char b;
                      short c;
                      };
           struct B{
                      char b;
                      int a;
                      short c;
                      };

    sizeof(A) = 8;sizeof(B) = 12。

    深究一下,为什么是这样,我们可以看看内存里的布局情况。

                                 a         b         c
         A的内存布局:1111,     1*,       11

                                 b          a        c
         B的内存布局:1***,     1111,   11**

         其中星号*表示填充的字节。A中,b后面为何要补充一个字节?因为c为short,其起始位置要为2的倍数,就是原则1。c的后面没有补充,因为b和c正好占用4个字节,整个A占用空间为4的倍数,也就是最大成员int类型的倍数,所以不用补充。B中,b是char为1,b后面补充了3个字节,因为a是int为4,根据原则1,起始位置要为4的倍数,所以b后面要补充3个字节。c后面补充两个字节,根据原则3,整个B占用空间要为4的倍数,c后面不补充,整个B的空间为10,不符,所以要补充2个字节。

    再看两个结构中含有结构成员的例子:

    例3:struct A{
                         int a;
                         double b;
                         float c;
                        };

                    struct B{
                         char e[2];
                         int f;
                         double g;
                         short h;
                         struct A i;
                        };

           sizeof(A) = 24; 这个比较好理解,int为4,double为8,float为4,总长为8的倍数,补齐,所以整个A为24。

           sizeof(B) = 48; 看看B的内存布局。

                            e         f             g                h                                    i 
    B的内存布局:11* *,   1111,   11111111, 11 * * * * * *,        1111* * * *, 11111111, 1111 * * * *

    i其实就是A的内存布局。i的起始位置要为24的倍数,所以h后面要补齐。

    例4:struct S1  

               {  

                  short a;  

                  long b;  

               };  

         struct S2  

              {  

        char c;  

        struct S1 d;  

        double e;  

              };  

           在Dev c++中,默认的是8字节对齐。我们分析下在4字节对齐的情况下输出的是,S2是20,S1是8,分析如图:

    struct结构体字节对齐
     

          在4字节对齐的情况中,有一个问题值得注意:就是图中画1的地方。这里面本应short是可以上去的。但是对于结构体中的结构体一定要十分警惕,S1是一体的,short已经由于long进行了内存对齐,后面还空了两个字节的内存,其实此时的short已经变成了4个字节了!!!即结构体不可拆,不管是多少字节对齐,他们都是一体的。所有的圈都变成了叉。所以说结构体只能往前篡位置,不能改变整体。

          我们在分析一些8字节对齐的情况,如图:

    struct结构体字节对齐

           以上讲的都是没有#pragma pack宏的情况,如果有#pragma pack宏,对齐方式按照宏的定义来。比如上面的结构体前加#pragma pack(1),内存的布局就会完全改变。sizeof(A) = 16; sizeof(B) = 32;

          有了#pragma pack(1),按1字节对齐。没错,这不是理想中的没有内存对齐的世界吗。

                                   a                b             c
          A的内存布局:1111,     11111111,   1111

                                 e        f             g         h                     i
          B的内存布局:11,   1111,   11111111, 11 ,            1111, 11111111, 1111

          那#pragma pack(2)的结果又是多少呢?#pragma pack(4)呢?留给大家自己思考吧,相信没有问题。

    展开全文
  • 三步解决C语言中struct字节对齐问题

    万次阅读 多人点赞 2018-08-01 23:03:39
    直入主题,要判断一个结构体所占的空间大小,大体来说分三步走: ... Linux 32位 默认4字节对齐,64位默认8字节对齐 (2)结构体最大成员(基本数据类型变量) (3)预编译指令#pragma pack(n)手动设置 n--只能...
  • 规则1: 结构体(struct)的数据成员,第一个数据成员放在offset为0的地方,以后每个数据成员放在offset为该数据成员大小的整数倍的地方(比如int在32为机器为4个字节,则每个int变量都是从4的整数倍地址开始存储) ...
  • struct字节对齐问题

    2017-12-04 10:02:57
    C语言项目开发过程中发现其他模块发给自己模块的消息长度与自己代码sizeof(struct)不一致,经过定位分析发现两边struct字节对齐方式不一致,C语言中默认为四字节对齐,如果struct字节不足4的倍数,则以4的倍数为...
  • 关于C语言中的结构体字节对齐问题,在《C与指针》一书中提到,但是似乎没有说清楚,还是我理解不完全?所以,根据书上和网上资料,总结一些关于C语言中的结构体字节对齐的知识。这里的讨论和代码,都在VS2010下,GCC...
  • struct对齐规则

    2020-09-12 00:50:14
    参考了:结构体在内存中的对齐规则 -CSDN博客 先看这一段代码: struct A{ char a; int b; double c; }; int main(){ A a; cout << sizeof(a) << endl; cout << &a << endl; ...
  • 结构体的内存对齐: 对于每个成员从上一个结尾变量终止的位置开始,找到最近的为此变量内存对齐方式大小倍数的起始位置...编译器中提供了#pragma pack(n)设定变量以n字节对齐(保证<=n字节的对齐方式): 如果n...
  • 写出一个struct,然后sizeof,你会不会经常对结果感到奇怪?sizeof的结果往往都比你声明的变量总长度要大,这是怎么回事呢?讲讲字节对齐吧.
  • struct是一种复合数据类型,一般而言struct的sizeof是所有成员对齐后长度相加的长度,下面分析一下: 1. //我的电脑是64位 #include&lt;stdio.h&gt; struct sum { short d; }; int main(void) { sum...
  • C语言字节对齐规则总结

    千次阅读 多人点赞 2018-10-23 16:16:30
    原始链接源自 https://www.cnblogs.com/clover-toeic/p/3853132.html , 从上面博客中学习总结得到下面的文章。... 此外,是由于对内存的存取效率问题,如果存放的地址不对齐,取一个4字节的数据,可能会需...
  • 字节对齐问题在面试笔试中经常碰到,自己也在这里经常碰到坑,今天索性把这方面搞清楚,记录自己这方面的学习过程。大端小端法机器的大端小端问题一直是一个常考的点,并且struct的内存布局问题和这个大端小端有很大...
  • 既然提到了struct那么肯定就避免不了结构体,结构体的内存对齐。 1. 什么是结构体? 结构体是一系列类型数据的集合这些数据可能描述了一个物体。 2. 什么时候会用到结构体? 1. 当内置类型无法满足用户需求的时候,...
  • 1.字节对齐的基本概念 现代计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但实际情况是在访问特定类型变量的时候经常在特 定的内存地址访问,这就需要各种类型数据...
  • 该结构大致如下:struct ...对应的Python代码:import structs = struct.unpack("icc", buf) #buf是从网络接收的字节流结果却报“Unpack str size does not match format”错。很明显是C++ struct产生的size和Pyth...
  • 涉及struct字节对齐,代码中发现自己struct占用的字节数和自认为的有出入,故搜集相关资料,整理,仅作个人记录先介绍一下4个基本概念: 1.数据类型自身的对齐值:对于char型数据,其自身对齐值为1,对于short型...
  • struct用法: struct在C语言中作为结构体。 结构体定义: struct stu{ char job[20]; int age; float height; }; 使用: struct stu a; //或者省略关键字struct stu a; 也可以定义和使用同时: ...
  • 结构体 字节对齐的好外: 提升读取的效率 代码如下: 结构体: struct TestByte { int age1; //32位 4个字节 long age2;//32位 4个字节 short ag3; //32位 2个字节 }testByte1; 主函数: void main...
  • C/C++结构体字节对齐详解

    千次阅读 2018-08-17 19:06:05
    前提:为了访问速度和效率,需要各种类型数据按照一定的规则在空间上排列; ...于是有了字节对齐,4个字节是一个自然对齐 为什么是4个字节? 32位机,即计算机数据总线宽度为32个,一次可以处...
  • 本示例均采用编译器默认字节对齐方式来说明,STM32 在KEIL中内存为4字节对齐。 #pragma pack() //取消自定义字节对齐方式 各字符类型占用字节数 类型 占用内存(对齐值) /字节 char 1 short 2 int 4 ...
  • 1.什么是字节对齐在c语言的结构体里面一般会按照某种规则去进行字节对齐。我们先看一段代码:struct st1{char name;double age;char sex;};//32位下 sizeof(struct st1) = 16//64位下 sizeof(struct st1) = 24struct...
  • 什么是字节对齐 这跟读取数据有关,cpu读取一次能读取到的内存大小跟数据总线的位数有关,如果数据总线为16位,那么cpu一次能够读取2字节;如果为32位那么cpu一次可以读取4字节,而读取数据是需要消耗时间的,为了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,940
精华内容 23,576
关键字:

struct字节对齐规则