⚡【C++要笑着学】(11) 动态内存管理：new 开辟空间 | delete 释放空间 | new/delete 底层探索和实现原理 | operator new / delete | 定位 new

 🔥 订阅量破千的火热 C++ 教程
👉 火速订阅《C++要笑着学》 

🔥 CSDN 累计订阅量破千的火爆 C/C++ 教程的 2023 重制版，C 语言入门到实践的精品级趣味教程。 了解更多： 👉 "不太正经" 的专栏介绍 ← 试读第一章 订阅链接： 🔗《C语言趣味教程》 ← 猛戳订阅！

   本篇博客全站热榜排名：4

💭 写在前面：C 语言里的 "动态内存管理" 放到 C++ 里面，用起来不是那么爽，所以 C++ 就对这一块进行了升级，本章我们就探索探索 C++ 的内存管理，顺便复习一下 C 语言里讲过的动态内存管理的知识。学完本章，单身的同学不用怕了，以后没有对象我们可以 new 一个 (2333) 。

---

Ⅰ.  C语言内存管理的方式回顾

0x00  回顾：内存分布位置

 观察下面一段代码，并回答问题：

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) = ____;

🔑 答案：CCCAA  AAADAB

栈区（stack）

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

执行函数时，函数内部局部变量的存储单元都可以在栈上创建。

函数执行结束后这些存储单元会被自动释放。栈内存分配运算内置于处理器的指令集中，

拥有很高的效率，但是分配的内存容量是有限的。

栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

堆区（heap）

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

一般由程序员自主分配释放，若程序员不主动不释放，程序结束时可能由操作系统回收。

其分配方式类似于链表。

数据段（data segment）

 静态存储区，数据段存放全局变量和静态数据，程序结束后由系统释放。

代码段（code segment）

 可执行的代码 / 只读常量。代码段存放类成员函数和全局函数的二进制代码。

一个程序起来之后，会把它的空间进行划分，而划分是为了更好地管理。

函数调用，函数里可能会有很多变量，函数调用建立栈帧，栈帧里存形参、局部变量等等。

内存映射段（memory mapping）

 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。

用户可使用系统接口创建共享共享内存，做进程间通信。

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

【面试题】malloc / calloc / realloc 的区别？

这些我们在C语言章节中都有详细的讲解：【维生素C语言】第十三章 - 动态内存管理

malloc

📜 头文件：stdlib.h

 📚 介绍：malloc 是 C 语言提供的一个动态内存开辟的函数，该函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。具体情况如下：

      ① 如果开辟成功，则返回一个指向开辟好空间的指针。

      ② 如果开辟失败，则返回一个 NULL 指针。

      ③ 返回值的类型为 void* ，malloc 函数并不知道开辟空间的类型，由使用者自己决定。

      ④ 如果 size 为 0（开辟0个字节），malloc 的行为是标准未定义的，结果将取决于编译器。

calloc

📜 头文件：stdlib.h

📚 介绍：calloc 函数的功能实为 num 个大小为 size 的元素开辟一块空间，并把空间的每个字节初始化为 0 ，返回一个指向它的指针。

⭕ 对比：

      ① malloc 只有一个参数，而 calloc 有两个参数，分别为元素的个数和元素的大小。

      ② 与函数 malloc 的区别在于 calloc 会在返回地址前把申请的空间的每个字节初始化为 0 。

 💬 验证： calloc 会对内存进行初始化

① 先看 malloc：

#include <stdio.h>
#include <stdlib.h>int main()
{// mallocint* p = (int*)malloc(40); // 开辟40个空间if (p == NULL)return 1;int i = 0;for (i = 0; i < 10; i++)printf("%d ", *(p + i));free(p);p = NULL;return 0;
}

 🚩  （运行结果是10个随机值）

② 再看 calloc：

#include <stdio.h>
#include <stdlib.h>int main()
{// callocint* p = (int*)calloc(10, sizeof(int)); // 开辟10个大小为int的空间，40if (p == NULL)return 1;int i = 0;for (i = 0; i < 10; i++)printf("%d ", *(p + i));free(p);p = NULL;return 0;
}

 🚩  0 0 0 0 0 0 0 0 0 0

🔺 总结：说明 calloc 会对内存进行初始化，把空间的每个字节初始化为 0 。如果我们对于申请的内存空间的内容，要求其初始化，我们就可以使用 calloc 函数。

realloc

📜 头文件：stdlib.h

📚 介绍：realloc 函数，让动态内存管理更加灵活。用于重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小，可以对动态开辟的内存进行大小的调整。具体介绍如下：

      ① ptr 为指针要调整的内存地址。

      ② size 为调整之后的新大小。

      ③ 返回值为调整之后的内存起始位置，请求失败则返回空指针。

      ④ realloc 函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

📌 realloc 函数在调整内存空间时存在的三种情况：

      情况1：原有空间之后有足够大的空间。

      情况2：原有空间之后没有足够大的空间。

      情况3：realloc 有可能找不到合适的空间来调整大小。

情况1：当原有空间之后没有足够大的空间时，直接在原有内存之后直接追加空间，原来空间的数组不发生变化。

情况2：当原有空间之后没有足够大的空间时，会在堆空间上另找一个合适大小的连续的空间来使用。函数的返回值将是一个新的内存地址。

情况3：如果找不到合适的空间，就会返回一个空指针。

Ⅱ.  C++动态内存管理方式

0x00 引入：C++ 兼容 C 的动态内存管理方式

#include <stdlib.h>void Test_C() {int* p1 = (int*)malloc(sizeof(int));int* p2 = (int*)malloc(sizeof(int) * 5);
}

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

 为了解决这种问题，C++ 又进化出属于自己的内存管理方式。

通过 new 和 delete 操作符进行动态内存管理。

0x01 使用 new 开辟空间 

💬 代码演示：使用 new 开辟空间

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

  是不是非常的爽，而且 new 不需要强制类型转换。

0x02 使用 delete 释放空间

C 语言用完之后我们要用 free 函数释放：

#include <stdlib.h>void Test_C() {int* p1 = (int*)malloc(sizeof(int));int* p2 = (int*)malloc(sizeof(int) * 5);free(p1);free(p2);
}

但是在 C++ 里，我们可以用它配套的 delete 来释放空间！

💭 代码演示：使用 delete 释放空间

void Test_CPP() {int* p1 = new int;int* p2 = new int(10);int* p3 = new int[10];    // 多个对象// 单个对象，delete即可。delete p1;delete p2;// 多个对象，delete[] 。delete[] p3;
}

 这些指针要不要置空呢？

从安全角度看，这里当然还是置空一下比较好：

void Test_CPP() {int* p1 = new int;int* p2 = new int(10);int* p3 = new int[3];delete p1;delete p2;delete[] p3;p1 = nullptr;p2 = nullptr;p3 = nullptr;
}

不知道大家还是否记得下面这张图（维生素C语言中讲解free的插图）

只是我们这里用 delete，并用 nullptr 置空了，目的是完全一样的。

0x03 初始化 new 数组的问题

 C++ 98 并不支持初始化 new 数组：

int* p = new int[5];

 但 C++11 允许大括号初始化，我们就可以用 { } 列表初始化：

int* p1 = new int[5]{1,2}         // 1 2 0 0 0
int* p2 = new int[5]{1,2,3,4,5};  // 1 2 3 4 5

0x04 new 和 delete 操作自定义类型

我们知道了，malloc / free 和 new / delete 对于内置类型没有本质区别，

 那么它存在的意义是什么呢？仅仅是因为用法更简洁吗？

 当然不是，我们继续往下看。

malloc 和 new 的对比

诚然，对于自定义类型，你也是可以用 malloc 的。

💬 代码演示：用 malloc 创建对象

#include <iostream>
using namespace std;class A {
public:A(): _a(0) {cout << "A():" << this << endl;}~A() {cout << "~A():" << this << endl;}private:int _a;
};int main(void)
{// 动态申请单个A对象和5个A对象数组A* p1 = (A*)malloc(sizeof(A));A* p2 = (A*)malloc(sizeof(A) * 5);
}

对于这种是自定义类型的场景，你继续坚持用 C 语言的动态内存开辟的手段。

这让然是行的，没人会拦你，但是我们在来看看 C++ 的：

int main(void)
{// 动态申请单个A对象和5个A对象数组A* p1 = (A*)malloc(sizeof(A));A* p2 = (A*)malloc(sizeof(A) * 5);A* p3 = new A;     // 后面只需要跟类型就可以A* p4 = new A[5];
}

"没有对比就没有伤害啊  >_< "

直接看代码，同样是申请单个 A 对象和 5 个对象数组，C++ 写法明显是是更简单。

仅仅是因为如此吗？我们再来调试调试一睹芳容！

🔍 调试监测：让我看看！

"我敲，还有这种功能？玩的这么花的吗？"

不仅能开内存，还能帮你初始化！是的！如果是一个数组，new 也会对它初始化。

比如这里的 new A[5] ，它会依次对动态创建的 5 个对象进行初始化

真的是太棒了，new 不仅会开内存，还会调用对应的构造函数初始化，多省事？

不仅仅是写法上变得简单了，对于自定义类型来说用起来也特别爽！还有什么理由不用 new 呢？

"new 简直是动态内存开辟的增强补丁！"

free 与 delete 的对比

💬 我们来对比一下 free 和 delete，它们都是用来释放内存空间的。

#include <iostream>
using namespace std;class A {
public:A(): _a(0) {cout << "A():" << this << endl;}~A() {cout << "~A():" << this << endl;}private:int _a;
};int main(void)
{A* p1 = (A*)malloc(sizeof(A));A* p2 = (A*)malloc(sizeof(A) * 5);A* p3 = new A;  A* p4 = new A[5];free(p1);free(p2);delete p3;delete[] p4;// ...
}

相对的，free 只是把 p1 p2 指向的空间释放掉。

而 delete 不仅会释 p1 p2 指向的空间，delete 还会调用对应的析构函数。

🔺 总结：在申请自定义类型的空间时，new 会调用构造函数，delete 会调用析构函数，而 malloc 与 free 不会。

• new：在堆上申请空间 + 调用构造函数输出。
• delete：先调用指针类型的析构函数 + 释放空间给堆上。

0x05 建议：new/delete 和 malloc/free 要匹配使用

new     👉  delete 
new[]   👉  delete[] malloc  👉  free(A)

  new 对应的是 delete，可以可以 new 出来的用 free 释放？

💡 不建议大家混着用， new 出来的用 free，有的编译器就会爆炸。

int main(void)
{A* p4 = new A[5];free(p4);	      // delete[] p4;     
}

不仅如此，new[] 出来的 你去 delate 而不是 delate[]  也会崩：

int main(void)
{A* p4 = new A[5];delete p4;	      // delete[] p4;     
}

记住一个点就可以了：壹壹对应，匹配使用，就不会翻车：

malloc / free          
delete / delete      
new[] / delete[] 

"你要过马路你就老老实实走斑马线，不要瞎穿"

其实也不一定会出问题，具体得看编译器的检查机制，但是这个 "不一定" 就带有悬念了。

  所以个人建议，还是老老实实的比较好。

Ⅲ.  new 和 delete 的底层探索

0x00 operator new 与 operator delete 函数

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，
尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
*/void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{// try to allocate size bytesvoid* 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 == NULLreturn;_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_FINALLYreturn;
}/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

 通过上述两个全局函数的实现可以知道： 

• operator new 实际上也是通过 malloc 来申请空间的。
• operator delete 最终也是通过 free 来释放空间的。

如果 malloc 申请空间成功就直接返回，否则执行用户提供的空间不足的应对措施，

如果用户提供该措施就继续申请，否则就抛异常。

面向过程的语言处理错误的方式：返回值 + 错误码解决（这个我们之前学过）。

#include <stdio.h>
#include <stdlib.h>int main(void)
{char* p1 = (char*)malloc(1024u * 1024u * 1024u *2u);if (p1 == nullptr) {printf("%d\n", errno);perror("malloc fail");exit(-1);} else {printf("%p\n", p1);}return 0;
}

而面向对象语言处理错误的方式：

一般是抛异常，C++中也要求出错抛异常 —— try catch（后期会细说）。

#include <iostream>
using namespace std;int main(void)
{char* p2 = nullptr;try {char* p2 = new char[1024u * 1024u * 1024u * 2u - 1];} catch (const exception& e) {cout << e.what() << endl;}printf("%p\n", p2);return 0;
}

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

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

0x01  operator new 与 operator delete 的类专属重载

下面代码演示了，针对链表的节点 ListNode 通过重载类专属 operator new / operator delete，

实现链表节点使用内存池申请和释放内存，提高效率。我们先看看按照 C 的方式写：

struct ListNode {ListNode* _next;ListNode* _prev;int _val;
};int main(void)
{struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));if (n1 == NULL) {printf("malloc failed!\n");exit(-1);}n1->_next = NULL;n1->_prev = NULL;n1->_val = 0;return 0;
}

我们创建节点还需要用 malloc 申请空间，还需要强制类型转换，之后还要自己写上初始化，

因为 malloc 失败返回 NULL，会存在野指针隐患，所以出于安全还要检查一下。

我们再来看看 C++ 的方式：

struct ListNode {ListNode* _next;ListNode* _prev;int _val;/* 构造函数*/ListNode(int val): _next(nullptr), _prev(nullptr), _val(val) {}
};int main(void)
{ListNode* n2 = new ListNode(0);return 0;
}

 而在 C++ 里，因为 new 会自动调用构造函数去完成初始化，就很舒服。

而且还不需要去检查是否开辟失败，因为 new 失败不会返回空，而是抛异常。

💬 我们再举个能用得上析构函数的例子 —— Stack：

#include <iostream>
using namespace std;class Stack {
public:Stack(int capacity = 4): _top(0), _capacity(capacity) {_arr = new int[capacity];}~Stack() {delete[] _arr;_arr = nullptr;_capacity = _top = 0;}// ...private:int* _arr;int  _top;int  _capacity;
};int main(void)
{Stack st;  // 完事了Stack* pst2 = new Stack;  // 开空间 + 构造函数初始化delete pst2;  // 析构函数（清理对象中资源）+ 释放空间return 0;
}

Ⅳ.  new 和 delete 的实现原理

0x00  对于内置类型

 如果申请的是内置类型的空间，new 和 malloc，delete 和 free 基本相似。

不同的地方是，new / delete 申请和释放的是单个元素的空间，

new[] 和 delete[] 申请的是连续空间，而且 new 再申请空间失败时会抛异常。

A* p3 = new A;      // 开辟单个空间
A* p4 = new A[5];   // 开辟的是连续地5个空间

operator new 和 operator delete 就是对 malloc 和 free 的封装。

operator new 中调用 malloc 后申请内存，失败以后，改为抛异常处理错误，

这样符合 C++ 面向对象语言处理错误的方式。

new Stack
call malloc + call Stack 构造函数   ❌ 如果失败返回0，这不符合C++处理错误的方式new Stack
call operator new + call Stack 构造函数  ✅  失败抛异常，这就非常滴合适

0x01 对于自定义类型

new 的原理：

① 调用 operator new 函数申请空间。

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

delete 的原理：

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

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

new T[N] 的原理：

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

② 在申请的空间上调用 N 次构造函数，对它们分别初始化。

Stack* p1 = new[10];
Stack* pst1 = (Stack*)operator new[](sizeof(Stack) * 10);

delete[] 的原理：

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

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

Ⅴ.  定位 new

0x00 引入：我想手动初始化构造函数

如果不用 new，我想手动调用构造函数初始化，我们该怎么做？

"有些人会说 我闲的？手动初始化干什么？实际上会有这种需求场景的！"

假设我们这有一块空间，是从内存池取来的，或者是 malloc 出来的、operator new 出来的……

 我就不想用 new，但是我想对他进行初始化，行不行？

A* p = (A*)malloc(sizeof(A));  // 我能不能调用构造函数初始化？

当然可以！定位 new 表达式 帮你！

0x01 定位 new 表达式

定位 new 表达式实在已分配的原始空间中调用构造函数初始化一个对象。

简单来说就是，定位 new 表达式可以在已有的空间进行初始化。

📚 写法：分为带参和不带参形式

new(目标地址指针)类型                         // 不带参
new(目标地址指针)类型(该类型的初始化列表)       // 带参

📌 注意：目标地址必须是一个指针

0x02 定位new的使用场景

定位 new 是很有用的！

比如开的空间是从内存池来的，如果想初始化，我们就可以使用它。

因为内存池分配出的内存初始化，所以如果是自定义类型的对象，

需要使用 new 定义的表达式进行显示调用构造函数进行初始化。

0x03 定位 new 用法演示

💬 代码演示：不带参定位 new

class A {
public:A(int a = 0): _a(a) {cout << "A(): " << this << endl;}~A() {cout << "~A(): " << this << endl;}private:int _a;
};int main(void)
{A* p = (A*)malloc(sizeof(A));  // malloc 创建的new(p)A;   // 使用定位new调用构造函数return 0;
}

💬 代码演示：带参定位 new

class A {
public:A(int a): _a(a) {cout << "A(): " << this << endl;}~A() {cout << "~A(): " << this << endl;}private:int _a;
};int main(void)
{A* p1 = (A*)malloc(sizeof(A));   // malloc 创建的new(p1)A(10);     // 调用构造并初始化为10return 0;
}

💬 模拟一下 new 的行为：

int main(void)
{A* p1 = (A*)malloc(sizeof(A));new(p1)A(10);// 模拟一下new的行为A* p2 = new A(2); // 等价于:A* p3 = (A*)operator new(sizeof(A));new(p3)A(3);return 0;
}

  没事这么写，其实就是脱裤子放屁，

但是有时候，内存不一定是从堆来的，比如从内存池来的，定位 new 就可以大显神功。

比如高并发内存池，实现定长内存池的时候就需要使用定位 new。

析构函数释放

析构函数是可以显式调用的（构造函数不行）

p->~A;

int main(void)
{A* p1 = (A*)malloc(sizeof(A));new(p1)A(1);A* p2 = new A(2);delete p2;// 等价于:A* p3 = (A*)operator new(sizeof(A));new(p3)A(3);p3->~A;operator delete(p3);return 0;
}

 ​​​

📌 [ 笔者 ]   王亦优
📃 [ 更新 ]   2022.3.28 | 2023.10.4(重制)
❌ [ 勘误 ]   暂无
📜 [ 声明 ]   由于作者水平有限，本文有错误和不准确之处在所难免，本人也很想知道这些错误，恳望读者批评指正！

📜 参考资料  Microsoft. MSDN(Microsoft Developer Network)[EB/OL]. []. . 百度百科[EB/OL]. []. https://baike.baidu.com/. 比特科技. C++[EB/OL]. 2021[2021.8.31]