这篇博客详细的介绍结构体的大小sizeof：union、struct、class。

一、不同数据类型所占的内存大小：

二、union联合体的结构体大小

1、关注点：
（1）联合体的大小为所有成员变量中所占字节数最大的；
（2）当联合体中有数组时，一方面要保证空间能够存储这个数组的大小，另一方面要保证最终的结果是最大数据类型的整数倍。
2、示例（不同的情况）
示例①

union A {       //所占内存大小double a;   //8int b;      //4char c;     //1
};
//按照联合体的计算规则：sizeof（A）=8

示例②

union B {       //所占内存大小char s[9];    //9int b;        //4double c;     //8
};
//按照联合体的计算规则：sizeof（B）=16

示例③

union B {       //所占内存大小long f;     //4char b[3];  //3char c;     //1
};
//按照联合体的计算规则：sizeof（B）=4

示例④

union B {       //所占内存大小long f;      //4char b[5];   //5char c;      //1int c[7];     //28
};
按照联合体的计算规则：sizeof（B）= 28

三、struct结构体的大小

1、关注点：
（1）struct的大小为最后一个成员的偏移量加上最后一个成员的大小，并且最终的结果要是所有数据成员大小的最小倍数；
（2）第一个成员的偏移量为0。
\qquad第二个成员的偏移量=第一个成员的偏移量+第一个成员的大小。
（3）若struct中有数组，最终结构体的大小是按数组的数据类型的整数倍，而不是看整个数组。

2、示例（不同的情况）
示例①

struct A {       //偏移量double a;    //0int b;       //0+8=8char c;      //8+4=12
};
最终结构体的大小：sizeof(A)=12+1=13->16
变为16的原因：因为13不是int(4)、double(8) 的整数倍，所以最终的结果是16.

示例②

struct A {          //偏移量char a[9];      //0int b;          //0+9=9->12(因为9不是int（4）的整数倍，所以变为12)double c;       //12+4=16
};
最终结构体的大小：sizeof(A)=16+8=24

示例③

struct A {          //偏移量long a;      //0char b[3];   //0+4=4   所以变为12)char c;      //4+3=7
};
最终结构体的大小：sizeof(A)=7+1=8

示例④

struct A {          //偏移量long a;         //0char b[5];      //0+4=4    char c;         //4+5=9int z[7];       //9+1=10->12 (因为10不是int（4）的整数倍，所以变为12)
};
最终结构体的大小：sizeof(A)=12+28=40

四、struct嵌套，计算大小

1、关注点：
（1）需要展开计算；
（2）嵌套里面的结构体：
\qquad展开后的求得的第一个的偏移量=嵌套结构体中所有元素的最小整数倍。
\qquad接下来就按照三中的方法计算。
（3）嵌套结构体的大小是所有成员的最小整数倍，这里的所有成员是展开后的单个数据元素的整数倍，而不是将嵌套的结构体看成一个整体。

2、示例（不同的情况）
示例①

struct A {          //偏移量short a;         //0struct S {   char c;      //0+2=2->4 (因为2不是int（4）的整数倍，所以变为4）int j;       //4+1=5->8}s;double k;       //8+4=12->16
};最终结构体的大小：sizeof(A)=16+8=24

示例②

struct A {          //偏移量struct S {   char c;      //0int j;       //0+1=1->4}s;double k;       //4+4=8
};最终结构体的大小：sizeof(A)=8+8=16

示例③

struct A {          //偏移量double i;       //0short m;        //0+8=8struct S {   char c;      //8+2=10->12char j;       //12+1=13int w;        //13+1=14->16}s;char a;           //16+4=20char b;           //20+1=21char d;           //21+1=22char e;           //22+1=23char f;           //23+1=24
};最终结构体的大小：sizeof(A)=24+1=25->32 (8的倍数)

示例④

struct A {          //偏移量struct S {   char c;      //0char j;       //0+1=1int w;        //1+1=2->4}s;char a;           //4+4=8char b;           //8+1=9char d;           //9+1=10char e;           //10+1=11char f;           //11+1=12
};最终结构体的大小：sizeof(A)=12+1=13->16 (4的倍数)

五、class类的大小

1、关注点：
（1）按照结构体对齐原则；
（2）class含有成员变量和成员函数：计算大小的时候只与成员变量有关。
\qquad与成员函数和静态成员无关，即普通成员函数、静态成员函数、静态成员变量。对类的大小没有影响。
（3）虚函数对类的大小有影响，因为虚表指针的影响。在32位系统占4个字节，64位系统占8个字节。
（4）多个虚函数也只算一个的影响。

2、示例（不同的情况）
示例①

class A {          //偏移量
public:static int s;   //静态成员变量不占内存的大小const int c;    //0int v;          //0+4=4char a;         //4+4=8 A() {}          //不占~A() {}         //不占
};
最终类的大小：sizeof(A) = 8 + 1 = 9->12 (4的倍数)

示例②
含有虚函数的情况（32位系统，指针占4个字节）：

class A {          //偏移量
public:static int s;   //静态成员变量不占内存的大小const int c;    //0int v;          //0+4=4char a;         //4+4=8 A() {}          //不占~A() {}         //不占virtual void f1() {}   //8+1=9 ->12virtual void f2() {}  //只算一个
};
最终类的大小：sizeof(A) = 12 + 4 = 16

含有虚函数的情况（64位系统）：

class A {          //偏移量
public:static int s;   //静态成员变量不占内存的大小const int c;    //0int v;          //0+4=4char a;         //4+4=8 A() {}          //不占~A() {}         //不占virtual void f1() {}   //8+1=9 ->16（必须是8的倍数）virtual void f2() {}  //只算一个
};
最终类的大小：sizeof(A) = 16 + 8 = 24