关于结构体struct的sizeof计算问题

1、一般情况

32位系统

假设有的结构：

1 2 3 4 5 6

struct  MyStruct {      double  dda1;      char  dda;      int  type; };

对结构MyStruct采用sizeof会出现什么结果呢？sizeof(MyStruct)为多少呢？也许你会这样求：

sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13

但是当在VC中测试上面结构的大小时，你会发现sizeof(MyStruct)为16。你知道为什么在VC中会得出这样一个结果吗？

其实，这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度， VC对一些变量的起始地址做了“对齐”处理。 在默认情况下，VC规定各 成员变量 存放的起始地址相对于结构的起始地址的 偏移量 必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的对齐方式(vc6.0, 32位系统 )。

类型
对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量）
Char
偏移量必须为sizeof(char)即1的倍数
int
偏移量必须为sizeof(int)即4的倍数
float
偏移量必须为sizeof(float)即4的倍数
double
偏移量必须为sizeof(double)即8的倍数
Short
偏移量必须为sizeof(short)即2的倍数

默认的对齐方式

各 成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的 字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。

下面用前面的例子来说明VC到底怎么样来存放结构的。

1 2 3 4 5 6

struct  MyStruct {      double  dda1;      char  dda;      int  type; };

为上面的结构分配空间的时候，VC根据成员变量出现的顺序和对齐方式，先为第一个成员dda1分配空间，其起始地址跟结构的起始地址相同（刚好偏移量0刚好为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；接下来为第二个成员dda分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的地方满足对齐方式，该成员变量占用sizeof(char)=1个字节；接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为9，不是sizeof(int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构的起始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：8+1+3+4=16， 刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。 所以整个结构的大小为：sizeof(MyStruct)=8+1+3+4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。

下面再举个例子，交换一下上面的MyStruct的 成员变量的位置，使它变成下面的情况：

1 2 3 4 5 6

struct  MyStruct {      char  dda;      double  dda1;      int  type; };

这个结构占用的空间为多大呢？在VC6.0环境下，可以得到sizeof(MyStruct)为24。结合上面提到的分配空间的一些原则，分析下VC怎么样为上面的结构分配空间的。（简单说明）

struct MyStruct

{

char dda;// 偏移量为0，满足对齐方式，dda占用1个字节；

double dda1;//下一个可用的地址的偏移量为1，不是sizeof(double)=8

的倍数，需要补足7个字节才能使偏移量变为8（满足对齐

方式），因此VC自动填充7个字节，dda1存放在偏移量为8

的地址上，它占用8个字节。

int type;//下一个可用的地址的偏移量为16，是sizeof(int)=4的倍

数，满足int的对齐方式，所以不需要VC自动填充，type存

放在 偏移量为16的地址上，它占用4个 字节。

所有 成员变量都分配了空间，空间总的大小为1+7+8+4=20，不是结构

的节边界数（即结构中占用最大空间的类型所占用的字节数sizeof

(double)=8）的倍数，所以需要填充4个字节，以满足结构的大小为

sizeof(double)=8的倍数。

所以该结构总的大小为：sizeof(MyStruct)为1+7+8+4+4=24。其中总的有7+4=11个字节是VC自动填充的，没有放任何有意义的东西。

2、结构体包含结构体时

如果一个结构体里同时包含结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（如struct a里有struct b,b里有char,int ,double等元素，那么b应该从8(即double类型的大小)的整数倍开始存储）。

typedef struct bb  
{  
    int id;             //[0]....[3]      表示4字节  
    double weight;      //[8].....[15]　　　　　　  
    float height;      //[16]..[19],总长要为8的整数倍,仅对齐之后总长为[0]~[19]为20，补齐[20]...[23]  
}BB;  

typedef struct aa    
{     
    int  id;         //[0]...[3]　　　　　　　　　    
    double score;     //[8]....[15]　　　　    
    short grade;    //[16],[17]　　　　　　　　    
    BB b;             //[24]......[47]　　　　　　　（因为BB内部最大成员为double,即8的整数倍开始存储）    
    char name[2]; //[48][49]  50个字节，凑六个，成为8的倍数
}AA;  


int main()  
{  
    cout<<sizeof(AA)<<" "<<sizeof(BB)<<endl;  
    return 0;  
}  

输出结果为56（补位凑成8的倍数） 24

再看一个例子：

struct s1
{
char a[8];
};

struct s2
{
double d;
};

struct s3
{
s1 s;
char a;
};

struct s4
{
s2 s;
char a; 
};
cout<<sizeof(s1)<<endl; // 8
cout<<sizeof(s2)<<endl; // 8
cout<<sizeof(s3)<<endl; // 9
cout<<sizeof(s4)<<endl; // 16;

  s1和s2大小虽然都是8，但是s1的对齐方式是1，s2是8（double），所以在s3和s4中才有这样的差异。
  所以，在自己定义结构体的时候，如果空间紧张的话，最好考虑对齐因素来排列结构体里的元素。

3、当有声明#pragma pack(n)时

上面的描述都是没有#pragma pack（n）的，都是按照自己的字节数大小进行对齐。

编译器中提供了#pragma pack(n)来设定变量以n字节对齐方式。//n为1、2、4、8、16...

n字节对齐就是说变量存放的起始地址的偏移量有两种情况：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，即该变量所占用字节数的整数倍；第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。

结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；否则必须为n的倍数。

所以在上面的代码前加一句#pragma pack(1)，

则代码输出为bb：(0~3)+(4~11)+(12~15)=16;   aa：(0~1)+(2~5)+(6~13)+(14~15)+(16~31)=32，也就是说，#pragma pack(1)就是没有对齐规则。

再考虑#pragma pack(4)，bb：(0~3)+(4~11)+(12~15)=16;    aa：(0~1)+(4~7)+(8~15)+(16~17)+(20~35)=36

4、 32位和64位系统的区别

     对齐和边界条件都和上述一样

5、联合体的sizeof

共用体表示几个变量共用一个内存位置，在不同的时间保存不同的数据类型和不同长度的变量。在union中，所有的共用体成员共用一个空间，并且同一时间只能储存其中一个成员变量的值。当一个共用体被声明时, 编译程序自动地产生一个变量, 其长度为联合中元类型（如数组，取其类型的数据长度）最大的变量长度的整数倍，且要大于等于其最大成员所占的存储空间。

union foo  
{  
char s[10];  
int i;  
} ; 


union   mm{    
  char   a;//元长度1        1  
  int   b[5];//元长度4     20  
  double   c;//元长度8     8  
  int   d[3];              12  
  }; 

foo的内存空间的长度为12，是int型的3倍，而并不是数组的长度10。若把int改为double，则foo的内存空间为16，是double型的两倍。 同理， sizeof(mm)=8*3=24；