c++的内存管理（new+delete详解）

动名词

已于 2022-08-19 21:47:54 修改

阅读量177

点赞数 2

分类专栏： c++ 文章标签： c++ java 算法数据结构后端

于 2022-08-18 23:11:45 首次发布

本文链接：https://blog.csdn.net/lyzzs222/article/details/126398074

版权

c++ 专栏收录该内容

19 篇文章 2 订阅

订阅专栏

文章目录

前言：

1.内存分布

在这里插入图片描述
说明：

栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。
内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。(虚拟内存)
堆用于程序运行时动态内存分配，堆是可以上增长的。
数据段–存储全局数据和静态数据。
代码段–可执行的代码/只读常量。

总结：临时变量，形参，递归调用函数等都是在栈上，不需要自己管理，程序退出时，栈释放内存；堆是人为动态开辟的内存，不用时需要自己动手释放内存；内核空间相当于给操作系统的，用户代码不能读写；内存映射段，学操作系统会讲，开虚拟内存等映射操作，本篇不着重讲这个；数据段，存全局变量和静态数据；代码段，存的是代码(编译后为指令)，只读常量。
看一道例题有助于我们理解：

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";
 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);
}
选择题：
 选项: A.栈 B.堆 C.数据段 D.代码段
 (1)globalVar在哪里？____ (2)staticGlobalVar在哪里？____
 (3)staticVar在哪里？____ (4)localVar在哪里？____
 (5)num1 在哪里？____
 
 (6)char2在哪里？____ (7)*char2在哪里？___
 (8)pChar3在哪里？____ (9)*pChar3在哪里？____
 (10)ptr1在哪里？____ (11)*ptr1在哪里？____

答案公布：
选择题：
(1)c :全局变量在数据段；（2）c :静态数据在数据段；（3）c :局部变量加上staic修饰，生存周期改为全局,所以在数据段；（4）A ：局部变量在栈上；（5）A ：局部变量在栈上；（6）A ：局部变量在栈上；（7）A ：在栈上保存的数组，其内容在数组中，所以在栈上（易错）；（8）A：局部变量在栈上；（9）D ："abcd"只读常量（字符串），指针指向了这个存在代码段的字符串（易错）；
（10）A ：局部变量在栈上；（11）B :在堆上开辟的空间。
具体关系如图：
在这里插入图片描述

2.动态内存管理

动态内存管理，无非就是在堆上开辟空间，最后释放空间。C语言是面向过程的语言，其动态开辟空间用的是 malloc/calloc/realloc三个库函数，释放空间用的是free；c++是面向对象的语言，其动态开辟空间用的是new，delete俩个操作符。下面会分开讲解。

2.1 C语言的动态内存管理

（1）void* malloc (size_t size);
malloc函数，在堆上开辟size字节的空间，结束后需要调用free函数进行空间释放。
例子：开辟一个整型数组，数组包含4个整型。

int * nums=(int *)malloc(sizeof(int)*4);
free(nums);

(2)void* calloc (size_t num, size_t size);
calloc函数，比malloc函数多一个参数num，意味：开辟num个大小为size的空间。而且，calloc还会对开辟的空间进行初始化，按字节初始化，每个字节都会被初始化为0。
例子：开辟一个整型数组，数组包含4个整型。

int * nums=(int *)calloc(4,sizeof(int));
free(nums);

在这里插入图片描述
(3)void* realloc (void* ptr, size_t size);
realloc函数用于修改指针ptr指向的空间，将其大小修改为size。
例子：修改上面数组的空间，改为存三个整型的大小；

relloc(nums,sizeof(int)*3);
free(nums);

2.2 c++的动态内存管理

（1）c++的动态内存管理用的是new和delete，为什么不沿用C语言的呢？

自定义类型对象的初始化和清理，new会调用构造函数，delete会调用析构函数。
这很重要，创建一个对象会自动调用它的构造函数，程序结束会自动调用它的析构函数；我们在堆上创建一个对象也要遵循如此，但是malloc，calloc，realloc都不能满足既开辟空间，又能去调用其构造函数去初始化对象。所以new产生了。delete也是如此，free不能够调用对象的析构函数，所以用delete。
报错的机制不同，new和delete报错会抛异常，malloc，calloc，realloc报错会报错误码，抛异常的报错方式更加的匹配面向对象的语言出错处理机制。

（2）

new一个对象：
new 类名()+delete 类名;()里可以传参也可以不传参，看具体情况
new多个对象：
new 类名[]+delete [] 类名;[]里面加数子，代表new多少个对象

必须配套使用，否则会抛异常。

（3）new和delete的使用

class A
{
  public:
  A(int a=1) 
  {
  _a=a;
  ptr=new int[_a];
  }
  ~A()
  {
   delete [] ptr;
   ptr=nullptr;
   _a=0;
  }
  private:
  int _a;
  int *ptr;
}

可以看到，上面我创建了一个类，这个类的功能是在堆上开辟一个包含_a个整型的整型数组。
假如我在main函数里创建了一个此类的对象，并且最后销毁它，我们来看看这个过程。

int main()
{  
    A* nums=new A(4);
    delete nums; 
    return 0;
}

new会先调用类A的析构函数去初始化，所以_a=4,并且ptr指向一个开辟了4个整型大小的空间，然后开辟nums的空间。
在这里插入图片描述

然后delete 对象nums，会先调用nums的析构函数，再去释放掉nums。
在这里插入图片描述

3. operator new与operator delete函数

void *operator new(size_t);     //allocate an object
void *operator delete(void *);    //free an object
void *operator new[](size_t);     //allocate an array
void *operator delete[](void *);    //free an array

解释：

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

可以想一下，new，delete是完全抛弃了malloc和free吗？当然不是，其实operator new和operator delete就是对malloc和free的封装，然后new和delete在底层会去调用operator new和operator delete。
咱们来看一下operator new和operator delete的源码。

//operator new中封装了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 );//这就是free
 __FINALLY
 _munlock(_HEAP_LOCK); /* release other threads */
 __END_TRY_FINALLY
 return;
 }
 #define free(p) _free_dbg(p, _NORMAL_BLOCK)

4. new和delete的实现原理

有了对operator new 和operator delete的认识，我们就来讲讲new和delete的实现原理。
（1）new
new会先调用operator new来申请空间(本质malloc申请空间)，然后申请的空间上执行对象的构造函数，完成对象的初始化。
（2）delete
delete会在申请的空间上执行对象的析构函数，再调用operator delete来释放掉申请的空间。