C++内存管理

内存管理

注意：

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

2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。

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

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

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

---

C++内存管理方式

• 先回顾一下C语言中动态内存管理方式：malloc/calloc/realloc和free

  • calloc和malloc的区别

    calloc会初始化，相当于，malloc+memset，按字节初始化，空间每个字节都初始化为0

  • realloc扩容：可能原地扩容可能异地扩容

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

new和delete

用法：

1. 对于内置类型

//动态申请int和4个int数组
//new 后面跟类型
int *p1=new int;
int *p2=new int[4]//申请了4个int
int *p3=(int*)malloc(sizeof(int));
int *p4=(int*)malloc(sizeof(int)*4);
delete p1;//释放单个
delete[] p2;//释放数组
free(p3);
free(p4);
p1=nullptr;p2=nullptr;p3=nullptr;p4=nullptr;
// malloc/free 和 new/delete对于内置类型没有本质区别，new和delete看起来会比较简洁

//p1:动态申请一个int空间，这块空间初始化为4
int *p1=new int(4);
//p2:动态申请4个int的空间
//C++98不支持初始化new的数组，C++11支持{}列表初始化
//int *p2=new int[4]{1,2,3,4};
int *p2=new int[4];

2. 对于自定义类型

   class A
   {
    public:
       A(int a=0)
           :_a(a)
           { cout<<"A()"<<endl;}
       ~A()
       {cout<<"~A()"<<endl;}
    private:
       int _a;
   };
   //首先对于自定义类型，以下两种方式都可以
   //1.malloc开辟自定义类型只能开辟空间
   A* p1=(A*)malloc(sizeof(A));
   A* p2=(A*)malloc(sizeof(A)*4);
   //2.new对于自定义类型，不仅能开辟空间，还会去自动调用自定义类型的构造函数
   A* p3= new A;
   A* p4= new A[4];
   free(p1);
   free(p2);
   //delete是先调用指针类型的析构函数+释放空间给堆
   delete p3;
   delete[] p4;
   //一定malloc free和new  delete和new[] delete[] 要匹配使用，否则可能会出问题
   

第一个原因就是new和delete会自动调用自定义类型的构造和析构函数

---

使用new和delete的第二个原因

• 面向对象的语言，处理错误的方式一般是抛异常，C++中也要求出错抛异常—>try catch

  void BuyMemory()
  {
      //如果没有异常就会往下执行
      //如果出现问题会直接跳到catch抛异常
      char* p=new char[100];
      printf("%p\n,p2");
  }
  try
  {
      BuyMemory();
  }
  catch (const exception& e)
  {
      cout<<e.what()<<endl;
  }
  

• 面向过程的语言，处理错误的方式是—>返回值+错误码解决

总结

C++提出new和delete，主要是解决两个问题

1. 自定义类型对象自动申请的时候，初始化和清理的问题。new/delete会调用构造函数和析构函数
2. new失败了以后要求抛异常，这样才符合面向对象语言的出错处理机制(delete和free一般不会失败，如果失败了，都是释放空间上存在越界或者释放指针位置不对)

---

operator new和operator delete

当我们使用new时，底层会自动调用两个函数一个是operator new和自定义类型的构造函数，delete也是同理会去调用operator delete 和析构函数，operator new和operator delete是操作系统提供的两个全局函数，new在底层调用operator new来开辟空间，delete在底层调用operator delete来释放空间

1. operator new的源代码

   /*
   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);
   }
   

2. operator delete的源代码

   /*
   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;
   }
   

总结

1. operator new和operator delete就是malloc和free的封装，它们跟malloc和free的作用相同都只是开空间
2. operator new中调用malloc申请内存，失败以后改为抛异常处理错误(异常抛出就一定要被接收，不然程序会直接挂掉)，这样符合C++面向对象语言处理错误的方式
3. operator new是可以被重载的，可以改变new开空间的方式，比如不想一直去找堆，可以把operator new重载成去找内存池

---

定位new表达式(placement-new)

当我们开辟了一块空间想要给它初始化，但是构造函数又不支持我们显示调用，我们就可以使用定位new来实现初始化(内存不一定从堆来，也可能从内存池来)

class A
{
 public:
    A(int a=0)
    :_a(a)
    {}
    ~A()
    {}
 private:
    int _a;
};
int main()
{
    A* p1=new A;
    //A* p1=new A(10);
    //上面等价于下面
    A* p2=(A*)operator new(sizeof(A));
    new(p2)A;
    //new(p2)A(10); A(10)传参初始化
    //析构函数是可以显示调用的
    p2->~A();
    operator delete(p2);
}

---

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

---

内存泄露

内存泄露：

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

危害：

1. 出现内存泄露的进程正常结束，进程结束时这些内存会还给操作系统，不会有什么大危害
2. 出现内存泄露的进程非正常结束，比如僵尸进程。危害很大，系统会越来越卡，甚至卡死宕机
3. 需要长期运行的程序，出现内存泄露，危害很大，系统会越来越卡，甚至卡死宕机—服务器程序