✨个人主页： Yohifo
🎉所属专栏： C++修行之路
🎊每篇一句： 图片来源

• Love is a choice. It is a conscious commitment. It is something you choose to make work every day with a person who has chosen the same thing.
  • 爱是一种选择。这是一种有意识的承诺。这是你选择每天与一个选择同样事情的人一起工作的东西。

---

@[toc]

---

📘前言

C++中的内存管理机制和C语言是一样的，但在具体内存管理函数上，C语言的malloc已经无法满足C++面向对象销毁的需求，于是祖师爷在C++中新增了一系列内存管理函数，即 new 和 delete
著名段子：如果你还没没有对象，那就尝试 new 一个吧

---

📘正文

==将内存分成不同区域是为了实现更好的管理==，比如在我们现实生活中，一幢房子会被分为客厅、厨房、卧室、卫生间等区域，目的是为了使我们生活更加方便、空间利用更加合理，计算机也是如此，更何况是空间非常珍贵的内存，因此在我们的==程序中存在不同内存分区==

📖内存分布

==在程序中存在五大分区，各个分区各司其职，比如我们耳熟能详的栈区、堆区、静态区==

🖋️五大分区

栈区：

• 栈又称做堆栈，用于存储非静态局部变量、函数参数、返回值等，栈的空间是向下增长的

内存映射段：

• 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信

堆区：

• 堆用于程序运行时动态内存分配，堆是可以上增长的，我们的动态内存就是在堆上申请的

数据段：

• 数据段中负责存储全局数据和静态数据

代码段：

• 代码段中存储可执行的代码/只读常量

==注意：== 内存中还存在内核空间，但我们普通用户代码无法读写

🖋️图解

通过具体代码展示具体分布如下

📖重温

先简单回顾下C语言中的动态内存管理

🖋️malloc/calloc/realloc

==C语言提供了三种动态内存管理函数==

malloc：申请指定大小的空间

int* pi = (int*)malloc(sizeof(int) * 1);	//申请一个整型
double* pd = (double*)malloc(sizeof(double) * 2);	//申请两个浮点型
char* pc = (char*)malloc(sizeof(char) * 3);	//申请三个字符型

==注意：== malloc申请的空间都是未初始化的，即被编译器置为随机值

calloc：将申请的空间初始化为 0

int* pi = (int*)calloc(1, sizeof(int));	//申请一个整型
double* pd = (double*)calloc(2, sizeof(double));	//申请两个个浮点型
char* pc = (char*)calloc(3, sizeof(char));	//申请三个字符型

==注意：== calloc参数列表与malloc不同，同时calloc申请的空间会被初始化为 0

realloc：对已申请的空间进行扩容

int* tmp = (int*)realloc(pi, sizeof(int) * 10);	//将 pi 扩容为十个整型
pi = tmp;	//常规使用方法

==注意：== 我们要对所有的申请函数进行空指针检查，预防野指针问题

堆区的空间由我们管理，编译器很信任我们，因此我们要做到==有借有还，再借不难==

==凡是动态开辟的空间，用完后都需要释放==

🖋️free

C语言提供的空间释放函数是free

free(tmp);	//此时tmp指向pi扩容后的空间，释放tmp就行了
tmp = pi = NULL;	//两者都需要置空
free(pd);
pd = NULL;
free(pc);	//只要是动态开辟的，都需要通过 free 释放
pc = NULL;

==注意：== 只有动态开辟的空间才能使用 free，同时==一块空间不能释放两次==。我们在 free 后通常会把指针置空

关于C语言动态内存管理更多细节可以看看这篇文章：《C语言动态管理》
这里就不再阐述

==C语言 中管理函数只能对内置类型使用，而 C++ 中存在很多自定义类型，常规 malloc 等函数无能为力==

📖初识

出现了新的关键字：new 和 delete，它们也有很多形式和使用细节

🖋️new

使用：

int* pi = new int;	//申请一个整型
double* pd = new double(3.14);	//申请一个浮点型并初始化为 3.14
char* pc = new char[5] {'H', 'e', 'l', 'l', 'o'};	//申请五个字符型，并分别初始化为 Helloc

注意：

• new 与 malloc等不同，不需要进行空指针检查，也不需要进行类型转换
• new 的使用极其简单

特点：

• new可以用于自定义类型
• 动态开辟时，会调用自定义类型的构造函数

//假设存在日期类
Date* ptr = new Date[5];	//申请五个日期类，这些类都在堆上

下面来看看C++中的内存释放函数

🖋️delete

形式：

• delete 指针
• delete[] 指针

使用：

• ==C语言中的 free 可以用于释放所有动态申请函数，而 C++ 不行，申请与释放需要配套使用==

int* pi = new int;
delete pi;	//直接释放

double* pd = new double[5];
delete[] pd;	//释放五次

Date* ptr = new Date[5];
delete[] ptr;	//释放五次，即调用五次日期类的析构函数

注意：

• 需要配套使用，new int 搭配 delete，而 new int[] 需要搭配 delete[]

特点：

• delete可以用于自定义类型
• 调用销毁时，会先调用自定义类型的析构函数

🖋️特点

C语言和C++动态内存管理函数的最大区别是： ==是否会调用自定义类型的构造函数和析构函数==

C语言明显不会，毕竟那时候还没有这些概念，而 C++ 作为面向对象的语言，调用构造与析构函数是必然的

C语言中的申请函数不能通过C++的释放函数进行释放，同理C++的申请空间也不能通过C语言的释放函数进行释放，比如下面这些情况是不合理的，可能引发问题

int* cPi = (int*)malloc(sizeof(int));
delete cPi;	//不合理的操作

int* cppPi = new int;
free(cppPi);	//这样也是不合理的

Date* ptr = new Date;
free(ptr);	//此时会报错，因为 free 并不会调用析构函数

==切记，申请与释放要配套使用==

📖探究

为何C++中的动态内存管理函数能做到调用构造和析构函数呢？

• 这是因为我们也是调用的其他函数，正是得益于C++中的封装

🖋️封装实现

new 和 delete 是用户进行动态内存申请和释放的 操作符，它们在实现时会去调用真正的全局函数 operator new 与 operator delete，具体调用情况如下所示：

new 与 new []

• new 调用 operator new
• new [] 调用 operator new[]

delete 与 delete []

• delete 调用 operator delete
• delete [] 调用 operator delete[]

==注意：== operator new[] 最终是调用 operator new，operator delete[] 最终也是调用 operator delete
所以严格来说，operator new 和 operator delete 才是我们探讨的主角

🖋️代码展示

先来看看 operator new 的代码实现

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。
*/
void* __CRTDECLoperatornew(size_tsize)_THROW1(_STDbad_alloc)
{
	// try to allocate size bytes
	void* p;
	while ((p = malloc(size)) == 0)
		if (_callnewh(size) == 0)
		{
			// report no memory
			//如果申请内存失败了，这里会抛出bad_alloc类型异常
			staticconststd::bad_allocnomem;
			_RAISE(nomem);
		}
	return(p);
}
//代码源自：比特教育科技 https://www.bitejiuyeke.com/index

可以看到，其实 operator new 就是通过对 malloc 的封装实现的，不过进行了改进，当对象为自定义类型时，会去调用它的构造函数，并且当开辟失败时，会抛出异常

再来看看 operator delete 的代码实现

/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void* pUserData)
{
	_CrtMemBlockHeader* pHead;
	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
	if (pUserData == NULL)
		return;
	_mlock(_HEAP_LOCK); /* block other threads */
	__TRY
		/* get a pointer to memory block header */
		pHead = pHdr(pUserData);
	/* verify block type */
	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
	_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK); /* release other threads */
	__END_TRY_FINALLY
		return;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
//代码源自：比特教育科技 https://www.bitejiuyeke.com/index

operator delete 的代码中也有 free 的影子，当释放对象为自定义类型时，会调用它的析构函数

📖new/delete 实现步骤

下面再来看看两者具体的实现步骤

🖋️内置类型

==对于内置类型来说，使用 malloc/free 和 new/delete 没什么区别==

🖋️自定义类型

==对于自定义类型，new/delete 的实现步骤如下：==

new

• 调用 operator new 申请空间
• 在申请的空间上调用构造函数

delete

• 在空间上调用析构函数
• 再调用 operator delete 释放空间

new []

• 调用 operator new[] 函数，根据数值N，调用N次 operator new 函数申请空间
• 在申请的空间上调用N次构造函数

delete []

• 在申请的空间上调用N次析构函数
• 调用 operator delete[] 函数，然后由函数再调用 operator delete 释放空间

📖定位new

定位new 是 new 的新用法

目的：

• 对已开辟而未初始化的空间进行初始化

形式：

• new(指针)构造函数

//定位new
Stack* ptr = (Stack*)malloc(sizeof(Stack));	//malloc 不会调用构造函数，此时未初始化

new(ptr)Stack();	//通过定位new初始化对象

🖋️应用场景

定位new 可以用在内存池这个项目中

• 向堆中申请一块定额空间，此时空间未初始化
• 此时就需要通过 定位new 来进行初始化
  

📖注意事项

==开辟与释放需要配对使用==

malloc/calloc/realloc 搭配 free

new 搭配 delete

new [] 搭配 delete []

---

📘总结

以上就是关于 C++ 内存管理的全部内容了，记住一点就够了：认识 new ，配对使用。

如果你觉得本文写的还不错的话，可以留下一个小小的赞👍，你的支持是我分享的最大动力！

如果本文有不足或错误的地方，随时欢迎指出，我会在第一时间改正

---

相关文章推荐
==类和对象实操==
类和对象实操之【日期类】
===============
==类和对象合集系列==
类和对象（下）
类和对象（中）
类和对象（上）
===============
==C++入门必备==
C++入门基础