C/C++内存管理

C/C++内存分布

解释重点区域的解释：
栈区： 调用一个函数就相当与开辟了栈的空间，该空间也会随着函数的结束而释放；局部变量也是如此（系统完成释放）
堆区： 比如用malloc/calloc/realloc去动态开辟空间就在堆区开辟（手动释放）
数据段（静态区）： 存储全局变量和静态变量
常量区： 通常就是用const修饰的变量

C语言的动态内存管理

malloc函数

函数原型：

void* malloc (size_t size);

• malloc时动态开辟一块指定大小且连续可用的空间（大小以字节为单位），以void*返回。

• 返回值，如果开辟成功那么指针就指向该空间的开始；否则，返回NULL。

• 释放：动态开辟的空间一定要手动释放，必须释放完整的一段空间没有释放一半或者释放不完整的说法。

• 指向空间的指针不要轻易移动，如果移动就可能会导致释放内存不完整，导致内存泄漏；

malloc使用形式

int n = 10;
int* p1 = (int*)malloc(sizeof(int) * n)//常见形式，（所需类型）malloc（大小）

因为返回的是void* ，所以用整型指针接收需要强转为相同的类型。

calloc函数（类似于malloc）

函数原型：

void* calloc (size_t num, size_t size);

• 这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针（跟malloc一样）
• 该函数与malloc函数的区别是calloc函数在返回后会把这段连续可用的空间初始化为0。

calloc使用：

int n = 10;
int* p1 = (int*)calloc(sizeof(int) * n)

因为返回的是void* ，所以用整型指针接收需要强转为相同的类型。

realloc函数

函数的作用：

• 合理的申请空间，realoc函数可以做到对动态开辟内存大小的调整
• realloc函数的出现让动态内存管理更加灵活

函数原型：

void* realloc (void* ptr, size_t size);

realloc使用

int *p1=(int*)malloc(100)
int n = 10;
int* p2 = (int*)realloc(p1,sizeof(int) * n)//扩容10字节

free的使用

只要动态申请就需要释放

int n = 10;
int* p1 = (int*)malloc(sizeof(int) * n)
free(p1);//完全释放

系统如何识别空间的可用性？

在开辟空间时，系统会识别当前空间是否满足开辟要求，被占用的空间标为True，未用空间标志为False

C++内存管理方式

• C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因

  此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

new和delete的使用

int main()
{
  // 动态申请一个int类型的空间
  int* p1 = new int;
  
  // 动态申请一个int类型的空间并初始化为10
  int* p2 = new int(10);
  
  // 动态申请10个int类型的空间
  int* p3 = new int[10];
  delete p1;
  delete p2;
  delete[] p3;
    
   return 0;
}

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，匹配起来使用。

C++new&&delete和C中的malloc&&free的区别

• 在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与

free不会。

• malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地

  方是：

• malloc和free是函数，new和delete是操作符

• malloc申请的空间不会初始化，new可以初始化

• malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可

  如果是多个对象，[]中指定对象个数即可

• malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型

• malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需

​ 要捕获异常

• 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new

在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成

空间中资源的清理

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)

其实operator new的开辟空间也是调用malloc，不过operator new的优点就是返回不会返回空指针，而是做了抛异常;

operator delete的释放空间也是调用free

new和delete的实现原理

内置类型

new的原理

1. 调用operator new函数申请空间

2. 在申请的空间上执行构造函数，完成对象的构造

delete的原理

1. 在空间上执行析构函数，完成对象中资源的清理工作

2. 调用operator delete函数释放对象的空间

new int[N]的原理

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对

象空间的申请

2. 在申请的空间上执行N次构造函数

delete[]的原理

1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释

放空间

内存泄漏

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

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内

存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对

该段内存的控制，因而造成了内存的浪费。

**内存泄漏的危害：**长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现

内存泄漏会导致响应越来越慢，最终卡死。

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

内存泄漏分类

堆内存泄漏

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一

块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分

内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放

掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

检测内存泄漏（_CrtDumpMemoryLeak函数）

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

还可以用一些第三方软件检测

如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。举例：

这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智

能指针来管理才有保证。

2. 采用RAII思想或者智能指针来管理资源。

3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

4. 出问题了使用内存泄漏工具检测。举例：不过很多工具都不够靠谱，或者收费昂贵。
   后，每次程序退出的时候就会检测是否存在内存泄漏