精华内容
下载资源
问答
  • 2018-12-23 23:26:00

    #pragma pack (n)             作用:C编译器将按照n个字节对齐。
    #pragma pack ()               作用:取消自定义字节对齐方式。


    #pragma  pack (push,1)     作用:是指把原来对齐方式设置压栈,并设新的对齐方式设置为1个字节对齐

    #pragma pack(pop)            作用:恢复对齐状态

    转载于:https://www.cnblogs.com/fisherman-luo/p/10166448.html

    更多相关内容
  • C---编译器字节对齐

    2021-10-13 16:42:09
    本文介绍了编译器对齐的相关内容。

    背景

    在项目代码中碰到平台配置文件中定义结构体时使用关键词__attribute__,遂在网上查找它的相关知识,发现有好文将我的疑惑解开,在这里贴出出处字节对齐。同时为了方便日后自己查阅,下文均是摘自上文精华。如有冒犯,联系删帖。

    概念

    自然对齐:
    对齐跟数据在内存中的位置有关。如果一个变量的内存地址正好位于它长度的整数倍,他就被称做自然对齐。
    比如在32位cpu下,假设一个整型变量的地址为0x00000004,那它就是自然对齐的。
    字节对齐:
    在C语言中,结构是一种复合数据类型,其构成元素既可以是基本数据类型(如int、long、float等)的变量,也可以是一些复合数据类型(如数组、结构、联合等)的数据单元。在结构中,编译器为结构的每个成员按其自然边(alignment)分配空间。各个成员按照它们被声明的顺序在内存中顺序存储,第一个成员的地址和整个结构的地址相同。为了使CPU能够对变量进行快速的访问,变量的起始地址应该具有某些特性,即所谓的”对齐”.

    为什么要字节对齐

    需要字节对齐的根本原因在于CPU访问数据的效率问题。
    假设上面整型变量的地址不是自然对齐,比如为0x00000002,则CPU如果取它的值的话需要访问两次内存,第一次取从0x00000002-0x00000003的一个short,第二次取从0x00000004-0x00000005的一个short然后组合得到所要的数据,如果变量在0x00000003地址上的话则要访问三次内存,第一次为char,第二次为short,第三次为char,然后组合得到整型数据。
    而如果变量在自然对齐位置上,则只要一次就可以取出数据。一些系统对对齐要求非常严格,比如sparc系统,如果取未对齐的数据会发生错误,举个例:
      
      char ch[8];
      char *p = &ch[1];
      int i = *(int *)p; 
      
      运行时会报segment error,而在x86上就不会出现错误,只是效率下降。

    正确处理字节对齐

    对于标准数据类型,它的地址只要是它的长度的整数倍就行了,而非标准数据类型按下面的原则对齐:
      
      数组 :按照基本数据类型对齐,第一个对齐了后面的自然也就对齐了。
      联合 :按其包含的长度最大的数据类型对齐。
      结构体: 结构体中每个数据类型都要对齐。
      比如有如下一个结构体:
      
      struct stu{
       char sex;
       int length;
       char name[10];
      };
      struct stu my_stu;
      
      
    由于在x86下,GCC默认按4字节对齐,它会在sex后面跟name后面分别填充三个和两个字节使length和整个结构体对齐。于是我们sizeof(my_stu)会得到长度为20,而不是15.

    __attribute__选项

    我们可以按照自己设定的对齐大小来编译程序,GNU使用__attribute__选项来设置,比如我们想让刚才的结构按一字节对齐,我们可以这样定义结构体
      
      struct stu{
       char sex;
       int length;
       char name[10];
      }attribute ((aligned (1)));
      
      struct stu my_stu;
      
      
      则sizeof(my_stu)可以得到大小为15。
      
      上面的定义等同于
      
      struct stu{
       char sex;
       int length;
       char name[10];
      }attribute ((packed));
      struct stu my_stu;
      
      
    attribute((packed))得变量或者结构体成员使用最小的对齐方式,即对变量是一字节对齐,对域(field)是位对齐.

    什么时候需要设置对齐

    1.在设计不同CPU下的通信协议;
    2.编写硬件驱动程序时寄存器的结构这两个地方都需要按一字节对齐;
    3.文件系统中数据存储(项目代码中使用的原因)

    更改C编译器的缺省字节对齐方式

    在缺省情况下,C编译器为每一个变量或是数据单元按其自然对界条件分配空间。一般地,可以通过下面的方法来改变缺省的对界条件:
    · 使用伪指令#pragma pack (n),C编译器将按照n个字节对齐。
    · 使用伪指令#pragma pack (),取消自定义字节对齐方式。

    另外,还有如下的一种方式:
    · attribute((aligned (n))),让所作用的结构成员对齐在n字节自然边界上。如果结构中有成员的长度大于n,则按照最大成员的长度来对齐。
    · attribute ((packed)),取消结构在编译过程中的优化对齐,按照实际占用字节数进行对齐。

    展开全文
  • 编译器字节对齐问题

    千次阅读 2018-04-19 10:44:27
    http://blog.sina.com.cn/s/blog_8b08096f0101amkd.html...一般地,可以通过下面的方法来改变缺省的对界条件: · 使用伪指令#pragma pack (n),C编译器将按照n个字节对齐。 · 使用伪指令#pragma pack (),...
    

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

    更改C编译器的缺省字节对齐方式


    在缺省情况下,C编译器为每一个变量或是数据单元按其自然对界条件分配空间。一般地,可以通过下面的方法来改变缺省的对界条件:


         · 使用伪指令#pragma pack (n),C编译器将按照n个字节对齐。


         · 使用伪指令#pragma pack (),取消自定义字节对齐方式。



     



    另外,还有如下的一种方式:


         · __attribute((aligned (n))),让所作用的结构成员对齐在n字节自然边界上。如果结构中有成员的长度大于n,则按照最大成员的长度来对齐。


         · __attribute__ ((packed)),取消结构在编译过程中的优化对齐,按照实际占用字节数进行对齐。


    【转载例文】


    1. 概述
        本文讨论了结构的自然边界对齐,在缺省情况下,c编译器为每一个变量或数据单元按其自然边界对齐条件分配空间。
        但可以通过四种方法来更改C编译器的缺省字节对齐方式,即可以指定边界对齐。
        
        在阅读完本文档后,将会更深入地了解一个结构的sizeof到底应当是多少。

    2. 自然边界对齐
        在C语言中,结构是一种复合数据类型,其构成元素既可以是基本数据类型(如int、long、float等)的变量,也可以是一些复合数据类型(如数组、结构、联合等)的数据单元。

        结构字节对齐有以下几个特点:
        1. 对于结构体,编译器会自动进行成员变量的对齐,以提高运算效率。
           缺省情况下,编译器为结构的每个成员按其自然边界对齐( natural alignment)条件分配空间。
           自然边界对齐即为默认对齐方式。

        2. 各个成员按照它们被声明的顺序在内存中顺序存储,第一个成员的地址和整个结构的地址相同。

        3. 结构整体的默认对齐方式就是它的所有成员使用的对齐参数中最大的一个。

        4. 结构整体长度的计算必须取所用过的所有对齐参数的整数倍,不够补空字节;
           也就是取所用过的所有对齐参数中最大的那个值的整数倍,因为对齐参数都是2的n次方;
           这样在处理数组时可以保证每一项都边界对齐;

        例如,下面的结构各成员空间分配情况:
        struct test
        {
            char  x1;
            short x2;
            float x3;
            char  x4;
        };
        结构的第一个成员x1,其偏移地址为0,占据了第1个字节。
        第二个成员x2为short类型,其起始地址必须2字节边界对齐,因此,编译器在x2和x1之间填充了一个空字节。
        结构的第三个成员x3和第四个成员x4恰好落在其自然边界对齐地址上,在它们前面不需要额外的填充字节。
        在test结构中,成员x3要求4字节边界对齐,是该结构所有成员中要求的最大边界对齐单元,因而test结构的自然边界对齐条件为4字节,编译器在成员x4后面填充了3个空字节。整个结构所占据空间为12字节。

    3. 指定边界对齐 
       在缺省情况下,c编译器为每一个变量或数据单元按其自然边界对齐条件分配空间;但可以通过下面四种方法来更改C编译器的缺省字节对齐方式:

    方法1: 使用#pragma pack
         #pragma pack说明:
         1. pack提供数据声明级别的控制,对定义不起作用;
         2. 调用pack时不指定参数,将恢复C编译器的缺省字节对齐方式,即使用伪指令#pragma pack()将取消自定义字节对齐方式;
         3. 一旦改变数据类型的alignment,直接效果就是占用memory的减少,但是performance可能会下降;
        
        #pragma pack语法详细说明:
        1. show:可选参数;显示当前packing aligment的字节数,以warning message的形式被显示;
        2. push:可选参数;将当前指定的packing alignment数值进行压栈操作,这里的栈是the internal compiler stack,同时设置当前的packing alignment为n;如果n没有指定,则将当前的packing alignment数值压栈;
        3. pop:可选参数;从internal compiler stack中删除最顶端的record;如果没有指定n,则当前栈顶record即为新的packing alignment数值;如果指定了n,则n将成为新的packing aligment数值;如果指定了identifier,则internal compiler stack中的record都将被pop直到identifier被找到,然后pop出identitier,同时设置packing alignment数值为当前栈顶的record;如果指定的identifier并不存在于internal compiler stack,则pop操作被忽略;
        4. identifier:可选参数;当同push一起使用时,赋予当前被压入栈中的record一个名称;当同pop一起使用时,从internal compiler stack中pop出所有的record直到identifier被pop出,如果identifier没有被找到,则忽略pop操作;
        5. n:可选参数;指定packing的数值,以字节为单位;缺省数值是8,合法的数值分别是1、2、4、8、16。

        #pragma pack规定的对齐长度,实际使用的规则是:结构,联合或者类的数据成员,第一个放在偏移为0的地方,以后每个数据成员的对齐,按照#pragma pack指定的数值和这个数据成员自身长度中比较小的值来对齐。
        也就是说,当#pragma pack的值等于或超过所有数据成员长度的时候,这个值的大小将不产生任何效果。
        而结构整体的对齐,则按照结构体中size最大的数据成员和#pragma pack指定值之间较小的值来对齐。

        -------------------------------------------
        例1:
        #pragma pack(2)
        struct TestA
    {
    public:
    int   a; // 第一个成员,放在[0,3]偏移的位置。
    char  b; // 第二个成员sizeof(char)=1,#pragma pack(2), 取小值也就是1,所以这个成员按1字节对齐,放在偏移[4]的位置。
    short c; // 第三个成员sizeof(short)=2, #pragma pack(2),取小值也就是2,所以这个成员按2字节对齐,所以放在偏移[6,7]的位置。
    char  d; // 第四个成员sizeof(short)=1, #pragma pack(2), 取小值也就是1,所以这个成员按1字节对齐,放在[8]的位置。
    };
        #pragma pack()
        struct TestA中size最大的数据成员(4),#pragma pack(2), 取小值也就是2,所以sizeof(TestA)应当按照2来对齐,为10。

        -------------------------------------------
        例2:
        #pragma pack(4)
        struct TestB
    {
    public:
    int   a; // 第一个成员,放在[0,3]偏移的位置。
    char  b; // 第二个成员sizeof(char)=1,#pragma pack(4), 取小值也就是1,所以这个成员按1字节对齐,放在偏移[4]的位置。
    short c; // 第三个成员sizeof(short)=2, #pragma pack(4),取小值也就是2,所以这个成员按2字节对齐,所以放在偏移[6,7]的位置。
    char  d; // 第四个成员sizeof(short)=1, #pragma pack(4), 取小值也就是1,所以这个成员按1字节对齐,放在[8]的位置。
    };
        #pragma pack()
        struct TestB中size最大的数据成员(4),#pragma pack(4),  取小值也就是4,所以sizeof(TestB)应当按照4来对齐,为12。

        -------------------------------------------
        例3:
        #pragma pack(8)
        struct s1
        {
            short a; // 第一个成员,放在[0, 1]偏移的位置。
            long  b; // 第二个成员sizeof(long)=4, #pragma pack(8), 取小值也就是4,所以这个成员按4字节对齐,放在偏移[4~7]的位置。
        };

        struct s2
        {
            char     

    展开全文
  • 关于编译器字节对齐 (转)

    千次阅读 2019-01-02 08:42:36
    现代计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问...各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在...

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

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

    二.字节对齐对程序的影响:
    先让我们看几个例子吧(32bit,x86环境,gcc编译器):
    设结构体如下定义:

    struct A
     {
          int    a;
          char b;
          short c;
     };
               4Byte
             |---------|
              |    a    |
              |----|----|
              | b -| c -|
              |---------|
    struct B
     {
          char b;
          int    a;
          short c;
     };
             |--------|
              |b |  \  |
              |--------|
              |    a   |
              |--------|
              | 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 B
     {
          char b;
          int    a;
          short c;
     };
     #pragma pack () /*取消指定对齐,恢复缺省对齐*/
    

    sizeof(struct B)值是8。
    修改对齐值为1:

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

    sizeof(struct B)值为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.
    · 使用伪指令#pragma pack (n),C编译器将按照n个字节对齐。
    · 使用伪指令#pragma pack (),取消自定义字节对齐方式。

    · __attribute((aligned (n))),让所作用的结构成员对齐在n字节自然边界上。如果结构中有成员的长度大于n,则按照最大成员的长度来对齐。
    ·__attribute__((packed)),取消结构在编译过程中的优化对齐,按照实际占用字节数进行对齐。

    五.针对字节对齐,我们在编程中如何考虑?
    如果在编程的时候要考虑节约空间的话,那么我们只需要假定结构的首地址是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. 编译器的big little端设置

    2. 看这种体系本身是否支持非对齐访问

    3. 如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作。

    4. __attribute__ ((packed)) 的作用就是告诉编译器取消结构在编译过程中的优化对齐,按照实际占用字节数进行对齐,是GCC特有的语法。这个功能是跟操作系统没关系,跟编译器有关,gcc编译器不是紧凑模式的,我在windows下,用vc的编译器也不是紧凑的,用tc的编译器就是紧凑的。例如:

    在TC下:struct my{ char ch; int a;} sizeof(int)=2;sizeof(my)=3;(紧凑模式)

    在GCC下:struct my{ char ch; int a;} sizeof(int)=4;sizeof(my)=8;(非紧凑模式)

    在GCC下:struct my{ char ch; int a;}__attrubte__ ((packed)) sizeof(int)=4;sizeof(my)=5

    1. __attribute__关键字主要是用来在函数或数据声明中设置其属性。给函数赋给属性的主要目的在于让编译器进行优化。函数声明中的__attribute__((noreturn)),就是告诉编译器这个函数不会返回给调用者,以便编译器在优化时去掉不必要的函数返回代码。

    GNU C的一大特色就是__attribute__机制。__attribute__可以设置函数属性(Function Attribute)、变量属性(Variable Attribute)和类型属性(Type Attribute)。

    __attribute__书写特征是:__attribute__前后都有两个下划线,并且后面会紧跟一对括弧,括弧里面是相应的__attribute__参数。

    __attribute__语法格式为:

    __attribute__ ((attribute-list))
    

    其位置约束:放于声明的尾部“;”之前。

    函数属性(Function Attribute):函数属性可以帮助开发者把一些特性添加到函数声明中,从而可以使编译器在错误检查方面的功能更强大。__attribute__机制也很容易同非GNU应用程序做到兼容之功效。

    GNU CC需要使用 –Wall编译器来击活该功能,这是控制警告信息的一个很好的方式。

    packed属性:使用该属性可以使得变量或者结构体成员使用最小的对齐方式,即对变量是一字节对齐,对域(field)是位对齐。

    如果你看过GPSR协议在TinyOS中的实现,你一定会注意到下面的语句:

    typedef struct {
        double x;
        double y;
     } __attribute__((packed)) position_t;
    

    开始我们还可以理解,不久是定义一个结构体嘛!不过看到后面的语句,你可能就会一头雾水了,’ __attribute__((packed))’是什么东西?有什么作用?一连串的疑问马上就会从你脑袋里冒出来。虽然这个对理解整个程序没有什么影响,但我不想让这些疑问一直呆在我的脑子里,负担太重。省得以后念念不忘,而且也许有一天可以用的上呢。搞清楚这个问题吧!

    GNU C的一大特色(却不被初学者所知)就是__attribute__机制。__attribute__可以设置函数属性(FunctionAttribute)、变量属性(Variable Attribute)和类型属性(TypeAttribute)。
    __attribute__语法格式为:

    __attribute__ ((attribute-list))
    

    其位置约束为:放于声明的尾部“;”之前。

    packed是类型属性(Type Attribute)的一个参数,使用packed可以减小对象占用的空间。需要注意的是,attribute属性的效力与你的连接器也有关,如果你的连接器最大只支持16字节对齐,那么你此时定义32字节对齐也是无济于事的。

    使用该属性对struct或者union类型进行定义,设定其类型的每一个变量的内存约束。当用在enum类型定义时,暗示了应该使用最小完整的类型(itindicates that the smallest integral type should be used)。

    下面的例子中,my-packed-struct类型的变量数组中的值会紧凑在一起,但内部的成员变量s不会被“pack”,如果希望内部的成员变量也被packed的话,my-unpacked-struct也需要使用packed进行相应的约束。

    struct my_unpacked_struct
     {
          char c;
          int i;
     };
              
     struct my_packed_struct
     {
          char c;
          int i;
          struct my_unpacked_struct s;
     }__attribute__ ((__packed__));
    

    在每个系统上看下这个结构体的长度吧。
    内存对齐,往往是由编译器来做的,如果你使用的是gcc,可以在定义变量时,添加__attribute__,来决定是否使用内存对齐,或是内存对齐到几个字节,以上面的结构体为例:
    1)到4字节,同样可指定对齐到8字节。

    struct student
    {
        char name[7];
        uint32_t id;
        char subject[5];
    } __attribute__ ((aligned(4))); 
    

    2)不对齐,结构体的长度,就是各个变量长度的和

    struct student
    {
        char name[7];
        uint32_t id;
        char subject[5];
    } __attribute__ ((packed));
    

    原文传送门:https://blog.csdn.net/embzheng/article/details/7598221

    展开全文
  • linux 改变GCC编译器字节对齐方式

    千次阅读 2020-09-24 23:49:58
    linux C 字节对其简介 在C语言中,结构是一种复合数据类型,其构成元素既可以是基本数据类型(如int、long、float等)的变量,也可以是一些复合数据类型(如数组、结构、联合等)的数据单元。 在结构中,编译器为...
  • 本文主要讲了什么是字节对齐,为什么要对齐,已经应该注意的一些问题,下面一起来看看
  • GCC编译器字节对齐

    千次阅读 2019-07-29 23:32:48
    由于在X86(32位机器)平台下,GCC编译器默认按4字节对齐, 如: 结构体4字节对齐,即结构体成员变量所在的内存地址是4的整数倍 可以通过使用gcc中的__attribute__选项来设置指定的对齐大小。 1): __attribute__ (...
  • GCC编译器结构体默认字节对齐方式

    千次阅读 2020-09-03 18:53:43
    当然变量起始地址是自身所占字节数的整数倍,是默认情况下字节对齐的前提。...总结:gcc编译器和VC编译器字节对齐方式有些许差别,总的来说VC字节对齐要大一些,而GCC字节对齐方式比较省空间。 .
  • 字节对齐的细节和具体编译器实现相关,但一般而言,需满足以下四个准则: 1)结构体变量的首地址能够被其最宽基本类型成员的大小所整除; 2)结构体每个成员相对于结构体首地址的偏移量都是成员大小的整数倍,如有...
  • linux和windows gcc g++ vc编译器字节对齐

    千次阅读 2017-09-15 16:16:17
    首先可以肯定的说,肯定和编译器有关,vc编译器和gcc,g++编译器肯定不一样,不说明是什么编译器什么系统下问你结构体长度...并且最后的字节总长度为最宽长度的整数倍,不足补齐(都是按照对齐模数来的) (2)gcc和g+
  • 编译器对齐方式

    2018-05-03 00:03:17
    //用来指定结构体(联合)中对齐的字节数,即按多少字节对齐,如果不指定,则结构体按照最大的数据成员的长度进行对齐, //如果指定了,为n,若n大于等于结构体中最大数据成员的长度,则n无效,按照最大数据长度对齐...
  • #pragma pack:改变C编译器默认的对齐方式,设定变量以n字节对齐方式欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个...
  • 关于编译器4字节对齐方式比较

    千次阅读 2014-09-10 21:18:00
    所谓的字节对齐,就是各种类型的数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这个就是对齐。我们经常听说的对齐在N上,它的含义就是数据的存放起始地址%N==0。具体对齐规则会在下面的篇幅中介绍...
  • 结构体字节对齐和瑞萨编译器中结构体对齐的设置
  • 字节对齐详解

    千次阅读 2020-10-30 15:55:01
    字节对齐主要是针对结构体而言的,通常编译器会自动对其成员变量进行对齐,以提高数据存取的效率; 字节对齐有两种方式:默认对齐方式、指定对齐方式; 默认对齐方式 默认对齐方式内存分配满足以下三个条件: 结构体...
  • 要改变编译器默认的字节对齐方式,Linux下可使用一下两种方法: 一: #pragma pack (n) //C编译器将按照n个字节对齐。 #pragma pack () //取消自定义字节对齐方式 例如: #pragma pack(1) //一下...
  • 一、什么是字节对齐 在计算机中,内存空间是按照字节(1B = 8 bit)划分的,每一个字节都有一个编号,这就是字节的地址。理论上可以从任意起始地址访问任意数据类型的变量,但在实际使用中,访问特定数据类型变量时...
  • C语言 字节对齐

    2022-03-29 17:05:33
    结构体变量的首地址能够被其最宽基本类型成员的大小所整除; 结构体每个成员相对结构体首地址的偏移量(offset)都是成员大小的整数倍,如有需要...// char[*]多少都是按4字节对齐 struct stChar{ char a[5]; int b; .
  • C/C++字节对齐

    千次阅读 2022-03-25 16:46:54
    1. 字节对齐 字节对齐是字节按照一定规则在空间上排列。...实际编程中,字节对齐的细节都是由编译器完成,但是需要知道变量是如何在内存中进行对齐的。 2. C/C++ 结构体 在C语言中,结构体可以用来存放一
  • 这句指令,指定编译器按照n个字节对齐方式来存放数据。这个会影响struct结构体的占用空间。 2、#pragma pack () 使用默认的对齐方式。 3、根据程序需要,在适当的时候使用一种特别的n个字节对齐,然后恢复之前的...
  • 什么是字节对齐,为什么需要字节对齐

    万次阅读 多人点赞 2019-09-07 14:58:43
    在结构中,编译器为结构的每个成员按其自然边界(alignment)分配空间。各个成员按照它们被声明的顺序在内存中顺序存储,第一个成员的地址和整个结构的地址相同。  为了使CPU能够对变量进行快速的访问,变量的起始...
  • 字节对齐
  • 这是给编译器用的参数设置,有关结构体字节对齐方式设置, #pragma pack是指定数据在内存中的对齐方式。 #pragma pack (n) 作用:C编译器将按照n个字节对齐。 #pragma pack () 作用:取消自定义字节对齐方式。 #...
  • 编译器对结构在编译过程中会优化对齐,由于编译器的内存对齐,当一个char变量独立存在时,会分配一个int大小的空间,当两个char连续存在时,会给两个char分配一个int大小的空间. class CMemoryTest { int a; char b; int ...
  • Strlen和Sizeof的区别 Strlen —— 获取能容纳所建立的最大对象的字节大小,一般在编译时就计算好了长度大小,故不能用来返回动态分配时的大小 Sizeof —— 返回字符串...编译器的内存对齐问题 成员对齐的规则:每个...
  • 最近在使用ac6.9的编译器,编译速度是真的很快,使用stm32的hal库编译...ac5的测试结果:#ifdef CC_ARM_AC5//该方式只是使用ac5编译器,结构体不对齐的方式1,结构体的长度,就是各个变量长度的和__packed typedef st...
  • 系统 win10 64位 编译器:VS2017 测试32位和64位字节长度,先测试如下代码(struct中有1个8字节长度的double成员) // 测试字节长度.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // ...
  • 一、概念     对齐跟数据在内存中的位置有关。如果一个变量的内存地址... 需要字节对齐的根本原因在于CPU访问数据的效率问题。假设上面整型变量的地址不是自然对齐,比如为0x00000002,则CPU如果取它的值的话...
  • 但是在程序实际编译过程中,编译器会对数据类型在编译过程中进行优化对齐,编译器会将各种类型数据按照一定的规则在空间上排列,而不是顺序的排放,这就是内存字节对齐。 2、内存字节对齐原因 不同硬件平台对存储...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 57,392
精华内容 22,956
关键字:

不同编译器的字节对齐