一、C/C++ 内存分布

在C语言阶段，我们常说局部变量存储在栈区，动态内存中的数据存储在堆区，静态变量存储在静态区，常量存储在常量区，其实这里我们所说的栈区、堆区、静态区以及常量区都是 虚拟进程地址空间 的一部分，其中具体内存区域的划分如下：

栈：又叫堆栈，用于存储非静态局部变量、函数参数以及函数返回值等等，栈是向下增长的；

堆：用于程序运行时进行动态内存分配，堆是向上增长的；

数据段 (静态区)：Linux 中通常叫作数据段，用于存储存储全局数据和静态数据；

代码段 (常量区)：Linux 中通常叫作代码段，用于存储可执行的代码指令和只读常量；

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

内核空间：操作系统内核 – kernel，受硬件保护，用户不能进行读写，用于执行各种机器指令。

注：虚拟进程地址空间、多进程多线程以及操作系统内核等相关知识我们会在 Linux 中进行学习，这里我们只需要学习 C/C++ 的内存区域划分即可。

在学习了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);
}
1. 选择题：
选项 : A.栈  B.堆  C.数据段(静态区)  D.代码段(常量区)
globalVar在哪里？____  staticGlobalVar在哪里？____
staticVar在哪里？____  localVar在哪里？____
num1 在哪里？____
char2在哪里？____ *char2在哪里？___
pChar3在哪里？____ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____
2. 填空题：
sizeof(num1) = ____;
sizeof(char2) = ____;    strlen(char2) = ____;
sizeof(pChar3) = ____;   strlen(pChar3) = ____;
sizeof(ptr1) = ____;
3. sizeof 和 strlen 区别？
答案：(横向)
1、选择题：C C C A A A A A D A B
2、填空题：40 5 4 4/8 4 4/8
3、sizeof是操作符/关键字，后面可以不加括号，而直接跟类型，另外，sizeof计算的是变量所占空间的字节数；而strlen是函数，调用必须加括号，且strlen计算的是字符串中字符的个数(不包括'\0')

上面有两个易错的地方，一是 sizeof(数组名) 计算的是整个数组的大小，二是 *char2 和 *pchar3 的存储区域 – 我们知道常量字符串 “abcd” 存储在代码段，不可修改；对于 pchar3 来说，它是一个指针，指向代码段的 “abcd”，所以 *pchar3 在代码段；而 char2 是一个数组，数组在栈区上开辟空间，所以 char2 数组中的数据是从代码段拷贝来的，所以 *char2 在栈区；

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

在C语言中我们使用 malloc/calloc/realloc/free 函数来进行动态内存管理：

void Test()
{
  int* p1 = (int*)malloc(sizeof(int));
  if (p1 == NULL)
  {
    perror("malloc fail");
    exit(-1);
  }
  int* p2 = (int*)calloc(4, sizeof(int));
  if (p2 == NULL)
  {
    perror("calloc fail");
    exit(-1);
  }
  int* p3 = (int*)realloc(p2, sizeof(int) * 10);
  if (p3 == NULL)
  {
    perror("realloc fail");
    exit(-1);
  }
  free(p1);
  free(p3);
}

面试题：malloc/calloc/realloc的区别？

malloc 用于开辟一块动态内存，使用时需要指定开辟的空间大小 (字节)，如果开辟成功返回空间的起始地址，如果开辟失败返回 NULL，且不会初始化；

calloc 的用法和 malloc 类似，只是它有两个参数，第一个参数为元素个数，第二个参数为每个元素的大小，并且它会将该空间中的数据全部初始化为0；

realloc 用于空间的扩容/缩容，它有两个参数，第一个参数为需要调整的动态内存的起始地址，第二个参数为调整后的空间大小，如果第一个参数为 NULL，则它等价于 malloc；如果扩容，编译器会检查原空间后是否有足够的空间，如果足够，就直接扩容并返回原空间的起始地址，如果不够，就新开辟一块空间，然后将原空间的数据拷贝到新空间并返回新空间的地址，最后再释放原空间；如果缩容，编译器会直接新开辟一块空间，然后拷贝原空间数据到新空间并返回新空间的地址，再释放原空间。

拓展学习：malloc 的实现原理 – glibc中malloc实现原理 – bilibili

三、C++动态内存管理方式

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

1、new/delete 操作内置类型

对于内置类型，C语言和C++内存管理方式没有明显区别，只是C++中使用 new 操作符来替代C语言中的 malloc/calloc 函数，使用 delete 操作符来替代 free 函数 ；

同时，由于 new 和 delete 是操作符/关键字，而不是函数，所以它们后面不需要跟括号，而是直接跟类型即可；另外，new 可以在开辟空间的同时进行初始化。

注：C++不支持扩容，要扩容都是自己开辟新空间、拷贝数据，然后再销毁原空间。

void Test()
{
  //申请单个空间不初始化
  int* p1 = new int;
  //申请单个空间并初始化
  int* p2 = new int(10);
  //申请连续空间不初始化
  int* p3 = new int[10];
  //申请连续空间并初始化
  int* p4 = new int[10]{ 1,2,3,4,5 };
  //释放单个空间
  delete p1;
  delete p2;
  //释放多个空间
  delete[] p3;
  delete[] p4;
}

申请和释放单个元素的空间，使用 new 和 delete 操作符，申请和释放连续的空间，使用 new[] 和 delete[]，注意二者一定要匹配使用，即不能用 delete 来释放 new[] 开辟的空间。

2、new/delete 操作自定义类型

C++动态内存管理和C语言动态内存管理最大的不同在于二者对自定义类型的处理：C语言 malloc/calloc/realloc 函数只负责开辟空间，free 函数只负责销毁空间；而C++在申请自定义类型的空间时，new 会调用构造函数，delete 会调用析构函数。

class A
{
public:
  A(int a = 0)
    : _a(a)
  {
    cout << "A 构造" << this << endl;
  }
  ~A()
  {
    cout << "A 析构" << this << endl;
  }
private:
  int _a;
};

四、operator new 与 operator delete

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

需要特别注意的是，operator new 和 operator delete 函数不是运算符重载，因为它们的参数没有自定义类型，而是库里面实现的全局函数，仅仅是将它们取名为 operator 而已，很多C++的初学者都会被二者的函数名所误导。

C++底层的 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);  //此处调用free函数
  __FINALLY
    _munlock(_HEAP_LOCK);  // release other threads
  __END_TRY_FINALLY
    return;
}
// free的实现
#define  free(p)        _free_dbg(p, _NORMAL_BLOCK)

我们可以通过查看反汇编代码来验证 new 和 delete 的底层调用：

int main()
{
  int* p = new int;
  delete p;
}

而对于new[] 和 delete[] 来说，它们通过调用 operator new[] 和 operator delete[] 函数来实现其功能，但是其实 operator new[] 和 operator delete[] 底层也是调用的 operator new 和 operator delete 函数：

通过上述的实验我们知道 operator new 实际也是通过 malloc 来申请空间，如果 malloc 申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供了该措施就继续申请，否则就抛异常。operator delete 最终是通过 free 来释放空间的。

五、new 和 delete 的实现原理

1、内置类型

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

2、自定义类型

调用 operator new 函数申请空间；

在申请的空间上调用构造函数，完成对象的初始化；

delete 的原理

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

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

new T[N] 的原理

调用 operator new[] 函数，在 operator new[] 中实际调用 operator new 函数完成N个对象空间的申请；

在申请的空间上调用N次构造函数；

delete[] 的原理

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

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

可以看到，对于自定义类型，C++ 中的 new 和 delete 不仅仅会进行空间的申请和释放，还会进行构造和析构，这也正是为什么在C语言已经有了malloc/calloc/realloc/free 的情况下，C++ 又单独创造了 new 和 delete 的原因。

六、定位 new 表达式 (了解)

定位 new 也叫 replacement new，定位 new 表达式是在已分配的原始内存空间中调用构造函数初始化一个对象；其使用格式如下：

new(place_address) type 或者 new (place_address) type(initializer-list)

其中 place_address 必须是一个指针，initializer-list 是类型的初始化列表；如下：

class A
{
public:
  A(int a = 0)
    : _a(a)
  {
    cout << "A():" << this << endl;
  }
  ~A()
  {
    cout << "~A():" << this << endl;
  }
private:
  int _a;
};
int main()
{
    //p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
  A* pa = (A*)malloc(sizeof(A));
  if (pa == NULL)
  {
    perror("malloc fail");
    exit(-1);
  }
  //定位new--对pa指向的空间显式调用构造函数
  new(pa)A(1);
  pa->~A();  //析构函数可以直接显式调用，或者直接使用delete
  free(pa);
}

使用场景

定位 new 表达式在实际中一般是配合内存池使用 – 因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用 new 的定义表达式进行显示调构造函数进行初始化；而内存池在后面我们会详细学习，此处我们了解一下即可。

简单理解一下内存池：

假设半山腰有一个村子，但由于各种原因村子中没有水喝，所以人们每次喝水都只能到山下的公共水井处排队打水，但是呢排队很慢，所以村长就用抽水机+水管联通水井在自己家建了一个蓄水池，以后要用水就直接到蓄水池中去取即可，而不用再到山下去排队打水了，大大提高了效率。

上述例子中全村公用的水井就相当于堆，其他村民排队打水就相当于 malloc/calloc/realloc 函数向堆区申请空间，而村长家的蓄水池就相当于我们的主角 – 内存池，内存池的建立可以使得我们申请空间的效率变得很高。

七、常见面试题

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

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

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

申请内置类型空间时，malloc申请的空间不可以初始化，new可以初始化；

申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理；

malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可；

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

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

2、内存泄漏

什么是内存泄漏

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

内存泄漏的危害

短期运行的程序发生内存泄露危害不大，因为当程序结束时动态申请的空间全部都会被回收；长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

内存泄露的分类

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

堆内存泄漏(Heap leak)：堆内存指的是程序执行中依据须要分配通过 malloc / calloc / realloc / new 等从堆中分配的一

块内存，用完后必须通过调用相应的 free或者delete 删掉；假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak；

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

如何检测内存泄露

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

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

• 在linux下内存泄漏检测：Linux下几款C++程序中的内存泄露检查工具
• 在windows下使用第三方工具：VLD工具说明
• 其他工具：内存泄露检测工具比较

如何避免内存泄漏

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

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

出问题了使用内存泄漏工具检测。(注：很多工具都不够靠谱，或者收费昂贵)

总结：内存泄漏非常常见，解决方案分为两种 – 1、事前预防型；如智能指针等。2、事后查错型；如泄漏检测工具。