前言：

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

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

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

🔑 答案：CCCAA  AAADAB

栈区（stack）

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

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

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

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

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

堆区（heap）

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

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

其分配方式类似于链表。

数据段（data segment）

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

代码段（code segment）

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

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

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

内存映射段（memory mapping）

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

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

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

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

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

malloc

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

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

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

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

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

calloc

📜 头文件：stdlib.h

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

⭕ 对比：

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

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

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

#include <stdio.h>
#include <stdlib.h>
int main()
{
    // malloc
    int* 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个随机值）

#include <stdio.h>
#include <stdlib.h>
int main()
{
    // calloc
    int* p = (int*)calloc(10, sizeof(int)); // 开辟10个大小为int的空间，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;
}

🚩  0 0 0 0 0 0 0 0 0 0

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

0x03 realloc

📜 头文件：stdlib.h

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

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

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

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

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

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

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

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

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

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

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

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

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

0x00 引入

#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 / delete 操作内置类型

💬 new 开辟空间：

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

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

💬 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：

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 对于内置类型没有本质区别，

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

当然不是，因为 new 和 malloc 可以操作自定义类型，我们继续往下看。

malloc 和 new 的对比

我们先来对比一下 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 呢？

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 
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[]

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

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

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