内存对齐 订阅
内存对齐”应该是编译器的“管辖范围”。编译器为程序中的每个“数据单元”安排在适当的位置上。但是C语言的一个特点就是太灵活,太强大,它允许你干预“内存对齐”。如果你想了解更加底层的秘密,“内存对齐”对你就不应该再模糊了。 展开全文
内存对齐”应该是编译器的“管辖范围”。编译器为程序中的每个“数据单元”安排在适当的位置上。但是C语言的一个特点就是太灵活,太强大,它允许你干预“内存对齐”。如果你想了解更加底层的秘密,“内存对齐”对你就不应该再模糊了。
信息
特    征
透明
作    用
每个数据单元安排在适当的位置
释    义
是编译器的“管辖范围”。
中文名
内存对齐
内存对齐词条简介
对于大部分程序员来说,“内存对齐”对他们来说都应该是“透明的”。
收起全文
精华内容
下载资源
问答
  • 内存对齐

    2020-09-23 22:51:39
    文章目录结构体内存对齐什么是结构体内存对齐内存对齐实例n字节对齐方式人为设定n字节对齐方式设定n字节对齐方式实例内存对齐的作用总结 结构体内存对齐 什么是结构体内存对齐? 默认的对齐方式:各成员变量在存放...

    结构体内存对齐

    什么是结构体内存对齐?

    默认的对齐方式:各成员变量在存放的时候根据在结构中出现的顺序依次申请空间,同时按照上面的对齐方式调整位置,空缺的字节编译器会自动填充。
    同时编译器为了确保结构的大小为结构的字节边界数(即该结构中占用最大空间的类型所占用的字节数)的倍数,所以在为最后一个成员变量申请空间后,还会根据需要自动填充空缺的字节。
    这样的定义语言是不是有些难懂?下面通过一个实例来演示内存对齐。

    内存对齐实例

    深信服(C++软件开发)面试原题:

    struct A
    {
      char a;
      int b;
      char c;
      double d;
    };
    
    1. 先为第一个成员a分配空间,其起始地址和结构体的起始地址相同(偏移量为0),该变量为char型,占用sizeof(char) = 1个字节;
    2. 再为第二个成员b分配空间,这时下一个可以分配的地址对于结构体的偏移量为1,不是sizeof(int) = 4 的倍数,所以编译器需要自动补齐3个字节,变量b存储在偏移量为4的地址上,它占用4个字节;此时的偏移量为1+3+4=8;
    3. 为第三个成员c分配空间,这时下一个可以分配的地址对于结构体的偏移量为8,是sizeof(char) = 1 的倍数,所以变量c存储在偏移量为8的地址上,它占用1个字节;此时的偏移量为8+1=9;
    4. 为第四个成员d分配空间,这时下一个可以分配的地址对于结构体的偏移量为9,不是sizeof(double) = 8 的倍数,所以编译器需要自动补齐 (8*2-9)=7 个字节,变量b存储在偏移量为16的地址上,它占用8个字节;此时的偏移量为9+7+8=24;
    5. 偏移量为24,是结构体中最大空间类型所占用字节数 8 (sizeof(double) ) 的倍数,不需要补齐;
    6. 所以最终结构体占用的总空间大小为24个字节。

    n字节对齐方式

    人为设定n字节对齐方式

    在VC中提供了#pragmapack(n)来设定变量以n字节对齐方式。
    n字节对齐就是说变量存放的起始地址的偏移量有两种情况:

    1. 如果n大于等于该变量所占用的字节数,那么偏移量必须满足默认的对齐方式;
    2. 如果n小于该变量的类型所占用的字节数,那么偏移量为n的倍数,不用满足默认的对齐方式。

    结构的总大小也有个约束条件:

    1. 如果n大于所有成员变量类型所占用的字节数,那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数;
    2. 否则必须为n的倍数。

    设定n字节对齐方式实例

    仍以上面代码为例,稍加修改:

    #pragmapack(push)	//保存对齐状态
    #pragmapack(4)		//设定为4字节对齐
    
    struct A
    {
      char a;
      int b;
      char c;
      double d;
    };
    
    #pragmapack(pop)	//恢复对齐状态
    
    1. 先为第一个成员a分配空间,其起始地址和结构体的起始地址相同(偏移量为0),满足我们设定的4字节对齐方式,该变量占用sizeof(char) = 1个字节;
    2. 再为第二个成员b分配空间,这时下一个可以分配的地址对于结构体的偏移量为1,不是sizeof(int) = 4 和设定的4字节的倍数,所以编译器需要自动补齐3个字节,变量b存储在偏移量为4的地址上,它占用4个字节;此时的偏移量为1+3+4=8;
    3. 为第三个成员c分配空间,这时下一个可以分配的地址对于结构体的偏移量为8,是sizeof(char) = 1 的倍数,所以变量c存储在偏移量为8的地址上,它占用1个字节;此时的偏移量为8+1=9;
    4. 为第四个成员d分配空间,这时下一个可以分配的地址对于结构体的偏移量为9,不是我们设定的 4 的倍数(因为sizeof(double)大于4),所以编译器需要自动补齐 (4*3-9)=3 个字节,变量b存储在偏移量为12的地址上,它占用8个字节;此时的偏移量为9+3+8=20;
    5. 偏移量为20,满足4的倍数,不需要补齐;
    6. 所以最终结构体占用的总空间大小为20个字节。

    内存对齐的作用

    我们平时理解中的内存是一个一个字节分开存储的,但是CPU并不是这样看待的。
    在这里插入图片描述

    CPU把内存当成是一块一块的,比如块的大小是4,8,16个字节大小,因此CPU在读取内存时是一块一块地读取。
    在这里插入图片描述

    如图,当数据对齐时(从0字节开始),CPU只需读取一次内存就可以把4个字节的数据完全读取到寄存器中
    在这里插入图片描述

    当数据没有对齐,比如从1字节开始,CPU读取数据有些复杂,需要分两次才能读取到数据
    在这里插入图片描述

    总结

    其实内存对齐就是拿空间换取时间的做法,来提高CPU读数据的效率。

    展开全文
  • 内存对齐,值得一读的内容, 内存对齐,值得一读的内容, 内存对齐,值得一读的内容, 内存对齐,值得一读的内容,
  • 内存对齐内存对齐规则解释、内存对齐原理

    千次阅读 多人点赞 2020-03-28 23:44:31
    一、内存对齐的原因 我们都知道计算机是以字节(Byte)为单位划分的,理论上来说CPU是可以访问任一编号的字节数据的,我们又知道CPU的寻址其实是通过地址总线来访问内存的,CPU又分为32位和64位,在32位的CPU一次...

    一、内存对齐的原因

    我们都知道计算机是以字节(Byte)为单位划分的,理论上来说CPU是可以访问任一编号的字节数据的,我们又知道CPU的寻址其实是通过地址总线来访问内存的,CPU又分为32位和64位,在32位的CPU一次可以处理4个字节(Byte)的数据,那么CPU实际寻址的步长就是4个字节,也就是只对编号是4的倍数的内存地址进行寻址。同理64位的CPU的寻址步长是8字节,只对编号是8的倍数的内存地址进行寻址,如下图所示是64位CPU的寻址示意图:
    在这里插入图片描述

    这样做可以实现最快速的方式寻址且不会遗漏一个字节,也不会重复寻址。

    那么对于程序而言,一个变量的数据存储范围是在一个寻址步长范围内的话,这样一次寻址就可以读取到变量的值,如果是超出了步长范围内的数据存储,就需要读取两次寻址再进行数据的拼接,效率明显降低了。例如一个double类型的数据在内存中占据8个字节,如果地址是8,那么好办,一次寻址就可以了,如果是20呢,那就需要进行两次寻址了。这样就产生了数据对齐的规则,也就是将数据尽量的存储在一个步长内,避免跨步长的存储,这就是内存对齐。在32位编译环境下默认4字节对齐,在64位编译环境下默认8字节对齐。

    查看自己电脑是多少位操作系统
    终端下输入:uname -a 回车
    x86_64 表示系统为64位
    i686 表示系统32位的

    二、对齐规则
    1:数据成员对齐规则:结构(struct)(或联合(union))的数据成员,第一个数据成员放在offset为0的地方,以后每个数据成员的偏移为 #pragma pack 指定的数值和这个数据成员自身长度中较小那个的整数倍。
    2:数据成员为结构体:如果结构体的数据成员还为结构体,则该数据成员的“自身长度”为其内部最大元素的大小。(struct a 里存有 struct b,b 里有char,int,double等元素,那 b “自身长度”为 8)
    3:结构体的整体对齐规则:在数据成员按照 #1 完成各自对齐之后,结构体本身也要进行对齐。对齐会将结构体的大小增加为 #pragma pack 指定的数值和结构体最大数据成员长度中较小那个的整数倍。

    (看不懂没关系,因为我也没看懂,也是打印之后才明白)

    三、实例

    typedef struct test1 {
        char a;//1
        int b;//4字节
        double c;//8
        char d[11];//11
    }Test1;//数据成员
    
    int main(int argc, const char * argv[]) {
    
        Test1 t1;
        //xcode默认对齐系数8,即#pragma pack(8)
        //char a,     1<8按1对齐,offset=0            [0]
        //int b,      4<8按4对齐,char a占到[0],int b应该从地址1开始排, 地址1不是对齐数4的倍数,所以int b的首地址是从4的最小倍数开始,所以offset=4,       [4...7];
        //double c,   8=8按8对齐,int b已经占到[4...7],double c从地址8开始排,地址8是对齐数8的倍数,所以double c的首地址是从8的最小倍数开始,offse=8             [8...15]
        //char d[11], 1<8按1对齐,double c已经占到[8...15], char d[11]从地址16开始,地址16是对齐数1的倍数,所以char d的,offset=16,          存储位置[16...26]
        //最后为27位,又因为27不是内部最大成员中double 8位字节的倍数,所以补齐为32)
        printf(" %lu\n %p\n %p\n %p\n %p\n", sizeof(t1), &t1.a, &t1.b, &t1.c, &t1.d);
        
        return 0;
    }
    

    结果:

     32
     0x7ffeefbff568
     0x7ffeefbff56c
     0x7ffeefbff570
     0x7ffeefbff578
    

    以首地址0x7ffeefbff568为offset=0,
    0x68=104,
    0x6c=108,
    0x70=112,
    0x78=120,
    0x7ffeefbff56c相对于0x7ffeefbff568便宜了4,
    0x7ffeefbff570相对于0x7ffeefbff568便宜了8,
    0x7ffeefbff578相对于0x7ffeefbff568偏移了16,符合规律
    上面int b正好偏移4,double c正好偏移8,比较凑巧,如果char a[5]呢,使地址正好措开,此时int b应该是[8…13],double c应该是[16…23], char d[11]应该是[24…34],34不是最大double c的整数倍,补齐到最小倍数40,所以结构体的大小应该是40.

     40
     0x7ffeefbff560
     0x7ffeefbff568
     0x7ffeefbff570
     0x7ffeefbff578
    Program ended with exit code: 0
    

    在结构体struct Test1中添加一个结构体Test2,看下结果:

    typedef struct test2 {
        char a[13];//1      [0...13]
        double b;//8        [16...23]
        int c[11];//4       [24...67]
        float d;//4         [68...71]
    }Test2;
    
    typedef struct test1 {
        char a[5];//1       [0...4]
        int b;//4           [8...11]
        double c;//8        [16...23]
        char d[11];//11     [24...34]
        Test2 t2;//         [40...111] Test2的'自身长度'为double b=8,所以从8的最小倍数开始,即40
    }Test1;//数据成员
    //此时:
    //  char a[13];//1      [40...52]
    //  double b;//8        [56...63]
    //  int c[11];//4       [64...107]
    //  float d;//4         [107...111]
    
    int main(int argc, const char * argv[]) {
        
        Test1 t1;
        Test2 t2;
        printf(" %lu\n", sizeof(t2));
        printf(" %lu\n", sizeof(t1));
        return 0;
    }
    

    结果:

     72
     112
    Program ended with exit code: 0
    

    把Test2中的double b注销了,看下结果:

    typedef struct test2 {
        char a[13];//1      [0...13]
        //double b;//8        [16...23]
        int c[11];//4       [16...59]
        float d;//4         [60...63]
    }Test2;
    
    typedef struct test1 {
        char a[5];//1       [0...4]
        int b;//4           [8...11]
        double c;//8        [16...23]
        char d[11];//11     [24...34]
        Test2 t2;//64       [36...99] 此时Test2的'自身长度'为int c=4,所以从4的最小倍数开始,即36开始,又因为100不是double c的倍数,补齐到最小倍数104
    }Test1;//数据成员
    
    int main(int argc, const char * argv[]) {
        
        Test1 t1;
        Test2 t2;
        printf(" %lu\n", sizeof(t2));
        printf(" %lu\n", sizeof(t1));
        return 0;
    }
    
     64
     104
    Program ended with exit code: 0
    

    四、更改默认对齐系数

    #pragma pack(2)//1、2、4、8、16,以2为例
    
    typedef struct test2 {
        char a[13];//1      [0...13]
        //double b;//8        [16...23]
        int c[11];//4    2<4   [14...57]从2的最小倍数开始,即14
        float d;//4         [58...61]
    }Test2;
    int main(int argc, const char * argv[]) {
        
        Test2 t2;
        printf(" %lu\n", sizeof(t2));
        return 0;
    }
    

    结果:

     62
    Program ended with exit code: 0
    

    参考:

    https://www.jianshu.com/p/f01fe1ef892d

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 159,286
精华内容 63,714
关键字:

内存对齐