C++ --- new与delete

new与delete

一、回顾
- 1.malloc
- 2.calloc
- 3.realloc
- 4.free
二、new与delete的特殊之处
- - （1）
  - （2）
三、new与delete的底层原理
四、总结

一、回顾

在C语言阶段我们学习了动态内存管理：malloc,calloc,realloc,free。

1.malloc

malloc --- 向堆上申请一块空间，其空间大小由我们自己定义大小，申请成功返回此连续空间的起始地址，否则返回空指针。

cpp 复制代码

	//使用malloc创建一个10个空间大小的整型数组。
	int* ptr1 = (int*)malloc(sizeof(int) * 10);

调试观察：

如上图，动态申请了一个10个空间大小的整型数组。

2.calloc

calloc --- 在malloc的基础上多了一个初始化的作用，会将所指向空间元素初始化成0。

cpp 复制代码

	//使用calloc创建一个10个空间大小的整型数组。
	int* ptr2 = (int*)calloc(10, sizeof(int));

调试观察：

对比malloc申请出来的空间，多进行了一步初始化成0的操作。

3.realloc

realloc --- 用法是扩容，跟上面两个不同，有两种情况。

（1）原地扩容，若要扩容的空间之后紧挨着的空间允许扩容操作，此就是原地扩容

（2）异地扩容，若要扩容的空间之后紧挨着的空间不支持扩容操作，则会在堆上重新找一块大小相等的空间，将原空间内的数据拷贝进新空间，再将旧空间释放，返回新空间的起始地址。

图解如下：

4.free

free的作用是将我们动态申请的空间不用了之后释放掉。

将上述两个动态开辟的空间给释放掉：

cpp 复制代码

	free(ptr1);
	ptr1 = nullptr;   

	free(ptr2);
	ptr2 = nullptr;

秉承写代码优良作风，一般free之后将其指针变量置为空，以防出现野指针。

但由于C++引入了类这种自定义类型，上述三种普遍针对内置类型的动态开辟空间的方法就不再适用了，所以C++语言新引入了动态开辟空间的方法：new，delete。

二、new与delete的特殊之处

new和delete是一对关键字，作用就是动态开辟空间和释放空间。

第一个场景：内置类型和自定义类型的对象创建场景。

对于内置类型示例代码如下：

cpp 复制代码

	//1、使用new创建一个整型变量
	int* ptr1 = new int;         // --- 没有初始化
	int* ptr2 = new int(1);      // --- 初始化操作

	//2、使用new创建一个10个空间大小的整型数组
	int* ptr3 = new int[10];                     // --- 没有初始化
	int* ptr4 = new int[10] {1, 2, 3, 4, 5};     // --- 初始化操作

	//同样不要忘记手动释放内存空间
	delete ptr1;      //普通变量释放内存空间
	delete ptr2;
	delete[] ptr3;    //数组释放内存空间需要加上[]
	delete[] ptr4;

对于自定义类型示例代码如下：

cpp 复制代码

class A
{
public:
	A()
	{
		cout << "调用无参构造函数！！！" << endl;
	}

	A(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{
		cout << "调用有参构造函数！！！" << endl;
	}

	~A()
	{
		cout << "调用析构函数！！！" << endl;
	}

private:
	int _year = 2000;
	int _month = 1;
	int _day = 1;
};

//3、使用new创建一个类类型的对象
	A* a1 = new A();
	A* a2 = new A(2025, 5, 13);
	
	//同样不要忘记手动释放内存空间

运行结果：

上图运行结果就是new与delete的特别之处：

（1）

new会先去堆上动态开辟空间，再调用构造函数。
delete会先调用析构函数，再释放内存空间。

图解：

另一个场景，即malloc，new申请失败的场景。

对于malloc申请失败示例代码如下：

cpp 复制代码

	//1.malloc申请失败的场景
	int* ptr1;
	for (int i = 0; i < 1000; i++)
	{
		ptr1 = (int*)malloc(sizeof(int) * 1024 * 1024);  //1024 = 2^10，此处为4M大小
		if (ptr1)
		{
			cout << i << "->" << ptr1 << endl;
		}
		else
		{
			break;
		}
	}

运行结果：

malloc申请失败后返回的为0（检查返回值是否为NULL），代表程序正常结束。

对于new申请失败示例代码如下：

cpp 复制代码

	//2.new申请失败的场景
	int* ptr2;
	for (int i = 0; i < 1000; i++)
	{
		ptr2 = new int[1024 * 1024];
		cout << i << "->" << ptr2++ << endl;
	}

运行结构：

new申请失败返回为3，不为0，说明其返回机理和malloc不同，程序非正常结束。

（2）

new的申请失败机理是抛异常，这点与malloc的申请失败截然不同。

下面演示一点如何处理异常（了解即可，后续会详细讲解）：

上述new的代码是在一个全局函数Test_3里面，所以直接对Test_3进行异常处理。

cpp 复制代码

int main()
{
	//Test_1();
	//Test_2();
	try
	{
		Test_3();
	}
	catch(const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

运行结果：

处理异常后程序返回0，正常结束，并且打印了一句"bad allocation"，这句话意思就是空间分配异常。

三、new与delete的底层原理

new与delete的底层原理其实就是重载的两个全局函数，operator new 与 operator delete，这两个在其主要作用。

对于operator new：

观察会发现一个熟悉的身影malloc，所以别看new听起来高大上，它的底层开辟内存空间的实现依旧是使用的malloc，如此这般麻烦操作就是为了将new改变成抛出异常，所以刚刚抛出异常的那一句话就是从这里出来的。

同理operator delete的释放内存空间的实现使用的就是free。

汇编层验证（基于对自定义类型）：

new的功能先调用operator new这个全局函数来开辟内存空间，再去调用构造函数。

delete的功能先调用析构函数清理资源，再调用operator delete这个全局函数来释放内存空间。

其实还有一组全局函数operator new[ ]和operator delete[ ]，此全局函数就是对于N个对象空间的申请与释放。

（1）operator new[ ]：在operator new[]中实际调用operator new函数完成N个对象空间的申请，并且在申请的空间上执行N次构造函数。

（2）operator delete[ ]：在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间。

四、总结

（1）对于内置类型：

new与malloc这写动态开辟空间的函数功能上没有区别，只是malloc申请失败会返回NULL，而new会抛出异常。

（2）对于自定义类型：

malloc这样的函数就无法使用了，而new的本质是先调用operator new这个全局函数来开辟内存空间，再去调用构造函数；delete的本质是先调用析构函数清理资源，再调用operator delete这个全局函数来释放内存空间。

（3）不同的动态开辟内存空间要配套使用，也就是使用malloc开辟空间，则使用free释放空间；使用new开辟空间，则使用delete释放空间；使用new开辟了一块连续的数组空间，则使用delete[ ]释放空间，一定不要乱配对和错误使用。