new和delete用法详解

谁践踏了优雅 2024-04-22 22:17 68阅读 0赞

![b79c7021afd644b89ed99072f62a07a6.gif][]

> 本篇文章对C++中的new和delete进行详解。在讲解new和delete时，我们会对比C语言中的malloc和free，看看两者的区别和相似之点。希望本篇文章会对你有所帮助。

> **文章目录**
> 
> 一、什么是new和delete
> 
> 二、new和delete的用法
> 
> 2、1 new和delete操作内置类型
> 
> 2、2 new和delete操作自定义类型
> 
> 三、new和delete的底层实现
> 
> 3、1 new的底层实现
> 
> 3、2 delete的底层实现
> 
> 三、总结
> 
> --------------------
> 
> **?♂️ 作者：@Ggggggtm ?♂️**
> 
> **? 专栏：C++、高频面试问题 ?**
> 
> **? 标题：new和delete用法详解 ?**
> 
>  **❣️ 寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景 ❣️** ![d6b42b55acbc48c68e4ba79bae2c642e.jpeg][]

## 一、什么是new和delete ##

> 我们知道在C语言中，动态开辟内存的方法是使用：**malloc/calloc/realloc**。释放动态开辟的内存是**free**。
> 
>  在C++中，又引出了一个新玩法:**new 和 delete**。在C++中，new是用来动态开辟内存的，delete是用来释放我们所动态开辟的内存。
> 
>  了解到了new和delete的是干什么的后，这里我们又有疑问了：C语言中已经有了malloc 和 free 了，直接延续用C语言的就行了，为什么还要新出一个用法呢？带着疑问，我们接着往下看。

## 二、new和delete的用法 ##

### 2、1 new和delete操作内置类型 ###

> 在C语言中，对内置类型的动态开辟我们经常使用的函数是**malloc函数**。在C++中，我们也可以使用**new操作符**来动态申请空间。注意：**我们这里发现了malloc 和 new 的第一个区别，malloc是函数，new是一个操作符**。**当然，成对出现的free 是函数，delete 是操作符。**我们先看其实用方法的对比，代码如下：
> 
>     void Test()
>     {
>       // 动态申请一个int类型的空间
>       int* p1 = malloc(sizeof(int));
>       int* p2 = new int;
>       
>       // 动态申请一个int类型的空间并初始化为10
>       int* p3 = malloc(sizeof(int));
>       *p3=10;
>       int* p4 = new int(10);
>       
>       
>       // 动态申请10个int类型的空间
>       int* p5 = malloc(sizeof(int)*3);
>       int* p6 = new int[3];
>       
>       //释放
>       free(p1);
>       delete p2;
>     
>       free(p3);
>       delete p4;
>     
>       free(p5);
>       delete[] p6;
>     
>     }
> 
> 通过上面的使用对比，我们可以很明显的感觉到**new和delete使用起来更加方便**。因为我们在使用new动态开辟空间时，**并不需要计算所开辟空间类型的大小。因为后面跟着类型，new会自动计算出类型的大小**。
> 
> 我们还发现，new在动态开辟内存时，还可以对其进行初始化。而malloc开辟后，才可通过解引用对其进行初始化。new在动态开辟数组时，也可对其进行初始化，但是这只是C++11才开始支持的语法，用法如下：
> 
>     int* p6 = new int[10]{1,2,3};
>         delete[] p6;
> 
> 后面没有给出的值，会自动初始化为0。

> 通过上面发现，new和delete使用起来确实方便一点。但是这好像并不足以解释C++不直接延续用C语言的用法，又新出一个用法。我们接着往下看。

### 2、2 new和delete操作自定义类型 ###

> 在C语言中，malloc动态申请自定义类型空间时，并不能对其进行很好的初始化。而是申请完后，需要我们自己对其进行初始化。对其变量进行赋值或调用其构造函数，我们在平常中也很容易忽略初始化这一点。
> 
> 在C++中，使用new对自定义类型进行操作申请空间时，会**自动调用自定义类型默认的构造参数对自定义类型进行初始化**。我们可看如下实例：
> 
>     #include<iostream>
>     
>     using namespace std;
>     
>     
>     class A
>     {
>     public:
>     	A(int a = 1)
>     		:_a(a)
>     	{
>     		cout << "A ( )" << endl;
>     	}
>     
>     	A(const A& a)
>     	{
>     		cout << "A(const A& )" << endl;
>     	}
>     
>     	~A()
>     	{
>     		cout << "~A()" << endl;
>     	}
>     private:
>     	int _a;
>     
>     };
>     
>     int main()
>     {
>     	A* p1 = new A;
>     	delete p1;
>     
>     	return 0;
>     }
> 
> 其运行结果如下：
> 
> ![d70d2689d799483cb8df910dc713284e.png][]
> 
> 我们在通过调试看看到底是否对成员变量\_a进行了初始化，结果如下：
> 
> ![c5764fefabc344a3a16100999a2968e5.png][]

> 通过上面发现，还挑用了析构函数。**注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与 free不会 。**

> 我们之前学习的链表更能体现出。链表是需要动态申请节点，此时new更能体先出其优势，我们可结合下面代码一起理解：
> 
>     struct ListNode
>     {
>         int _val;
>         struct ListNode* _next;
>     
>         ListNode(int x)
>             :_val(x)
>             ,_next(NULL)
>         {}
>     };
>     
>     struct ListNode* BuyListNode(int x)
>     {
>         // 单纯开空间
>         struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
>         // 检查
>         newnode->_next = NULL;
>         newnode->_val = x;
>     
>         return newnode;
>     }
>     
>     int main()
>     {
>         struct ListNode* n1 = BuyListNode(1);
>         struct ListNode* n2 = BuyListNode(2);
>         struct ListNode* n3 = BuyListNode(3);
>     
>         // 开空间+调用构造函数初始化
>         ListNode* nn1 = new ListNode(1);
>         ListNode* nn2 = new ListNode(2);
>         ListNode* nn3 = new ListNode(3);
>     
>         return 0;
>     }

> new最主要的就是在操作自定义类型时可以去调用其构造函数对其进行初始化，malloc是做不到的。这也是C++新增用法的主要原因。
> 
> 通过上面的学习，发现new和malloc时是有点相似的，那么new的底层到底是怎么实现的呢？

## 三、new和delete的底层实现 ##

### 3、1 new的底层实现 ###

> new的底层其实就是用malloc进行实现的开辟空间，只不过是又多了一点东西。我们可结合下述代码理解一下：
> 
>     #include<iostream>
>     using namespace std;
>     
>     class A
>     {
>     public:
>     	//A(int a = 0)
>     	A(int a = 0, int b = 0)
>     		: _a(a)
>     	{
>     		cout << "A():" << this << endl;
>     	}
>     
>     	A(const A& aa)
>     		: _a(aa._a)
>     	{
>     		cout << "A(const A& aa):" << this << endl;
>     	}
>     
>     	~A()
>     	{
>     		cout << "~A():" << this << endl;
>     	}
>     
>     private:
>     	int _a;
>     };
>     
>     int main()
>     {
>     	A* p1 = (A*)malloc(sizeof(A));
>     	A* p2 = new A(1,1);
>     	free(p1);
>     	delete p2;
>     
>     	return 0;
>     }
> 
> 我们对上述代码进行调试，看其汇编代码：
> 
> ![f4af8a903dd14d449c40333d7f5ee95b.png][]
> 
> 通过上图的汇编代码，我们看到new是先去**调用了operator new函数**，**再调用了自定义类型的构造函数**。 我们再看看**operator new函数里面的具体内容，**如下：
> 
> ![02ac0b939e1a4a18b5a41007909dcce7.png][]
> 
> 通过**operator new函数**我们可以看出，new的底层确实是用的malloc进行实现的。同时，**new不用担心动态开辟空间失败，因为失败时会抛出异常**，可让用户看到。但是**malloc动态开辟空间失败后返回空指针**，这就会给我们造成很大的麻烦，同时也不宜找出错误。
> 
> ![c6e7c8c9b2594882b17ba81c8c553e60.png][]

### 3、2 delete的底层实现 ###

> delete的底层实现是通过free函数进行实现的。 我们一样结合new的底层实现给出的代码来看一下其汇编代码：
> 
> ![d56e2c12278949c0b762e717cae56899.png][]
> 
> 通过汇编，我们可看到**delete操作符**是**先调用自定义类型的析构函数**，再去调用**operator delete 函数**。我们再看**operator delete 函数**的内容。![a0393afdafb04455904ca42f1f835d2c.png][]
> 
> 我们也看到，delete函数底层是用free函数实现的。

>  通过上述两个全局函数的实现知道，**operator new 实际也是通过malloc来申请空间，**如果 
> 
> malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。**operator delete 最终是通过free来释放空间的。**

## 三、总结 ##

> 通过上面的学习后，我们总结一下new/deletehe对不同类型实现原理的区别：
> 
>  *  **对内置类型**
> 
> 1.  如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是： new/delete申请和释放的是单个元素的空间，new\[\]和delete\[\]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
> 
>  *  **对自定义类型new的原理**
> 
> 1.  调用operator new函数申请空间；
> 2.  在申请的空间上执行构造函数，完成对象的构造；
> 
>  *  **对自定义类型newT\[N\]的原理**
> 
> 1.  调用operator new\[\]函数，在operator new\[\]中实际调用operator new函数完成N个对 
>     
>     象空间的申请。
> 2.  在申请的空间上执行N次构造函数
> 
>  *  **对自定义类型delete的原理**
> 
> 1.  在空间上执行析构函数，完成对象中资源的清理工作。
> 2.  调用operator delete函数释放对象的空间。
> 
>  *  **对自定义类型delete\[\]的原理**
> 
> 1.  在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理**。**
> 2.  调用operator delete\[\]释放空间，实际在operator delete\[\]中调用operator 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在释放空间前会调用析构函数完成空间中资源的清理。

> 以上就是整个new和delete的讲解，感谢阅读ovo~

[b79c7021afd644b89ed99072f62a07a6.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/6430e7883f274bddb1afac82a52996e9.gif
[d6b42b55acbc48c68e4ba79bae2c642e.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/99d12bd747834a99af694470c0008965.jpeg
[d70d2689d799483cb8df910dc713284e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/2568471c17124dda8f6e915bba561ca8.png
[c5764fefabc344a3a16100999a2968e5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/1197947b41cf45f29a7927f3c1e0fdef.png
[f4af8a903dd14d449c40333d7f5ee95b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/872f8a6972034e94aed62a4952676f01.png
[02ac0b939e1a4a18b5a41007909dcce7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/cbbb6acce9164867b2972841446b2887.png
[c6e7c8c9b2594882b17ba81c8c553e60.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/560c185472e1492eb7938fe513ae5c55.png
[d56e2c12278949c0b762e717cae56899.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/58136984c02740b1ad587e6aa6ce2a85.png
[a0393afdafb04455904ca42f1f835d2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/a5e0b91cf7c945008693883b9dfb7648.png