守望者--AIR技术交流

 找回密码
 立即注册

QQ登录

只需一步,快速开始

扫一扫,访问微社区

搜索
热搜: ANE FlasCC 炼金术
查看: 2259|回复: 0
打印 上一主题 下一主题

[C++] 结构体在内存中的对齐规则

[复制链接]
  • TA的每日心情
    擦汗
    2018-4-10 15:18
  • 签到天数: 447 天

    [LV.9]以坛为家II

    1742

    主题

    2094

    帖子

    13万

    积分

    超级版主

    Rank: 18Rank: 18Rank: 18Rank: 18Rank: 18

    威望
    562
    贡献
    29
    金币
    52695
    钢镚
    1422

    开源英雄守望者

    跳转到指定楼层
    楼主
    发表于 2015-1-4 13:31:04 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
    一个结构体变量定义完之后,其在内存中的存储并不等于其所包含元素的宽度之和。

    例一:

    1.                                      #include <iostream>
    2.                                       using namespace std;
    3.                                          struct X
    4.                                          {
    5.                                               char a;
    6.                                               int b;
    7.                                               double c;
    8.                                          }S1;

    9.                                      void main()
    10.                                     {
    11.                                          cout << sizeof(S1) << endl;
    12.                                          cout << sizeof(S1.a) << endl;
    13.                                          cout << sizeof(S1.b) << endl;
    14.                                          cout << sizeof(S1.c) << endl;
    15.                                     }
    复制代码
    比如例一中的结构体变量S1定义之后,经测试,会发现sizeof(S1)= 16,其值不等于sizeof(S1.a) = 1、sizeof(S1.b) = 4和 sizeof(S1.c) = 8三者之和,这里面就存在存储对齐问题。    原则一:结构体中元素是按照定义顺序一个一个放到内存中去的,但并不是紧密排列的。从结构体存储的首地址开始,每一个元素放置到内存中时,它都会认为内存是以它自己的大小来划分的,因此元素放置的位置一定会在自己宽度的整数倍上开始(以结构体变量首地址为0计算)。    比如此例,首先系统会将字符型变量a存入第0个字节(相对地址,指内存开辟的首地址);然后在存放整形变量b时,会以4个字节为单位进行存储,由于第一个四字节模块已有数据,因此它会存入第二个四字节模块,也就是存入到4~8字节;同理,存放双精度实型变量c时,由于其宽度为8,其存放时会以8个字节为单位存储,也就是会找到第一个空的且是8的整数倍的位置开始存储,此例中,此例中,由于头一个8字节模块已被占用,所以将c存入第二个8字节模块。整体存储示意图如图1所示。

    考虑另外一个实例。例二:
    1.                                           struct X
    2.                                            {
    3.                                                 char a;
    4.                                                 double b;
    5.                                                 int c;
    6.                                             }S2;
    复制代码
    在例二中仅仅是将double型的变量和int型的变量互换了位置。测试程序不变,测试结果却截然不同,sizeof(S2)=24,不同于我们按照原则一计算出的8+8+4=20,这就引出了我们的第二原则。   原则二:在经过第一原则分析后,检查计算出的存储单元是否为所有元素中最宽的元素的长度的整数倍,是,则结束;若不是,则补齐为它的整数倍。    例二中,我们分析完后的存储长度为20字节,不是最宽元素长度8的整数倍,因此将它补齐到8的整数倍,也就是24。这样就没问题了。其存储示意图如图2所示。

    掌握了这两个原则,就能够分析所有数据存储对齐问题了。再来看几个例子,应用以上两个原则来判断。例三:
    1.                                              struct X
    2.                                               {
    3.                                                    double a;
    4.                                                    char b;
    5.                                                    int c;     
    6.                                               }S3;
    复制代码
    首先根据原则一来分析。按照定义的顺序,先存储double型的a,存储在第0~7个字节;其次是char型的b,存储在第8个字节;接下来是int型的c,顺序检查后发现前面三个四字节模块都被占用,因此存储在第4个四字节模块,也就是第12~15字节。按照第一原则分析得到16个字节,16正好是最宽元素a的宽度8的整数倍,因此结构体变量S3所占存储空间就是16个字节。存储结构如图3所示。

    例四:
    1.                                              struct X
    2.                                               {
    3.                                                    double a;
    4.                                                    char b;
    5.                                                    int c;
    6.                                                    char d;   
    7.                                               }S4;
    复制代码
      仍然首先按照第一原则分析,得到的字节数为8+4+4+1=17;再按照第二原则补齐,则结构体变量S4所占存储空间为24。存储结构如图4所示:

    例五:
    1.                                              struct X
    2.                                               {
    3.                                                    double a;
    4.                                                    char b;
    5.                                                    int c;
    6.                                                    char d;
    7.                                                    int e;
    8.                                                }S5;
    复制代码
       同样结合原则一和原则二分析,可知在S4的基础上在结构体内部变量定义最后加入一个int型变量后,结构体所占空间并未增加,仍为24。存储结构示意图如图5所示。

    例六:    如果将例五中加入的变量e放到第一个定义的位置,则情况就不同了。结构体所占存储空间会变为32。其存储结构示意图如图6所示。
    1.                                              struct X
    2.                                               {
    3.                                                   int e;
    4.                                                   double a;
    5.                                                   char b;
    6.                                                   int c;
    7.                                                   char d;
    8.                                               }S6;
    复制代码

    补充:前面所介绍的都是元素为基本数据类型的结构体,那么含有指针、数组或是其它结构体变量或联合体变量时该如何呢?    1.包含指针类型的情况。只要记住指针本身所占的存储空间是4个字节就行了,而不必看它是指向什么类型的指针。例七:
    1.                    struct X
    2.                     {
    3.                      char *a;  
    4.                     };

    5.                    struct Y
    6.                    {
    7.                      int *b;
    8.                    };

    9.                    struct Z
    10.                    {
    11.                      double *c;
    12.                    };
    复制代码

    经测试,可知sizeof(X)、sizeof(Y)和sizeof(Z)的值都为4。例八:
    1.                                     struct X
    2.                                      {
    3.                                           char a;
    4.                                           int b;
    5.                                           double c;
    6.                                       };
    7.                                       struct Y
    8.                                       {
    9.                                            char a;
    10.                                            X b;
    11.                                        };
    复制代码
      经测试,可知sizeof(X)为16,sizeof(Y)为24。即计算Y的存储长度时,在存放第二个元素b时的初始位置是在double型的长度8的整数倍处,而非16的整数倍处,即系统为b所分配的存储空间是第8~23个字节。    如果将Y的两个元素char型的a和X型的b调换定义顺序,则系统为b分配的存储位置是第0~15个字节,为a分配的是第16个字节,加起来一共17个字节,不是最长基本类型double所占宽度8的整数倍,因此要补齐到8的整数倍,即24。测试后可得sizeof(Y)的值为24。    由于结构体所占空间与其内部元素的类型有关,而且与不同类型元素的排列有关,因此在定义结构体时,在元素类型及数量确定之后,我们还应该注意一下其内部元素的定义顺序。


    本文来自:http://blog.csdn.net/liukun321/article/details/6974282



    本帖子中包含更多资源

    您需要 登录 才可以下载或查看,没有帐号?立即注册

    x
    分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友 微信微信
    收藏收藏 分享分享 支持支持 反对反对 微信
    守望者AIR技术交流社区(www.airmyth.com)
    回复

    使用道具 举报

    您需要登录后才可以回帖 登录 | 立即注册

    本版积分规则

    
    关闭

    站长推荐上一条 /4 下一条

    QQ|手机版|Archiver|网站地图|小黑屋|守望者 ( 京ICP备14061876号

    GMT+8, 2024-4-20 12:18 , Processed in 0.046163 second(s), 33 queries .

    守望者AIR

    守望者AIR技术交流社区

    本站成立于 2014年12月31日

    快速回复 返回顶部 返回列表