【C++】内存管理

目录

C/C++内存分布

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

C++内存管理方式

operator new与 operator delete函数

匹配使用的相关问题-内存泄漏:

delete与delete [ ]

malloc/free和 new/delete的区别

内存泄漏

---

C/C++内存分布

1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。

2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口 创建共享共享内存，做进程间通信。(Linux课程如果没学到这块，现在只需要了解一下)

3. 堆用于程序运行时动态内存分配，堆是可以上增长的。

4. 数据段--存储全局数据和静态数据。

5. 代码段--可执行的代码/只读常量

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

具体讲解:C语言：动态内存管理(动态内存+柔性数组讲解)_努力学c的楼下小王的博客-CSDN博客

int * p1=(int*)malloc(sizeof(int));
if(p1==NULL)
{
  perror("malloc is fail");
}
free(p1);

C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因 此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理。

注意:申请和释放单个元素的空间，使用new和delet操作符，申请和释放连续的空间，使用new[]和delete[]，注意:匹配起来使用。 也切勿使用C语言中的free或malloc等与C++中的new和delete交叉使用 否则导致结果是不确定的

operator new与 operator delete函数

注意! 此处的operator 并不是函数重载,而是库函数

operator new与 operator delete本质上是malloc和free的封装

operator new:该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回;申请空间 失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否 则抛异常。

operator delete: 该函数最终是通过free来释放空间的

operator new与 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)

---

 int main()
 {
     //申请失败会抛出异常
     int *p1 = (int *)operator new(sizeof(int *));
     
     //失败返回nullptr
     int *p2 = (int *)malloc(sizeof(int *));
     if (p2 == NULL)
     {
         perror("malloc is fail");
     }
 ​
     return 0;
 }

 // 申请空间 operator nwe -> 封装malloc
 // 调用构造函数
 A *p3 = new A;
 ​
 // 先调用析构函数,在释放p3指向的空间
 delete p3;
 ​
 // 申请空间: operator new[]-> operator new -> malloc封装
 A *p4 = new A[10];
 ​
 // 先调用10次析构函数,在释放p4指向的空间
 delete[] p4; //[]只是为了匹配

匹配使用的相关问题-内存泄漏:

由前文可知,C++中的new与delete和C中的mlloc.. 和free尽量不要交叉使用 看下列代码:

 class A
 {
 public:
     A(int a = 0)
         : _a(a)
     {
         cout << "A():" << this << endl;
     }
     ~A()
     {
         cout << "~A():" << this << endl;
     }
 ​
 private:
     int _a;
 };
 int main()
 {
     int *p1 = new int[10];
     free(p1);
 ​
     A *p2 = new A;
     free(p2);
 ​
     return 0;
 }

此处并没有报错,若是使用delete p2时,则会先调用析构函数再进行free

而此处直接使用free 释放,释放的是堆上的空间,但少调用了析构函数, 但此处也无需调用析构函数,A类中并没有额外的资源需要进行清理, 若是A类中有需要额外清理的则会导致内存泄漏如:

 class Stack
 {
 private:
     int* _a;
     int _size;
     int _capacity;
 ​
 public:
     Stack()
     {
         cout << "Stack():" << this << endl;
         _a=new int[4];
         _size=0;
         _capacity =4;
     }
 ​
     ~Stack()
     {
         cout << "~Stack():" << this << endl;
         delete[] _a;
         _size=_capacity=0;
     }
 };
 ​
 int main()
 {
     //st为自定义类型,出了函数会自动调用析构函数
     Stack st;
 ​
     //pst为指针,是内置类型,不会自动调用
     Stack* pst=new Stack;
     delete pst;
 ​
     return 0;
 }

由上图可以看出,pst必须先调用析构函数将堆中创建的空间进行销毁:

调用完析构函数后,再调用operator delete(pst):

若此时使用的是free(pst): 则导致无法调用析构函数,无法释放空间,而pst指针指向的空间被销毁,而之前通过 new 分配的内存将无法被正确释放导致内存泄漏

结论:new/malloc系列 底层实现机制有关联交叉.不匹配使用,可能有问题,也可能没问题

delete与delete [ ]

部分编译器会实现该机制或不同编译器实现机制不同

 int main()
 {
     A* p1=new A[10];
     delete[] p1;
 ​
     return 0;
 }

编译器会在头部多开4字节,存储数组元素个数,用于delete,使编译器知道要调用多少次析构函数(此处地址为p1地址-4字节):

malloc/free和 new/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在释放空间前会调用析构函数完成 空间中资源的清理

内存泄漏

什么是内存泄漏，内存泄漏的危害

什么是内存泄漏:内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。 内存泄漏的危害:长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。