【C++从练气到飞升】07---内存管理

青旅半醒 2024-04-22 04:30 10阅读 0赞

![b69c619d7f3544e9a958e6682bc0ab19.png][]

🎈**个人主页**：[库库的里昂][Link 1]  
✨**收录专栏**：[C++从练气到飞升][C]  
🎉**鸟欲高飞先振翅，人求上进先读书****。**

![266ea5a5363a43b5a383205fbb8308ea.jpeg][]

**目录**

一、 C/C++内存分布

二、 C语言中动态内存管理方式

三、 C++中动态内存管理

1. new/delete操作内置类型

2. new和delete操作自定义类型

四、 operator new与operator delete函数

五、 new和delete的实现原理

1. 内置类型

2. 自定义类型

六、 定位new表达式(placement-new)

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

八、 内存泄漏

1. 什么是内存泄漏,内存泄漏的危害

3. 如何检测内存泄漏

4. 如何避免内存泄漏

总结一下:

--------------------

⛳️推荐

> 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。[点击跳转到网站][Link 2]

### 一、 C/C++内存分布 ###

int globalVar = 1;
    static int staticGlobalVar = 1;
    void Test()
    {
     static int staticVar = 1;
     int localVar = 1;
     int num1[10] = { 1, 2, 3, 4 };
     char char2[] = "abcd";
     const char* pChar3 = "abcd";
     int* ptr1 = (int*)malloc(sizeof(int) * 4);
     int* ptr2 = (int*)calloc(4, sizeof(int));
     int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
     free(ptr1);
     free(ptr3);
    }

![1059dc750e374a61bc6e4dd3080511d9.png][]

【说明】

*  **栈**又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
 *  **内存映射段**是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
 *  **堆**用于程序运行时动态内存分配，堆是可以上增长的。
 *  **数据段**–存储全局数据和静态数据。
 *  **代码段**–可执行的代码/只读常量

![e1dc4680e0b54aeda2881e71e4f22400.png][]

### 二、 C语言中动态内存管理方式 ###

在学习C语言时，学到了几个内存管理函数malloc、[realloc][]、calloc、free，下面通过一道题目来复习一下：

void Test ()
    {
    int* p1 = (int*) malloc(sizeof(int));
    free(p1);
    // 1.malloc/calloc/realloc的区别是什么？
    int* p2 = (int*)calloc(4, sizeof (int));
    int* p3 = (int*)realloc(p2, sizeof(int)*10);
    // 这里需要free(p2)吗？
    free(p3 );
    }

*  malloc/calloc/realloc的区别？

1.  是否会对申请的内存空间进行初始化  
    函数malloc不能初始化所分配的内存空间，函数calloc() 会将所分配的内存空间中的每一位都初始化为零，所以可以认为collac<==>malloc+memset。
2.  功能上的区别  
    malloc与calloc用来动态分配内存空间，而realloc则是对给定的指针所指向的内存空间进行扩大或者缩小。

*  上述代码free(p3)前需要加上一段代码：free(p2)吗？

答案是不需要的，因为p2是collac出来的，collac和malloc出来空间的都可以realloc，而realloc分为原地扩容和异地扩容，若是原地扩容时，p2和p3是一样的一块空间所以释放一次就可以。若是异地扩容，p3不等于p2，但是realloc异地扩容会开辟一块新空间，然后把p2那块空间上的数值拷贝过去，再释放p2。走而言之无论原地扩容还是异地扩容表明都不需要free(p2)，加上反而会出错

![8429fda6461d40799e7ff03134126967.png][]

### 三、 C++中动态内存管理 ###

[C语言内存管理][C 1]方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，就比如：malloc 不会调用构造函数。free 不会调用析构函数（重要的），因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理

#### 1. new/delete操作内置类型 ####

void Test()
    {
      // 动态申请一个int类型的空间
      int* ptr4 = new int;
      delete ptr4;
      
      // 动态申请一个int类型的空间并初始化为10
      int* ptr5 = new int(10);
      delete ptr5;
      
      // 动态申请10个int类型的空间
      int* ptr6 = new int[3];
      delete[] ptr6;
        
      // 动态申请10个int类型的空间，并对前5个进行初始化
      int* ptr7 = new int[10]{1,2,3,4,5};
      delete[] ptr7;
     ————————————————————————————————————————————————————————————————————
     下面这两种写法是错误的
      int* ptr7 = new int[5](1,2,3,4,5);
      int* ptr7 = new int[5]={1,2,3,4,5};
    }

![d8a27246067347808f03729075b75963.png][]

🌟new对内置类型来说，和C语言是一样的（C++兼容C语言，内置类型的动态申请，用法简化了但是功能保持一致），只是纯粹的开空间，对于动态申请到的空间，**不进行人为初始化，里面的数据存的都是随机值**。

🌟若是想完成动态申请并**初始化，类型后面+()**，动态**申请多个连续空间，类型后面+\[\]**，如果要**对这多个连续的空间初始化，可以在\[\]的后面+\{\}**（注意是+\{\}，而非+（）这是错误的写法如上述代码报错图片），\{\}里面是初始化的数据，当然**可以只初始化一部分**（int\* ptr7 = new int\[10\]\{1,2,3,4,5\};），**后面默认补0**。

🌟**注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new\[\]和delete\[\]**，**时刻谨记匹配起来使用**

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

**注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会：**

#include<iostream>
    using namespace std;
    class A
    {
    public:
    	A(int a = 0)//全缺省
    		: _a(a)
    	{
    		cout << "A():" << this << endl;
    	}
    	~A()
    	{
    		cout << "~A():" << this << endl;
    	}
    private:
    	int _a;
    };
    int main()
    {
    	//动态申请一个A类型的空间，调用一次构造函数
    	A* p2 = new A;
    	delete p2;
    	//动态申请一个A类型的空间并初始化为3，调用一次构造函数
    	A* p3 = new A(3);
    	delete p3;
    	//动态申请三个A类型的空间，调用三次构造函数
    	A* p4 = new A[3];
    	//调用三次析构函数
    	delete[] p4;
    	return 0;
    }

![5be50eab0b414fa5b6b106944d39b285.png][]

由上图可以明显的看到new开空间且调用了构造函数，delet调用了析构函数且释放空间

![1c5387711ad14b92bd0e74b589f64094.png][]

🌟**注意**：对于初始化，我们可以人为的去写入，比如上述代码中的A\* p3 = new A(3); 在括号里写入了一个3，因为new会调用构造函数，所以这个3就被构造函数作为形参用来初始化类中成员变量\_a，但是对于上述代码A\* p4 = new A\[3\];只是开了3个空间并没有人为写入数值，所以new只会开3个空间，然后调用构造函数（上述代码是具有全缺省的默认构造函数），所以会用缺省值来初始化成员变量\_a；

A aa1(1);
    	A aa2(2);
    	A* p6 = new A[3]{aa1,aa2,1};
    	A* p7 = new A[3]{ A(1),A(2),1};
    	//A* p8 = new A[3]{ 1,2 };//错误的写法

🌟**如果类没有默认构造函数，在使用new动态申请空间的时候，一定要进行人为的传值初始化。对于动态申请的自定义类型数组，如果该自定义类型没有默认构造，则需要进行人为的初始化，并且申请了几块空间就要初始化几个，不像动态申请的内置类型数组，可以只初始化前面一部分，后面默认是0**

![d730b9c3a6944f2691b5e54665f2041b.png][]

🌟以链表为例对比C和C++：

//以C为例：
    struct List_Node
    {
    	int _val;![在这里插入图片描述](https://img-blog.csdnimg.cn/0dfde4d32d904e56b062349e6a8dbca1.png)
    
    	struct List_Node* _next;
    };
    List_Node* BuyListNode(int x)
    {
    	List_Node* tmp = (List_Node*)malloc(sizeof(List_Node));
    	if (nullptr == tmp)
    	{
    		perror("malloc");
    		exit(-1);
    	}
    
    	tmp->_val = x;
    	tmp->_next = nullptr;
    }
    int main()
    {
    	List_Node* p1 = BuyListNode(1);
    	List_Node* p2 = BuyListNode(2);
    	List_Node* p3 = BuyListNode(3);
    	List_Node* p2 = BuyListNode(4);
    	List_Node* p3 = BuyListNode(5);
    	
    	return 0;
    }
    ——————————————————————————————————————————————————————————————————————————————
    //以C++为例：
    struct ListNode
    {
    	ListNode* _next;
    	int _val;
    	ListNode(int val = 0)
    		:_val(0)
    		,_next(nullptr)
    	{
    
    	}
    };
    int main()
    {
    	
    	ListNode* n1 = new ListNode(1);
    	ListNode* n2 = new ListNode(2);
    	ListNode* n3 = new ListNode(3);
    	ListNode* n4 = new ListNode(4);
    	ListNode* n5 = new ListNode(5);
    
    	return 0;
    }

通过上述代码的对比，可以明显的看出C语言中要想完成链表，要单独分装一个函数来进行动态内存申请，检查合法性，初始化；但是对于C++而言可以直接new一块空间，同时还能调用构造函数和析构函数

### 四、 operator new与operator delete函数 ###

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

/*
    operator new：该函数实际通过malloc来申请空间，当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 实际也是通过malloc来申请空间**，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。**operator delete 最终是通过free来释放空间的**；可以明显的道operator new ，operator delete，malloc，free都是在堆上申请释放空间，**但也有区别operator new会对错误抛异常**。

### 五、 new和delete的实现原理 ###

#### 1. 内置类型 ####

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：**new/delete申请和释放的是单个元素的空间**，**new\[\]和delete\[\]申请的是连续空间**，而且new在申请空间失败时会抛异常，malloc会返回NULL

#### 2. 自定义类型 ####

*  new的原理  
    调用operator new函数申请空间  
    在申请的空间上执行构造函数，完成对象的构造

![5bc8d7e7d324454496c584b0453903e9.png][]

delete的原理  
在空间上执行析构函数，完成对象中资源的清理工作  
调用operator delete函数释放对象的空间

![06ff7f7747dc44178c621f6fa22570bb.png][]

*  new T\[N\]的原理  
    调用operator new\[\]函数，在operator new\[\]中实际调用operator new函数完成N个对象空间的申请  
    在申请的空间上执行N次构造函数
 *  delete\[\]的原理  
    在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理  
    调用operator delete\[\]释放空间，实际在operator delete\[\]中调用operator delete来释放空间

### 六、 定位new表达式(placement-new) ###

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

**使用格式：**

*  new (place\_address) type或者new (place\_address) type(initializer-list)
 *  place\_address必须是一个指针，initializer-list是类型的初始化列表

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

Stack* pst1 = (Stack*)operator new(sizeof(Stack));
    //pst1->~Stack(4);--->这种是不允许的
    new (pst1)Stack(4);//显式调用构造函数---定位new
    pst1->~Stack();//显式调用析构函数
    operator delete(pst1);
    return 0;

### 七、 malloc/free和new/delete的区别 ###

malloc/free和new/delete（简化用法，解决动态申请的自定义类型的初始化问题）的区别：

**共同点是：**

*  都是**从堆上申请空间**，并且**需要用户手动释放**。

**不同点是：**

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

### 八、 内存泄漏 ###

#### 1. 什么是内存泄漏,内存泄漏的危害 ####

*  什么是内存泄漏：

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

*  内存泄漏的危害：

长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死

void MemoryLeaks()
    {
       // 1.内存申请了忘记释放
      int* p1 = (int*)malloc(sizeof(int));
      int* p2 = new int;
      
      // 2.异常安全问题
      int* p3 = new int[10];
      
      Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
      
      delete[] p3;
    }

2 .内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：

*  堆内存泄漏(Heap leak)  
    堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

*  系统资源泄漏  
    指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放  
    掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

#### 3. 如何检测内存泄漏 ####

在vs下，可以使用windows操作系统提供的\_CrtDumpMemoryLeaks() 函数进行简单检测，该函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息

#include<iostream>
    using namespace std;
    int main()
    {
    	int* p = new int[10];
    	// 将该函数放在main函数之后，每次程序退出的时候就会检测是否存在内存泄漏
    	_CrtDumpMemoryLeaks();
    	return 0;
    }

![1989b475bc614a1fbf5e633a07f0a1ad.png][]

因此写代码时一定要小心，尤其是动态内存操作时，一定要记着释放。但有些情况下总是防不胜防，简单的可以采用上述方式快速定位下。如果工程比较大，内存泄漏位置比较多，不太好查时一般都是借助第三方内存泄漏检测工具处理的。

*  在linux下内存泄漏检测：[linux下几款内存泄漏检测工具][linux]
 *  在windows下使用第三方工具：[VLD工具说明][VLD]
 *  其他工具：[内存泄漏工具比较][Link 3]

#### 4. 如何避免内存泄漏 ####

*  工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
 *  采用RAII思想或者智能指针来管理资源。
 *  有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
 *  出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

### **总结一下:** ###

内存泄漏非常常见，解决方案分为两种：

*  事前预防型。如智能指针等。
 *  事后查错型。如泄漏检测工具

[b69c619d7f3544e9a958e6682bc0ab19.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/dc2f8dedc6934fdc88fc033590b3d45f.png
[Link 1]: https://blog.csdn.net/m0_68662723
[C]: http://t.csdnimg.cn/eQPZG
[266ea5a5363a43b5a383205fbb8308ea.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/8123079005754fb49e02e5b298e84676.jpeg
[Link 2]: https://www.captainbed.cn/wxz
[1059dc750e374a61bc6e4dd3080511d9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/837f1cade3a3467ea0e563f9c193d46f.png
[e1dc4680e0b54aeda2881e71e4f22400.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/dd54b7fe0929465d968c58f060d491fc.png
[realloc]: https://so.csdn.net/so/search?q=realloc&spm=1001.2101.3001.7020
[8429fda6461d40799e7ff03134126967.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/63c23ecd681b443b9b0c422a89e1c9ee.png
[C 1]: https://so.csdn.net/so/search?q=C%E8%AF%AD%E8%A8%80%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86&spm=1001.2101.3001.7020
[d8a27246067347808f03729075b75963.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/b2acf0fdef9349f3a90a6f30a154ee5f.png
[5be50eab0b414fa5b6b106944d39b285.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/f8568da360264cf4b95f1d8c34761762.png
[1c5387711ad14b92bd0e74b589f64094.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/86baef8a88634b7f9f539d12390ebb56.png
[d730b9c3a6944f2691b5e54665f2041b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/d16090c9f998486494b53b00289232f3.png
[5bc8d7e7d324454496c584b0453903e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/d72db972203447cea1b815268ef046d8.png
[06ff7f7747dc44178c621f6fa22570bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/c1f6751e40bc4f01902935e8142a35a4.png
[1989b475bc614a1fbf5e633a07f0a1ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/d82a39fc3e4b4dee8eebc695f0c09e92.png
[linux]: https://blog.csdn.net/gatieme/article/details/51959654
[VLD]: https://blog.csdn.net/GZrhaunt/article/details/56839765
[Link 3]: https://www.cnblogs.com/liangxiaofeng/p/4318499.html