C++ 内存空间总结

C++中的结构体所占内存空间总结

因为结构体有时候需要字节对齐。一般而言，struct 的 sizeof 是所有成员字节对齐后长度相加，而 union 的 sizeof 是取最大的成员长度。
在默认情况下，编译器为每一个变量或数据单元按其自然对界条件分配空间。一般地，可以通过下面的方法来改变默认的对界条件：
(1) 使用伪指令#pragma pack(n)，C编译器将按照n个字节对齐。
(2) 使用伪指令#pragma pack()，取消自定义字节对齐方式。

字节对齐的细节和编译器实现相关，但一般而言，满足以下3个准则：
(1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除。
(2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节。
(3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节。
需要注意的是，基本类型是指前面提到的像 char、short、int、float、double 这样的内置数据类型。如果一个结构体中包含另外一个结构体成员，那么此时最宽基本类型成员不是该结构体成员，而是取基本类型的最宽值。
1、 默认对齐方式

#include 

using namespace std;

typedef struct
{
	char ch1;   // 1个字节，成员的大小为1，所以不用补齐，结构体大小就是1的整数倍，为3
	char ch2;
	char ch3;
}A1;

typedef struct
{
	int num;   // 5个字节，补齐为8字节
	char ch;
}A2;

typedef struct
{
	char a; // 1字节+补齐
	int b; // 8字节
	long long  c;  // 16字节 
	char d; // TotalSize= 17 ,但是不是成员c的倍数，所以+7 == 24,才是8的倍数
}A3;

typedef struct
{
	long num; // 4字节 
	char * name; // 8字节
	short int data; // 10字节
	char ha; // 11字节+补齐，为12字节
}A4;

int main(void)
{
	cout << "A1: " << sizeof(A1) << endl; // A1: 3
	cout << "A2: " << sizeof(A2) << endl; // A2: 8
	cout << "A3: " << sizeof(A3) << endl; // A3: 24
	cout << "A4: " << sizeof(A4) << endl; // A4: 12

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2、位域方式

#include 

using namespace std;

typedef struct
{
	char ch1:1; // 1+3+3=7位，所以只占1个字节
	char ch2:3;
	char ch3:3;
}A1;

typedef struct
{
	char ch1 : 5; // 5+5+3=13位，所以只占2个字节
	char ch2 : 5;
	char ch3 : 3;
}A2;

typedef struct
{
	char ch1 : 5; // 5+5+4=14位，却占3个字节 【注意】
	char ch2 : 5;
	char ch3 : 4;
}A3;

typedef struct
{
	char ch1 : 7; // 7+7=14位，却只占2个字节 【注意】
	char ch2 : 7;
}A4;

typedef struct
{
	char ch1 : 1; // 偏移1个字节
	int a : 16; // 偏移5个字节
	int b : 16; // 偏移5个字节，因为16+16<=32，未超出“int”，所以只补齐为8个字节
}A5;

typedef struct
{
	char ch1 : 1; // 偏移1个字节
	int a : 16; // 偏移5个字节
	int b : 17; // 偏移5个字节，因为16+17>33，超出“int”，所以补齐为12个字节
}A6;

int main(void)
{
	cout << "A1: " << sizeof(A1) << endl; // A1: 1
	cout << "A2: " << sizeof(A2) << endl; // A2: 2
	cout << "A3: " << sizeof(A3) << endl; // A3: 3
	cout << "A4: " << sizeof(A4) << endl; // A4: 2
	cout << "A5: " << sizeof(A5) << endl; // A5: 8
	cout << "A6: " << sizeof(A6) << endl; // A6: 12

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

3、使用#pragma pack(n)

#include 
using namespace std;

#pragma pack(1) // 要求补齐为“1”的倍数
typedef struct
{
	char ch1; // 1+0 字节，由于自定义了对齐方式，所以不再补齐
	int b; // 5 字节
	int a; // 9 字节
}A1;

#pragma pack(2) // 要求补齐为“2”的倍数
typedef struct
{
	char ch1; // 1+1 字节，由于自定义了对齐方式，补齐为"2"的倍数
	int b; // 6 字节
	int a; // 10 字节
}A2;

#pragma pack(4)  // 要求补齐为“4”的倍数
typedef struct
{
	char ch1; // 1+3 字节，由于自定义了对齐方式，补齐为"4"的倍数
	int b; // 8 字节
	int a; // 12 字节
}A3;

int main(void)
{
	cout << "A1: " << sizeof(A1) << endl; // A1: 9
	cout << "A2: " << sizeof(A2) << endl; // A2: 10
	cout << "A3: " << sizeof(A3) << endl; // A3: 12

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

注意当 #pragma pack 的 n 值等于或超过所有数据成员长度的时候，这个 n 值的大小将不产生任何效果。

4、结构体中有结构体成员

#include "stdafx.h"
#include 

using namespace std;

typedef struct
{
	short i; // 2字节

	char c; // 3字节，由于后一个数据为int类型，故补齐为4字节
	int j; // 8字节

	int k; // 12字节
}A1;

/*
如果结构体中的成员又是另外一种结构体类型时应该怎么计算呢？只需把其展开即可。
但有一点需要注意，展开后的结构体的第一个成员的偏移量应当是被展开的结构体中最大的成员的整数倍。
结构体stu5的成员ss.c的偏移量应该是4，而不是2。
*/
typedef struct
{
	short i; // 2+2字节 （因为展开后的结构体的第一个成员的偏移量为4）

	struct
	{
		char c; // 5字节，补齐为8
		int j; // 12字节
	}A;

	int k; // 16字节

}A2;

int main(void)
{
	cout << "A1: " << sizeof(A1) << endl; // A1: 12
	cout << "A2: " << sizeof(A2) << endl; // A2: 16

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

C++中的类所占内存空间总结

类所占内存的大小是由成员变量（静态变量除外）决定的，成员函数（这是笼统的说，后面会细说）是不计算在内的。
示例如下：
(一)

class CBase 
{ 
}; 

sizeof(CBase)=1；

1
2
3
4
5
6

为什么空的类什么都没有是 1 呢？

c++要求每个实例在内存中都有独一无二的地址。空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的 sizeof 为 1。
(二)

class CBase 
{ 
	int a; 
	char p; 
}; 

sizeof(CBase)=8;

1
2
3
4
5
6
7
8

记得对齐的问题，这点和 struct 的对齐原则很像！int 占 4 字节，char 占一字节，补齐 3 字节。
(三)

class CBase 
{ 
public: 
	CBase(void); 
	virtual ~CBase(void); 
    
private: 
	int  a; 
	char *p; 
}; 

sizeof(CBase)=12

1
2
3
4
5
6
7
8
9
10
11
12
13

C++ 类中有虚函数的时候有一个指向虚函数的指针，在 32 位系统分配指针大小为 4 字节。无论多少个虚函数，只有这一个指针，4 字节。注意一般的函数是没有这个指针的，而且也不占类的内存。
(四)

class CChild : public CBase 
{ 
public: 
	CChild(void); 
	~CChild(void); 

virtual void test();
	private: 
	int b; 
}; 

sizeof(CChild)=16；

1
2
3
4
5
6
7
8
9
10
11
12
13

可见子类的大小是本身成员变量的大小加上父类的大小。其中有一部分是虚函数表的原因，父类子类共享一个虚函数指针。
(五)

#include 

class A {};

class B : public A
{
	virtual void fun() = 0;
};

// 共有继承，共用虚函数指针，没有虚基指针
class C : public B
{
};

class D : public A, public B
{
};

int main()
{
	std::cout << "sizeof(A)" << sizeof(A) << std::endl;
	std::cout << "sizeof(B)" << sizeof(B) << std::endl; // 空类A(0) + 虚函数指针(4)
	std::cout << "sizeof(C)" << sizeof(C) << std::endl; // 与B共用虚函数指针(4)
	std::cout << "sizeof(D)" << sizeof(D) << std::endl; // A(1+3) + 与B共用虚函数指针(4)

	return 0;
}

/*
输出：
sizeof(A)1
sizeof(B)4
sizeof(C)4
sizeof(D)8
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

共有继承，共用虚函数指针，没有虚基指针。
(六)

#include

/*  虚继承与继承的区别：
	1.多了一个虚基指针
	2.虚基类位于派生类存储空间的最末尾
	3.不会共用虚函数指针
*/

class A
{
	char a[3];
public:
	virtual void fun1() {};
};

// 测试一：单个虚继承，不带虚函数
class B : public virtual A
{
	char b[3];
};

// 测试二：单个虚继承，带自己的虚函数
class C : public virtual A
{
	char c[3];
public:
	virtual void fun2() {};
};

// 测试三：双重继承
class D : public virtual C
{
	char d[3];
public:
	virtual void fun3() {};
};

int main()
{
	std::cout << sizeof(A) << std::endl; // 8
	std::cout << sizeof(B) << std::endl; // 8(A) + 8(B)【8 == (3+1)+虚基指针】
	std::cout << sizeof(C) << std::endl; // 8(A) + 12(C)【12 == (3+1)+自己的虚函数指针+虚基指针】
	std::cout << sizeof(D) << std::endl; // 8(A) + 12(C) + 12(D)
	return 0;
}

/*
输出：
8
16
20
32
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

注意，虚继承的时候 A B C D 四个类不仅不会共享虚基类指针，也不会共享虚函数指针，要和普通继承区分开来。
具体分析如下：

 class A size(8):
      +---
 0    | {vfptr}
 4    | a
      | <alignment member> (size=1)
 8    +---
 
 class B size(16):
      +---
 0    | {vfptr}
 4    | {vbptr}
 8    | b
      | <alignment member> (size=1)
      +---
      +--- (virtual base A)
12    | a
      | <alignment member> (size=1)
16    +---
    
 class C size(20):
      +---
 0    | {vfptr}
 4    | {vbptr}
 8    | b
      | <alignment member> (size=1)
      +---
      +--- (virtual base A)
12    | {vfptr}
16    | a
      | <alignment member> (size=1)
20    +---    
 
 class D size(32):
      +---
 0    | {vfptr}
 4    | {vbptr}
 8    | c
      | <alignment member> (size=1)
      +---
      +--- (virtual base A)
12    | {vfptr}
16    | a
      | <alignment member> (size=1)
      +---
      +--- (virtual base B)
20    | {vfptr}
24    | {vbptr}
28    | b
      | <alignment member> (size=1)
32    +---

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

• 虚表（vftable）
• 虚函数指针（vfptr）
• 虚基指针（vbptr）

总 结

空的类是会占用内存空间的，而且大小是 1，原因是 C++ 要求每个实例在内存中都有独一无二的地址。

（一）类内部的成员变量：
普通的变量：是要占用内存的，但是要注意对齐原则（这点和 struct 类型很相似）。
static 修饰的静态变量：不占用内容，原因是编译器将其放在全局变量区。
（二）类内部的成员函数：
普通函数：不占用内存。
虚函数：有一个指向虚函数的指针，要占用 4 个字节，用来指定虚函数的虚拟函数表的入口地址。所以一个类的虚函数所占用的地址是不变的，和虚函数的个数是没有关系的。
（三）虚继承与继承的区别：
多了一个虚基指针。
虚基类位于派生类存储空间的最末尾。
不会共用虚函数指针。