C++内存管理方式--通过new和delete操作符进行动态内存管理详细讲解

本文链接：https://blog.csdn.net/m0_49619206/article/details/133161368

一、new和delete的出现解决了malloc和free的什么缺陷？

在C语言中malloc和free已经能够实现创建空间和释放空间，但是对于自定义类型有一个不好之处在于：
自定义类型的初始化需要调用构造函数，自定义类型的销毁需要调用析构函数进行资源清理，但是malloc和free不能调用类当中的成员函数，所以导致使用malloc去申请空间的时候，申请的空间里的内容是随机值，用free去释放空间的时间容易导致内存泄漏（介绍如下），因为调用不了析构函数。
因此在C++中为了自定义对象有合适的初始值并且能正常销毁，出现了两种方式：new/delete

二、new和delete的语句介绍以及特点

通过new和delete操作符进行动态内存管理

先举例malloc申请空间和释放空间的语句：

int* mptr = (int*)malloc(sizeof(int));
free(mptr);

new/delete操作内置类型
申请释放单个空间：new --> delete
申请释放连续空间：new[~] --> delete[]
例如：
申请一个整型类型空间

int* ptr = new int;
delete ptr;

申请空间+初始化：初始值为10 -->4 byte

int* ptr2 = new int(10);
delete ptr2;

连续空间：包含10个元素 --> 40 byte 内容为随机值

int* arr = new int[10];
//释放连续空间
delete[] arr;	//方括号内不用填写

自定义类型：new：申请空间+调用构造函数进行空间内容的初始化
malloc申请时，没有调用A的构造函数
new申请时，会调用构造函数进行一个初始化

free释放时：没有调用A的析构函数
delete释放时：调用A的析构函数完成资源清理+空间释放

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "资源清理" << endl;
		cout << "~A()" << endl;
	}
private:
	int _a = 10;
};

void test()
{
	A* mpa = (A*)malloc(sizeof(A));
	free(mpa);

	//自定义类型：new：申请空间+调用构造函数进行空间内容的初始化
	A* pal = new A;
	//自定义类型：delete：调用析构完成资源清理+空间释放
	delete pal;

	//自定义类型：连续空间
	//new[]：申请空间+调用N此构造函数
	A* arrA = new A[100];
	//delete[]：调用N次析构+空间释放
	delete[] arrA;
}


int main()
{
	test();
	return 0;
}

在这里插入图片描述

当自定义类型初始化需要传入参数时：
则写成如下形式：
类型指针指针变量 = new 类型（参数列表） --> 调用带参构造
不能使用带参的构造进行多个对象的空间申请和初始化

class A
{
public:
	A(int a)
	:_a(a);
	{}
	~A()
	{
		cout << "资源清理" << endl;
		cout << "~A()" << endl;
	}
private:
	int _a = 10;
};

void test()
{

	//类型指针 指针变量 = new 类型 --> 调用默认构造（无参，全缺省）
	A* pal = new A;
	//类型指针 指针变量 = new 类型（参数列表） --> 调用带参构造
	A* pa2 = new A(10);
	//自定义类型：delete：调用析构完成资源清理+空间释放
	delete pal;
	delete pa2;

	//自定义类型：连续空间
	//new[]：申请空间+调用N此构造函数
	//不能使用带参的构造进行多个对象的空间申请和初始化
	A* arrA = new A[3];
	//delete[]：调用N次析构+空间释放
	delete[] arrA;
}


int main()
{
	test();
	return 0;
}

operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

operator new不是new的运算符重载函数
operator delete不是delete的运算符重载函数

operator new和operator delete是全局函数
它们的使用方式类似于malloc、free

int* ptr = (int*)operator new(sizeof(int));
int* ptr2 = (int*)malloc(sizeof(int));

operator delete(ptr);
free(ptr2);

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。
operator delete: 该函数最终是通过free来释放空间的

内置类型和自定义类型使用new和delete操作符时调用的全过程分析如下：

内置类型：
new: operator new --> malloc

int* ptr = new int;

delete：operator delete --> free

delete ptr;

new[]：operator new[] --> operator new --> malloc

int* ptr2 = new int[];

delete[]：operator delete[] --> operator delete --> malloc

delete[] ptr2;

自定义类型:
new: operator new --> malloc --> 构造

A* pa = new A;

delete：析构 --> operator delete --> free

delete pa;

new[]：operator new[] --> operator new --> malloc --> N次构造

A* pa2 = new A[10];

delete[]：N次析构 --> operator delete[] --> operator delete --> free

delete[] pa2;

定位new表达式

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

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

自定义A类：

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

在测试函数中先进行空间申请，malloc申请出来的空间是随机值没有进行初始化


// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
A* p1 = (A*)malloc(sizeof(A));

再初始化已有的空间
new定位表达式：new（指针）类型（参数列表）–> 显示调用构造函数

 // 注意：如果A类的构造函数是全缺省或者无参时，此处可以不需要传参。即后面的（10）可以省略不写
new(p1)A(10);

释放空间时，先调用析构函数，完成资源清理。

p1->~A();

再进行释放动态开辟出来的空间

free(p1);

三、malloc/free和new/delete的区别

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