C++动态内存管理（malloc和new操作符的底层关系以及区别）

我们都知道C++是在C语言的基础上拓展出来的；C语言是面向过程的高级编程语言，而C++是面向对象的高级编程语言。
C语言动态内存管理这套在C++中就有些出入，为什么这样说呢？
再讲两者区别之前，我们来简单回顾一下C语言动态内存管理和C++动态内存管理的方式：

🍁C语言：malloc/calloc/realloc/free

在C语言中的动态内存管理方式常用函数有：malloc calloc realloc free等。
前三个函数主要功能是开辟动态内存空间(堆区)，free函数功能即是释放动态内存开辟空间，防止内存泄漏。

若是对于上面提到的C语言动态内存管理函数比较陌生的小伙伴可以转站看看这篇文章，对其有详细介绍：链接: C语言动态内存管理

🍁C++：new和delete操作符

C++的动态内存管理方式是通过new和delete操作符进行管理。没错这里指代的是操作符并不是函数，C语言在使用动态管理函数时需要包含#include <stdlib.h>头文件；而在C++使用new和delete操作符时不需要包含特定的头文件。

🍂new和delete使用方法

C++对于内置类型动态开辟/销毁空间使用方法如下:

void Test1()
{
	int* ptr1 = new int;     //动态申请一个int类型的空间
	int* ptr2 = new int(10); //动态申请一个int类型的空间,并初始化为10
	int* ptr3 = new int[5];  //动态申请五个int类型的空间
	int* ptr4 = new int[5] { 1, 2, 3, 4, 5 }; //动态申请五个int类型的空间，并初始化为 1，2，3，4，5

	delete ptr1;
	delete ptr2;
	delete[] ptr3;
	delete[] ptr4;
}

注意：上面提到的在用new操作符动态开辟一个int类型空间和动态开辟五个连续int类型的空间时所对应动态释放空间时delete操作符是有严格要求的（申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[ ]和delete[ ]）

C++对于自定义类型动态开辟/销毁空间使用方法如下:

#include <iostream>

using namespace std;

class A
{
public:

	A(int a = 0):_a(a)  //构造函数
	{
		cout << "A()" << endl;
	}
	
	~A()    //析构函数
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

int main()
{
	A* ptr1 = new A;      //动态开辟1个A类型对象
	A* ptr2 = new A[4];  //动态开辟4个A类型对象
	
	delete ptr1;
	delete[] ptr2;
	
	return 0;
}

在上面运行结果可以看到在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数

看到这里不妨会想到delete操作符使用的疑问：是先销毁对象，再调用析构函数？还是先调用析构函数，再清理动态开辟对象空间？

举个简单例子，创建一个栈类：

#include <iostream>
using namespace std;

class Stack
{
public:

	Stack()
	{
		cout << "Stack()" << endl;
		_a = new int[4];
		_top = 0;
		_capacity = 4;
	}
	
	// 其他函数实现...

	~Stack()
	{
		cout << "~Stack()" << endl;
		delete _a;
		_top = _capacity = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	Stack p1;
	Stack* p2 = new Stack;

	delete p2;
	return 0;
}

可以看到输出结果为两个构造和两个析构，对于其中一个构造和析构的不用多说，创建p1对象时会调用其默认构造函数，程序结束时编译器会调用p1这个对象的析构，在这里主要用来对照。

1. p1对象是直接在栈上开辟的，因此p1对象创建之初就会调用其默认构造函数，默认构造函数会直接对p1对象中的int* _a进行开辟一块连续的int类型空间，这块空间在堆区
2. p2为Stack类的类型的指针，在栈上；p2指针所指向的对象空间是属于堆区的(也就是new出来的)，new操作符开辟的自定义类型会直接掉用其默认构造函数，因此p2指针指向的对象的成员中int* _a会再向堆区开辟一块连续的int类型空间

在了解了直接创建一个对象或是new一个对象后默认构造函数是如何工作原理后，我们再回到刚刚问题：
delete操作符：是先销毁对象，再调用析构函数？还是先调用析构函数，再清理动态开辟对象空间？

答案是：delete操作符会先调用析构函数，再清理动态开辟对象空间

上面例子中可以看到，p2指针指向的对象是在堆区开辟的，若是delete操作符直接先释放了p2指针指向的对象空间的话，那么该对象的成员指向的连续的int类型空间如何找到？还能再调用析构函数吗？答案是否定的，这样只会造成内存泄漏。正确的调用顺序是先调用析构函数，先释放该对象的成员指向的连续的int类型空间，然后才能将p2指向的对象进行销毁。

🍁operator new与operator delete函数

相信很多小伙伴第一眼看到operator new与operator delete这两个家伙的时候脑海里面都会想起一个词运算符重载。也不怪第一次见到这两个家伙的小伙伴会这样想，这样取名字真的很误导人，但是没有办法C++祖师爷创建的我们也不好说什么。

这两个家伙其实并不是new和deletd操作符的运算符重载，它们是函数。

做个区分：new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数

先来看看使用方法：

🍂perator new与operator delete使用方法及原理

int main()
{
	int* ptr1 = (int*)operator new(sizeof(int));
	operator delete(ptr1);
	
	return 0;
}

看到这里的小伙伴是否有点懵，这个不是和malloc和free函数的用法一模一样的吗？对比起来还没有malloc和free函数简便，名字倒是复杂很多。

在这里operator new 和operator delete函数和malloc和free函数使用方法是一模一样的，但是两者间却是有藕断丝连般的关系。

先来看看operator new 和operator delete函数底层实现：

//operator new：该函数实际通过malloc来申请空间
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	// try to allocate size bytes
	void *p;
	while ((p = malloc(size)) == 0)
	if (_callnewh(size) == 0)
	{
	// report no memory
	// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
	static const std::bad_alloc nomem;
	_RAISE(nomem);
	}
	return (p);
}

//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)

可以看到operator new 和operator delete函数底层是调用malloc和free函数进行工作的，为什么要搞这么复杂呢？

我们都知道C++是兼容C语言的，关于动态内存管理这块对于C++来说，若是自己重新去开辟一套属于自己的原理或是方法，这个过程难免会比较艰辛，于是C++便沿用了C语言的动态内存管理方式，但是C++是面向对象的编程语言，C语言是面向过程的编程语言，对于动态内存管理这块还是需要改进的，这便有了operator new 和operator delete函数。

malloc：malloc函数申请动态内存空间失败时会直接返回NULL

operator new：该函数通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则抛异常

operator new 和operator delete函数其实就是malloc和free函数的封装，前者对动态内存空间申请失败后会抛异常，后者只会返回NULL。

🍂底层关系

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，malloc和
free是C语言的动态内存管理函数。

int main()
{
	int* ptr1 = new int;

	delete ptr1;

	return 0;
}

在VS2022反汇编下可以看到：

1. new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
2. operator new函数底层是通过malloc来申请空间，operator delete函数底层是通过free来释放空间的

再来看看new T[N] 和 delete[ ]底层原理：

int main()
{
	int* ptr = new int[10];

	delete[] ptr;

	return 0;
}

1. new int[10]在底层调用operator new[ ]全局函数来申请空间，delete[ ]在底层通过operator delete[ ]全局函数来释放空间
2. operator new[ ]函数底层是通过operator new来申请空间，operator delete[ ]函数底层是通过operator delete来释放空间的
3. operator new函数底层是通过malloc来申请空间，operator delete函数底层是通过free来释放空间的

由此上面关系可以定义为：

new操作符原理是调用operator new函数；而operator new函数又是malloc函数的封装，因此operator new函数底层调用的是malloc函数。

new T[N]原理是调用operator new[ ]函数；而operator new[ ]函数又会调用operator new函数，operator new函数底层最终调用malloc函数。

delete操作符原理是调用operator delete函数；而operator delete函数又是 free函数的封装，因此operator delete函数底层调用的是free函数。

delete[ ]原理是调用operator delete[ ]函数；而operator delete[ ]函数又会调用operator delete函数；operator delete函数底层最终调用free函数进行空间释放。

以上提到的关系，对于操作符还是函数都有自己的一套流程，因此强烈建议：
new与delete配套使用；new T[N]与delete[ ]配套使用；malloc函数与free函数配套使用；

关系不能乱套！关系不能乱套！关系不能乱套！重要事情说三遍！！！

对于乱搭乱套，可能不会出现问题，此次没有问题不代表次次都侥幸，搬起石头砸自己就不好了。

🍁malloc、free函数与new、delete操作符区别

#include <iostream>
#include <stdlib.h>

using namespace std;

int main()
{	
	int* ptr1 = (int*)malloc(sizeof(int));
	if (ptr1 == nullptr)
	{
		perror("malloc fail\n");
		exit(-1);
	}

	int* ptr2 = new int;

	free(ptr1);
	delete ptr2;
	

	return 0;
}

上述代码分别是：C语言malloc函数动态开辟一个int类型的空间 和C++new操作符动态内存开辟一个int的类型的空间。

可以看到，从用法上malloc函数的操作更加细节（例如：类型强转，字节计算），若不是长时间去使用可能都会造成语法忘记出错；new操作符用法倒是简便许多。

当然两者间不仅仅只是用法上不同，下面我们来看看还有哪些不一样的地方：

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在释放空间前会调用析构函数完成空间中资源的清理

以上就是该篇文章所要介绍的全部内容啦，感谢大家的支持！！！！！！