c++动态内存管理

文章目录

前言

想必大家对c语言的动态内存分配并不陌生，忘了的小伙伴也可以看看我的这篇文章C语言动态内存分配

c语言的动态内存分配由于有些地方用起来比较麻烦同时检查错误的机制不适合c++，因此c++引入new/delete操作符进行内存管理，下面我们来深入探讨c++为什么要引入new/delete

用法上

对内置类型

new/delete同样是在堆区申请释放空间
new和delete申请释放单个元素的空间，new[]和delete[]申请释放一块连续的空间，new与delete匹配，new[]与delete[]匹配。new后面直接跟类型，不需要强制类型转换。简单来说new/delete用于单个对象，new[]/delete[]用于多个对象。
对内置类型没有什么区别，new操作符和malloc函数一样，不会对空间初始化，唯一的不同在后面的底层原理会介绍

#include<iostream>usingnamespace std;intmain(){int* p1 =(int*)malloc(sizeof(int));int* p2 =(int*)malloc(sizeof(int)*10);//new后面跟动态申请的类型int* p3 =newint;//动态申请一个int型空间int* pp3 =newint(1);//动态申请一个int型空间并初始化为1//动态申请10个int型空间并初始化int* p4 =newint[10]{1,2,3};free(p1);free(p2);delete p3;delete pp3;delete[] p4;}

对自定义类型

对自定义类型那就有很大的区别了，new一个自定义对象，在申请空间后还会调用构造函数初始化，delete对象会先调用析构函数清理对象中的资源，然后释放空间

#include<iostream>usingnamespace std;classTest{public:Test(int data =10):_data(data){
        cout <<"Test():"<< endl;}~Test(){
        cout <<"~Test():"<< endl;}private:int _data;};intmain(){// 申请单个Test类型的空间
    Test* p1 =(Test*)malloc(sizeof(Test));free(p1);// 申请10个Test类型的空间
    Test* p2 =(Test*)malloc(sizeof(Test)*10);free(p2);// 申请单个Test类型的对象
    Test* p3 =new Test;//申请空间并调用构造函数初始化delete p3;// 申请10个Test类型的对象
    Test* p4 =new Test[10];//申请空间并调用构造函数初始化delete[] p4;return0;}

简单解释一下：对于delete操作符先调用析构函数清理对象的资源，再释放空间，这里为了演示我只写了栈的构造函数和析构函数

#include<iostream>usingnamespace std;classStack{public:Stack(int capacity =4):_capacity(capacity){int* _p =newint[capacity];
        _top =0;
        _capacity = capacity;
        cout <<"Stack()"<< endl;}~Stack(){delete[] _p;
        _top = _capacity =0;
        cout <<"~Stack()"<< endl;}private:int* _p;int _top;int _capacity;};intmain(){    
    Stack* s1=new Stack;delete s1;return0;}

delete先调用构造函数清理对象维护的堆区B的资源，然后再释放堆区A的空间

new/delete底层原理

通过汇编代码我们发现，在底层：new会调用operator new函数和Stack构造函数，而delete也会调用operator delete函数和析构函数，那么operator new和operator delete是什么函数呢？
operator new和operator delete是系统提供的两个全局函数，通过operator new申请空间，operator delete释放空间，实际上operator new也是调用malloc申请空间的，operator delete也是调用free释放空间的，那么为什么不直接用malloc和free呢？

c语言中malloc申请空间失败会返回NULL空指针，那我们检查错误的方式就是通过errno错误码，而面向对象的语言，处理错误的方式一般是抛异常，C++中也要求抛异常——try catch，

这里我简单提一下抛异常，当我们new失败后，如果不捕获异常就会抛异常

intmain(){//由于申请空间过大new失败char* p =newchar[1024u*1024u*1024u*2-1];printf("execute\n");return0;}

那我们捕获异常，new失败后编译器就会提示申请失败原因

#include<iostream>usingnamespace std;intmain(){try//检测异常{char* p =newchar[1024u*1024u*1024u*2-1];//new失败，直接跳到catch，不执行下面语句printf("execute\n");}catch(const exception& e)//捕获并处理异常{
        cout << e.what()<< endl;}return0;}

所以这就是为什么不直接使用malloc的原因，因为malloc申请空间失败不会抛异常

而operator delete也是在free函数的基础上增加了一些检查机制

C++也有operator new[]和operator delete[]，仅仅是为了和new[]和delete[]配对

重载类的专属operator new和 operator delete

operator new和operator delete是可以自己定义的，一般用于在STL中的内存池中申请空间，没学过内存池的小伙伴可以简单了解一下。
有个住在山上的少年，他每次洗澡，做饭的时候都需要跑到山下的河边接水，然后再回到山上，没天重复多次。那么可不可以在家附近建一个水池，每次用水的时候就直接从水池里面打水就行了，不需要每次都跑到山下，那么内存池就出现了。这里山下的小河可以看作堆区，而每次打水可以看作是从堆区申请空间，水池可以看作内存池，这样我们直接从堆区申请一大块空间，每次需要申请时，直接到内存池申请空间就行了，不需要每次都从堆区申请空间。

这里以双链表为例，如果没有内存池，每次创建新的节点时都需要从堆区申请空间，频繁的找操作系统申请会大大降低效率

我们直接在类里面定义operator new和operator delete，与系统提供的两个全局的函数构成重载，到时候new和delete就会调用我们定义的operator new和delete而不会调用那两个全局的函数

structListNode{
    ListNode* _next;
    ListNode* _prev;int _data;ListNode(int val =0):_next(nullptr),_prev(nullptr),_data(val){}void*operatornew(size_t n){void* p =nullptr;
        p = allocator<ListNode>().allocate(1);//allocator是STL中的内存池
        cout <<"memory pool allocate"<< endl;return p;}voidoperatordelete(void* p){
        allocator<ListNode>().deallocate((ListNode*)p,1);
        cout <<"memory pool deallocate"<< endl;}};classList{public:List(){
        _head =new ListNode;
        _head->_next = _head;
        _head->_prev = _head;}voidListPush(int val){
        ListNode* newnode =new ListNode;
        newnode->_data = val;
        ListNode* tail = _head->_prev;
        tail->_next = newnode;
        newnode->_prev = tail;
        newnode->_next = _head;
        _head->_prev = newnode;}~List(){
        ListNode* cur = _head->_next;while(cur != _head){
            ListNode* next = cur->_next;delete cur;
            cur = next;}delete _head;
        _head =nullptr;}private:
    ListNode* _head;};intmain(){
    List l;
    l.ListPush(1);
    l.ListPush(2);
    l.ListPush(3);
    l.ListPush(4);return0;}

定位new

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化

#include<iostream>usingnamespace std;classTest{public:Test(int data =10):_data(data){
        cout <<"Test():"<< endl;}~Test(){
        cout <<"~Test():"<< endl;}private:int _data;};//构造函数是不支持直接手动调用的，所以引入定位new，对已经存在的对象调用构造函数初始化，常用于内存池中的对象intmain(){//调用operator new申请空间，operator new和malloc函数用法类似
    Test* p =(Test*)operatornew(sizeof(Test));//调用构造函数初始化new(p)Test(1);//定位new，new后面接要初始化对象的地址+类型，(1)表示初始化为1//先调用析构函数
    p->~Test();//在调用operator delete释放空间operatordelete(p);return0;}

new/delete与malloc/free区别总结

共同点是：都从堆上申请空间，并需要手动释放空间，因为new/delete可以说是对malloc/free的升级，申请释放空间还是会调用malloc/free

不同点：
1、new/delete是操作符，而malloc/free是函数
2、首先是用法上的不同，malloc返回类型是void*，需要强转，而new不需要强转了，new后面直接跟类型，new也不需要计算空间大小，申请N个加[N]，new/delete配对，mew[]/delete[]配对
3、malloc失败返回NULL指针，new失败如果不catch捕获就会抛异常
4、对内置类型，new和malloc一样也不会初始化，但对自定义类型，new会先申请空间再调用构造函数初始化，delete会先调用析构函数清理对象中的资源再释放空间

内存泄漏

内存泄漏：动态申请的内存空间不使用了，又没有主动释放，就存在内存泄漏

当然不是所有的内存泄漏都有危害：

1、出现内存泄漏的进程正常结束，会将内存还给操作系统，不会有什么危害

2、但出现内存泄漏的进程非正常结束，比如僵尸进程，或是长期运行的程序，比如服务器程序，出现内存泄漏，那么危害就很大了，系统会越来越慢，甚至是卡死宕机

所以我们在new申请空间时，一定要记得delete释放空间

了解到这里我们就明白了c++为什么要引入new/delete了
1、对自定义类型，对象动态申请空间时，new/delete会自动调用构造函数/析构函数
2、new失败后抛异常，符合面向对象语言对出错的处理机制

文章到这里就结束了，希望我的文章能对你有所帮助，欢迎👍点赞 ，📝评论，🌟关注，⭐️收藏