计算结构体大小（内存对齐原则）struct、union、class

这篇博客详细的介绍结构体的大小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