【C++】：内存管理：C++内存分布 || C++中动态内存管理（new || delete）

📭1. C/C++内存分布

【说明】
🃏1. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的
🃏2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
🃏3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
🃏4. 数据段–存储全局数据和静态数据。
🃏5. 代码段–可执行的代码/只读常量
我们先来看下面的一段代码和相关问题

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
const char* pChar3 = "abcd";
int* ptr1 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
free(ptr1);
free(ptr3);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

🍡1. 选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？____ staticGlobalVar在哪里？____
staticVar在哪里？____ localVar在哪里？____
num1 在哪里？____
char2在哪里？____ *char2在哪里？___
pChar3在哪里？___ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____
🍡2. 填空题：
sizeof(num1) = ____
sizeof(char2) = ____ strlen(char2) = ____
sizeof(pChar3) = ____ strlen(pChar3) = ____
sizeof(ptr1) = ____
3. sizeof 和 strlen 区别？

📮2.C语言中动态内存管理方式：malloc/calloc/realloc/free

void Test ()
{
int* p1 = (int*) malloc(sizeof(int));
free(p1);
// 1.malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
// 这里需要free(p2)吗？
free(p3 );
}
1
2
3
4
5
6
7
8
9
10

【面试题】
🚈 1. malloc/calloc/realloc的区别？
🚈 2. malloc的实现原理？
glibc中malloc实现原理
glibc中malloc实现原理

🎢3. C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理
new/delete操作内置类型

void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[3];
delete ptr4;
delete ptr5;
delete[] ptr6;
}
1
2
3
4
5
6
7
8
9
10
11
12

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[ ]和delete[ ] 注意：匹配起来使用

int main()
{
	int* p2 = (int*)malloc(sizeof(int));
	// 自动计算大小，不需要强转 
	int* p3 = new int;

	int* p4 = (int*)malloc(sizeof(int)*10);
	int* p5 = new int[10];

	free(p2);
	free(p4);

	delete p3;
	delete[] p5;

	// 额外支持开空间+初始化
	int* p6 = new int(10);
	int* p7 = new int[10]{1,2,3};
	int* p8 = new int[10]{};

	return 0;
}int main()
{
	int* p2 = (int*)malloc(sizeof(int));
	// 自动计算大小，不需要强转 
	int* p3 = new int;

	int* p4 = (int*)malloc(sizeof(int)*10);
	int* p5 = new int[10];

	free(p2);
	free(p4);

	delete p3;
	delete[] p5;

	// 额外支持开空间+初始化
	int* p6 = new int(10);
	int* p7 = new int[10]{1,2,3};
	int* p8 = new int[10]{};

	return 0;
}int main()
{
	int* p2 = (int*)malloc(sizeof(int));
	// 自动计算大小，不需要强转 
	int* p3 = new int;

	int* p4 = (int*)malloc(sizeof(int)*10);
	int* p5 = new int[10];

	free(p2);
	free(p4);

	delete p3;
	delete[] p5;

	// 额外支持开空间+初始化
	int* p6 = new int(10);
	int* p7 = new int[10]{1,2,3};
	int* p8 = new int[10]{};

	return 0;
}

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}

	~A()
	{
		cout << "~A():" << this << endl;
	}

private:
	int _a;
};

struct ListNode
{
	ListNode* _next;
	int _val;

	ListNode(int val = 0)
		:_val(0)
		, _next(nullptr)
	{}
};

int main()
{
	 malloc没有办法很好支持动态申请的自定义对象初始化
	A* p1 = (A*)malloc(sizeof(A));
	p1->_a = 0;
	p1->A(1);

	 自定义类型，开空间+调用构造函数初始化
	A* p2 = new A;
	A* p3 = new A(3);

	 自定义类型，调用析构函数+释放空间
	delete p2;
	delete p3;

	A* p4 = new A[10];
	delete[] p4;

	A aa1(1);
	A aa2(2);
	A* p5 = new A[10]{ aa1, aa2 };
	delete[] p5;


	A* p6 = new A[10]{ A(1), A(2) };
	delete[] p6;

	A* p7 = new A[10]{ 1, 2 };
	delete[] p7;

	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);
	ListNode* n4 = new ListNode(4);
	ListNode* n5 = new ListNode(5);

	n1->_next = n2;
	n2->_next = n3;
	n3->_next = n4;
	n4->_next = n5;
	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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

new和delete操作自定义类型

class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
还会调用构造函数和析构函数
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A(1);
free(p1);
delete p2;
// 内置类型是几乎是一样的
int* p3 = (int*)malloc(sizeof(int)); // C
int* p4 = new int;
free(p3);
delete p4;
A* p5 = (A*)malloc(sizeof(A)*10);
A* p6 = new A[10];
free(p5);
delete[] p6;
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

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会