[c-programming]编译器字节对齐问题-结构字段对齐问题

引子

 在csdn上看帖子
 看到Oversense (步步文)  发的“intel和微软和本公司同时出现的问题”。
 http://topic.csdn.net/t/20050224/17/3804035.html
 帖子发于2005-02-24，结于2005-03-15，共122楼。

 原帖内容如下：
  #pragma   pack(8)

  struct   s1{
  short   a;
  long   b;
  };

  struct   s2{
  char   c;
  s1   d;
  long   long   e;
  };

  #pragma   pack()

  问 
  1.sizeof(s2)   =   ?
  2.s2的s1中的a后面空了几个字节接着是d?
 答案正解 24, 3。

 这是编译器字节对齐问题，或者说pack的使用问题。我称之为结构类型的字段对齐问题。
 在帖子中redleaves详细讲解了这个问题；buptrobin提出了平台的问题，编译器问题的实验数据；之后又引发了对C,C++标准的讨论。

 阅读这篇帖子受益非浅。感谢参与讨论的每一个人。现总结形成一文作为在csdn blog上的开山之作。

Part 0 数据

 我的实验代码及后续章节中的变量说明：

 示例代码：
 #include <iostream>

 #pragma   pack(3)

 struct   s1{
 short   a;
 long   b;
 };

 struct   s2{
 char   c;
 s1   d;
 double  e;
 char f;
 };

 #pragma   pack()

 void print(int begin, int end, int signal) {
     for (int i=begin; i<end; i++) {
  std::cout<<signal<<" ";
     }
 }

 #define SIZE 6

 int main () {

     s2 s;
     int len = sizeof(s);
     std::cout<<"size of s2: "<<len<<std::endl
  <<"struct is: "<<std::endl;

   
     long pos[SIZE]={(long)&s.c, (long)&s.d.a, (long)&s.d.b, (long)&s.e , (long)&s.f , ( ((long)&s.c) + len)};

     long posC=(long)&s.c;
     long posA=(long)&s.d.a;
     long posB=(long)&s.d.b;
     long posE=(long)&s.e;
   
     int size[SIZE-1]={sizeof(s.c), sizeof(s.d.a), sizeof(s.d.b), sizeof(s.e) ,sizeof(s.f) };
     int sizeC=sizeof(s.c);
     int sizeA=sizeof(s.d.a);
     int sizeB=sizeof(s.d.b);
     int sizeE=sizeof(s.e);

     int i=0;

     for (;i<5;i++) {
  print (pos[i], pos[i]+size[i], 1) ;
  print (pos[i]+size[i], pos[i+1], 0) ;
  std::cout<<std::endl;
       
     }

 }

 变量说明
     1 #pragma pack(n)，n to be pow of 2；
     2 结构在内存中的起始位置为0；
     3 对齐参数记为k；
     4 当前字段的内存大小记为f。

 实验结果
 debian linux, g++:
 n=1
  size of s2: 16
  struct is:
  1
  1 1
  1 1 1 1
  1 1 1 1 1 1 1 1
  1
 n=2
  size of s2: 18
  struct is:
  1 0
  1 1
  1 1 1 1
  1 1 1 1 1 1 1 1
  1 0
 n=4
  size of s2: 24
  struct is:
  1 0 0 0
  1 1 0 0
  1 1 1 1
  1 1 1 1 1 1 1 1
  1 0 0 0
 n=8
  size of s2: 24
  struct is:
  1 0 0 0
  1 1 0 0
  1 1 1 1
  1 1 1 1 1 1 1 1
  1 0 0 0
 n=4 & b is changed to short type
  size of s2: 20
  struct is:
  1 0
  1 1
  1 1 0 0
  1 1 1 1 1 1 1 1
  1 0 0 0
 n=3
  t.cpp:75: warning: alignment must be a small power of two, not 3

 winXp sp2, vc 6.0:
 n=1, 2, 4 结果相同
 n=8
  size of s2: 32
  struct is:
  1 0 0 0
  1 1 0 0
  1 1 1 1 0 0 0 0
  1 1 1 1 1 1 1 1
  1 0 0 0 0 0 0 0
 n=3
  path/main.cpp(94) : warning C4086: expected pragma parameter to be '1', '2', '4', '8', or '16'  
 
 WinXp sp2, g++ in Cygwin:
 n=8时 与 vc6.0结果一致。

Part I 规则
   
    字段对齐问题的规则。
    1 当前字段的对齐参数k = n与f的 小 者（n为2，char型字段其对齐参数为sizeof(char)=1, long型字段为n=2）；
    2 当前字段的起始位置p = 当前字段对齐参数k的整数倍 (前一字段的末尾和该字段之间补空位)；
    3 整个结构的对齐参数为所有字段中 最大 的对齐参数 （那么该结构的变量如果作为其他结构的字段，那么其对齐参数就不是sizeof(该结构)和n中的小者了）；
    4 整个结构变量占有的存储空间为其对齐参数的整数倍 （会补充相应数目的空位）。
    5 自然对齐：没有规定n，那么对齐参数只有取f （但事实表明编译器往往对对齐参数都会有上限，也就是n有个默认值，是对齐参数可以取的最大值）。

Part II 平台
   
    正如刚才所说：
    但事实表明编译器往往对对齐参数都会有上限，也就是n有个默认值，是对齐参数可以取的最大值。

    对我实验的解释：
    1 在debian linux下g++实验表明
      猜测n默认为4。当n=8时，结果表明和4是一样的。

    2 WinXp sp2, vc 6.0下，根据n=3的warning
 expected pragma parameter to be '1', '2', '4', '8', or '16'
      猜测n默认为16。

    3 WinXp sp3, g++ in Cygwin 和2得到同样的结果

    关于 buptrobin(听风) 实验的分析：
    “在linux下是这样的,gcc,   同样还有solaris2.8,
    size:20
    c***aa**bbbbeeeeeeee

    不过aix5,   hp11.11的话呢,是
    size:24
    c***aa**bbbb****eeeeeeee

    tru64:
    size:32
    c*******aa******bbbbbbbbeeeeeeee”

            平台      编译器     分析结论
    情况一 solaris2.8 g++:       编译器支持n最大为4，    sizeof(long)=4
    情况二 aix5       ??:        编译器支持n最大至少为8，sizeof(long)=4
    情况三 tru64      ??:        编译器支持n最大至少为8，sizeof(long)=8

Part III 标准

    由于编译器要对c语言标准进行支持，或者说是根据c语言标准制定的。所以引发了对标准的讨论。
    这一部分的总结就在下面着段文字中。

    redleaves的回复
    “因为在C89,90,99,C++98的标准中,int的长度是会随平台不同而变化的,long的长度却始终是固定的32位.”
    “不过根据我查看标准文档,文档里说只有"plain   int"即"int"类型是随平台变化的,其它的整数类型都是定长的.”

    redleaves得到的一些推论
    “至于编译器为什么这么做,我就不得而知了.但如果64位台下long是64位,那C99中加入的long   long类型可以说是多此一举了....”
    “还有,你在tru64平台中不知道用的什么编译器.它对标准的支持是有问题的.”

    utstar对redleaves的回复
    “肯定是你理解错了。int   随平台变化没错，但是，那是指从16位到32位，而不是针对将来的64位。”
    “我在ia64,ibm，hp的64位平台都作过测试。一般64位平台遵守 LP64模型，即long和pointer类型是64位的，其他类型长度一般与原来的32位平台相同”

Part IV  是否应该关注细节

 刚接触这个问题的时候感觉挺新鲜，但感觉自己真正懂得这个细节之后，产生这样的疑问：
 是否在平时的学习过程中就有必要把这些细节抠清楚？

 真正的去研究，然后做实验，发现并没有特别深奥的东西。在学习了计算机的基础知识后，分析这样的问题并没有特别的复杂。
 没有数学的东西，没有理学的东西。纯技术的东西，工学中的问题。
 我觉的各个编译器的文档中应该有更详细的说明。

 但熟练的掌握这样的技术细节并没有坏处，尤其对于现在有点找不到研究方向的我而言。
 而且在这个过程中，锻炼了自己的动手能力及找资料的能力。

Part V 附录-帖子的内容
 37楼  redleaves   (ID最吊的网友) 

 还是我给出正确答案吧:
 如果代码:
 #pragma   pack(8)
 struct   S1{
  char   a;
  long   b;
 };
 struct   S2   {
  char   c;
  struct   S1   d;
  long   long   e;
 };
 #pragma   pack()
 sizeof(S2)结果为24.
 成员对齐有一个重要的条件,即每个成员分别对齐.即每个成员按自己的方式对齐.
 也就是说上面虽然指定了按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字节对齐)整除.这样,一共使用了24个字节.
        a         b
 S1的内存布局：11**,1111,
        c         S1.a   S1.b           d
 S2的内存布局：1***,11**,1111,****11111111

 这里有三点很重要:
 1.每个成员分别按自己的方式对齐,并能最小化长度
 2.复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度
 3.对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐

 补充一下,对于数组,比如:
 char   a[3];这种,它的对齐方式和分别写3个char是一样的.也就是说它还是按1个字节对齐.
 如果写:   typedef   char   Array3[3];
 Array3这种类型的对齐方式还是按1个字节对齐,而不是按它的长度.
 不论类型是什么,对齐的边界一定是1,2,4,8,16,32,64....中的一个.

 97楼  buptrobin   (听风)

 在linux下是这样的,gcc,   同样还有solaris2.8, 
 size:20
 c***aa**bbbbeeeeeeee

 不过aix5,   hp11.11的话呢,是
 size:24
 c***aa**bbbb****eeeeeeee

 tru64:
 size:32
 c*******aa******bbbbbbbbeeeeeeee

 看来写面试题的时候,得说明什么平台,多少位的,hoho,否则.......

Part VI 结束语
 帖子中提到了http://blog.csdn.net/wenddy112/articles/300583.aspx

 Ending & To Be Continued ... ...