【C++】内存管理

一、c/c++的内存分布

1.1 c/c++内存区域划分图

1.2 各个区域的功能

栈： 非静态局部变量 / 函数参数 / 返回值 / 函数调用建立栈帧 等等，向下增长。
堆： 按需要申请和释放空间，向上增长。
数据段： 静态区，存储全局数据和静态数据。
代码段： 常量区，可执行的 代码 / 只读常量，指令也在这里。

1.3 malloc/realloc/calloc 的区别？❗️❗️

malloc 堆上动态开辟空间
calloc 堆上动态开辟空间 + 初始化为0 （相当于malloc + memset）
realloc 针对已经有的空间进行扩容 （原地扩容或异地扩容）

---

二、new和delete

2.1 内置类型使用

int main()
{
	//c语言
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = (int*)malloc(sizeof(int) * 10);
	free(p1);
	free(p2);
	p1 = p2 = NULL;
	//c++
	int* p3 = new int;
	int* p4 = new int[10];
	delete p3;
	delete[] p4;
	p3 = p4 = nullptr;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

我们可以看到new和delete在对内置类型跟c语言的malloc和free没有区别。他们的区别体现在自定义类型上。

2.2 自定义类型使用

class A
{
public:
	A()
		: _a(0)
	{}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

int main()
{
	A* p1 = (A*)malloc(sizeof(A) * 10);
	free(p1);
	p1 = NULL;
	A* p2 = new A;
	delete p2;
	p2 = nullptr;
	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

通过调试可以发现当我们
使用new的时候会 在堆上申请空间 + 调用构造函数初始化
使用delete的时候会 调用析构函数 + 释放空间

delete 清理的是new出来的空间，如果空间里含有堆区的空间，要自己在析构函数销毁

new / delete 和 new[] / delete[] 要匹配使用

补充一点，数组的初始化可以这么写：

A* p4 = new A[5]{ 1, 2, 3, 4, 5 };
1

这里要把构造函数写成默认构造函数。

---

三、处理错误

c语言：

int main()
{
	//c语言
	int* p = (int*)malloc(sizeof(int) * INT_MAX);
	if (p == NULL)
	{
		printf("%d\n", errno);
		printf("malloc fail\n");
		exit(-1);
	}
	else
	{
		printf("%p\n", p);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在面对对象的语言一般处理错误的方式是抛异常，使用try - catch

C++

int main()
{
	try
	{
		char* p1 = new char[INT_MAX];
	}
	catch(const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

output

bad allocation

---

四、operator new 和 operator delete

其实operator new就是malloc的封装，平常判断malloc是否成功需要判断指针是否为NULL，而operator new可以直接抛异常，但不会调用构造函数初始化

而operator delete最终还是调用free，跟operator new一样，也是free的封装，可以抛异常处理错误。

operator new是new的时候变成指令自己调用的new Stack = call operator new + call Stack构造函数

---

五、定位new

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

class A
{
public:
	A(int n = 5)
	{
		_a = new int[5];
		cout << "A(int n = 5)" << endl;
	}
private:
	int* _a;
};


int main()
{
	A* a = (A*)malloc(sizeof(A));
	//new(a)A;
	new(a)A(3);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

使用场景：

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化

---

六、malloc/free和new/delete的区别❗️❗️

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：

<1> malloc和free是函数，new和delete是操作符
<2> malloc申请的空间不会初始化，new可以初始化
<3> malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
<4> malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
<5> malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
<6> 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

---

七、内存泄漏

7.1 什么是内存泄漏？

动态申请的内存如果不使用也不释放就会造成内存泄漏，造成内存的浪费

7.2 内存泄漏的危害

长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

---

---

纸上得来终觉浅，绝知此事要躬行。