class存储空间，字节对齐

首先： 以下所有试验在32位机，VC.Net2003上运行。

class的存储空间有四点需要注意。

1。默认情况下以最大储存空间变量对齐。double-8,int-4,char-1,short-2,float-4,指针-4,虚函数-4，其实

虚函数就是一个指针。以最大的对齐。存储空间必须是要对齐的字节个数的整数倍。

2。变量及虚函数的存储位置首地址必须是自身所占字节个数的整数倍。

3。可以使用#pragma pack设置要对齐的字节个数，pack()中的值只能是1,2,4,8,16，其他值无效，无效时

以第1条，最大存储空间的变量为准。并且当设置的值超过了最大变量存储字节数的时候，也设置无效，取

成员变量中最大字节数的那个为准。

4。成员变量和虚函数（包括虚拟析构函数）占存储空间，一般成员函数，静态成员函数，静态成员变量

不占存储空间。在VC.Net下，成员变量和虚函数分开计算，分别补齐。但是在c++builder里，ms是算在

一起的。所以下面这份代码在c++builder里运行估计结果会有差异。

#include  < stdio.h >

class  a{
     char     d2; // 0,7
     double     d1; // 8-15,
     int         d3; // 16-19,
     char     d4; // 20,
     short     d5; // 22-23,
     float     d6; // 24-27,31
};

class  a0{
     double     d1; // 0-7,
     char     d2; // 8,
     short     d5; // 10-11,
     char     d4; // 12,
     int         d3; // 16-19,
     float     d6; // 20-23,
};

class  a1{
     char     d2; // 0,7
     double     d1; // 8-15,
     int         d3; // 16-19,
     char     d4; // 20,
     short     d5; // 22-23,
     float     d6; // 24-27,31

    a1(){}
     ~ a1(){}
     void  fn1(){}
     virtual   void  fn2(){} // 32-35,39
};

class  a2{
     double     d1; // 0-7,
     char     d2; // 8,
     short     d5; // 10-11,
     char     d4; // 12,
     int         d3; // 16-19,
     float     d6; // 20-23,

    a2(){}
     virtual   ~ a2(){} // 24-27,
     void  fn1(){}
     virtual   void  fn2(){} // 28-31,
}; 

#pragma  pack(1)
class  a11{
     char     d2; // 0,
     double     d1; // 1-8,
     int         d3; // 9-12,
     char     d4; // 13,
     short     d5; // 14-15,
     float     d6; // 16-19,

    a11(){}
     ~ a11(){}
     void  fn1(){}
     virtual   void  fn2(){} // 20-23,
};
#pragma

#pragma  pack(2)
class  a12{
     char     d2; // 0,1
     double     d1; // 2-9,
     int         d3; // 10-13,
     char     d4; // 14-15,
     short     d5; // 16-17,
     float     d6; // 18-21,

    a12(){}
     ~ a12(){}
     void  fn1(){}
     virtual   void  fn2(){} // 22-25,
};
#pragma

#pragma  pack(4)
class  a14{
     char     d2;
     double     d1;
     int         d3;
     char     d4;
     short     d5;
     float     d6;

    a14(){}
     ~ a14(){}
     void  fn1(){}
     virtual   void  fn2(){}
};
#pragma

#pragma  pack(16) // 16这个值无效，因为所有成员变量中，最大的为double的8，超过了8无效，仍然取8
class  a116{
     char     d2; // 0,7
     double     d1; // 8-15,
     int         d3; // 16-19,
     char     d4; // 20,
     short     d5; // 22-23,
     float     d6; // 24-27,31

    a116(){}
     ~ a116(){}
     void  fn1(){}
     virtual   void  fn2(){} // 32-35,39
};
#pragma

#pragma  pack(3) // 3这个值无效，取默认double的8
class  a13{
     char     d2; // 0,7
     double     d1; // 8-15,
     int         d3; // 16-19,
     char     d4; // 20,
     short     d5; // 22-23,
     float     d6; // 24-27,31

    a13(){}
     ~ a13(){}
     void  fn1(){}
     virtual   void  fn2(){} // 32-35,39
};
#pragma

class  b
{
     char     d1;
     int      d2;
     short    d3;
};

class  b0
{
     char     d1;
     short    d2;
     char     d3;
};

class  b1
{
     short    d1;
     char     d2;
};

#pragma  pack(4) // 设置无效，因最大的为short的2，设置4无效，仍然取2
class  b14
{
     short    d1;
     char     d2;
};
#pragma

int  _tmain( int  argc, _TCHAR *  argv[])
{
     char *    pInt;
    printf( " sizeof(char)=%d " , sizeof ( char )); // 1
    printf( " sizeof(double)=%d " , sizeof ( double )); // 8
    printf( " sizeof(int)=%d " , sizeof ( int )); // 4
    printf( " sizeof(short)=%d " , sizeof ( short )); // 2
    printf( " sizeof(float)=%d " , sizeof ( float )); // 4
    printf( " sizeof(char*)=%d " , sizeof (pInt)); // 4

    printf( " sizeof(a)=%d " , sizeof (a)); // 32
    printf( " sizeof(a0)=%d " , sizeof (a0)); // 24
    printf( " sizeof(a1)=%d " , sizeof (a1)); // 40
    printf( " sizeof(a2)=%d " , sizeof (a2)); // 32

    printf( " sizeof(a11)=%d " , sizeof (a11)); // 24
    printf( " sizeof(a12)=%d " , sizeof (a12)); // 26
    printf( " sizeof(a14)=%d " , sizeof (a14)); // 28
    printf( " sizeof(a116)=%d " , sizeof (a116)); // 40
    printf( " sizeof(a13)=%d " , sizeof (a13)); // 40

    printf( " sizeof(b)=%d " , sizeof (b)); // 12
    printf( " sizeof(b0)=%d " , sizeof (b0)); // 6
    printf( " sizeof(b1)=%d " , sizeof (b1)); // 4
    printf( " sizeof(b14)=%d " , sizeof (b14)); // 4


     return   0 ;
}

 

以上结构是在32位机，VC.Net2003下的结果。

如果是在TC3.0上的话，由于tc是16位编译器，结果会不一样。

在tc里char-1,int-2,short-2,float-4,double-8，指针-2。所有均为紧凑对齐，没有字节对齐。即相当于pack(1)。

具体结构，大家可以自行试验。

在linux下用g++编译后结构也不同：结果如下

sizeof(char)=1
sizeof(double)=8
sizeof(int)=4
sizeof(short)=2
sizeof(float)=4
sizeof(char*)=4

sizeof(a)=24
sizeof(a0)=24
sizeof(a1)=28
sizeof(a2)=28

sizeof(a11)=24
sizeof(a12)=26
sizeof(a14)=28
sizeof(a116)=28
sizeof(a13)=28

sizeof(b)=12
sizeof(b0)=6
sizeof(b1)=4
sizeof(b14)=4

可见在g++中，不会跟double的对齐，而是统一跟4对齐。由b,b0,b1也可以看出g++也是和最大成员变量看齐

唯一区别就是g++中最大的是4，而VC.Net中最大的为8。

至于vc.net编译的时候显示的warning中说pack中的值可以为16，就不知道怎么回事了？

难道有占16个字节的基本类型？