这篇博客详细的介绍结构体的大小sizeof：union、struct、class。
一、不同数据类型所占的内存大小：
二、union联合体的结构体大小
1、关注点：
（1）联合体的大小为所有成员变量中所占字节数最大的；
（2）当联合体中有数组时，一方面要保证空间能够存储这个数组的大小，另一方面要保证最终的结果是最大数据类型的整数倍。
2、示例（不同的情况）
示例①
union A { //所占内存大小
double a; //8
int b; //4
char c; //1
};
//按照联合体的计算规则：sizeof（A）=8
示例②
union B { //所占内存大小
char s[9]; //9
int b; //4
double c; //8
};
//按照联合体的计算规则：sizeof（B）=16
示例③
union B { //所占内存大小
long f; //4
char b[3]; //3
char c; //1
};
//按照联合体的计算规则：sizeof（B）=4
示例④
union B { //所占内存大小
long f; //4
char b[5]; //5
char c; //1
int c[7]; //28
};
按照联合体的计算规则：sizeof（B）= 28
三、struct结构体的大小
1、关注点：
（1）struct的大小为最后一个成员的偏移量加上最后一个成员的大小，并且最终的结果要是所有数据成员大小的最小倍数；
（2）第一个成员的偏移量为0。
\qquad
第二个成员的偏移量=第一个成员的偏移量+第一个成员的大小。
（3）若struct中有数组，最终结构体的大小是按数组的数据类型的整数倍，而不是看整个数组。
2、示例（不同的情况）
示例①
struct A { //偏移量
double a; //0
int b; //0+8=8
char c; //8+4=12
};
最终结构体的大小：sizeof(A)=12+1=13->16
变为16的原因：因为13不是int(4)、double(8) 的整数倍，所以最终的结果是16.
示例②
struct A { //偏移量
char a[9]; //0
int b; //0+9=9->12(因为9不是int（4）的整数倍，所以变为12)
double c; //12+4=16
};
最终结构体的大小：sizeof(A)=16+8=24
示例③
struct A { //偏移量
long a; //0
char b[3]; //0+4=4 所以变为12)
char c; //4+3=7
};
最终结构体的大小：sizeof(A)=7+1=8
示例④
struct A { //偏移量
long a; //0
char b[5]; //0+4=4
char c; //4+5=9
int 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; //0
struct 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; //0
int j; //0+1=1->4
}s;
double k; //4+4=8
};
最终结构体的大小：sizeof(A)=8+8=16
示例③
struct A { //偏移量
double i; //0
short m; //0+8=8
struct S {
char c; //8+2=10->12
char j; //12+1=13
int w; //13+1=14->16
}s;
char a; //16+4=20
char b; //20+1=21
char d; //21+1=22
char e; //22+1=23
char f; //23+1=24
};
最终结构体的大小：sizeof(A)=24+1=25->32 (8的倍数)
示例④
struct A { //偏移量
struct S {
char c; //0
char j; //0+1=1
int w; //1+1=2->4
}s;
char a; //4+4=8
char b; //8+1=9
char d; //9+1=10
char e; //10+1=11
char 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; //0
int v; //0+4=4
char a; //4+4=8
A() {} //不占
~A() {} //不占
};
最终类的大小：sizeof(A) = 8 + 1 = 9->12 (4的倍数)
示例②
含有虚函数的情况（32位系统，指针占4个字节）：
class A { //偏移量
public:
static int s; //静态成员变量不占内存的大小
const int c; //0
int v; //0+4=4
char a; //4+4=8
A() {} //不占
~A() {} //不占
virtual void f1() {} //8+1=9 ->12
virtual void f2() {} //只算一个
};
最终类的大小：sizeof(A) = 12 + 4 = 16
含有虚函数的情况（64位系统）：
class A { //偏移量
public:
static int s; //静态成员变量不占内存的大小
const int c; //0
int v; //0+4=4
char a; //4+4=8
A() {} //不占
~A() {} //不占
virtual void f1() {} //8+1=9 ->16（必须是8的倍数）
virtual void f2() {} //只算一个
};
最终类的大小：sizeof(A) = 16 + 8 = 24
