C++的new / delete 与 C语言的malloc/realloc/calloc / free 的讲解

在C语言中我们通常会使用malloc/realloc/calloc来动态开辟的空间，malloc是只会开辟你提供的空间大小，并不会初始化内容；calloc不但会开辟空间，还会初始化；realloc是专门来扩容的，当你第一次开辟的空间不够用的时候，就要使用realloc；如果你第一次使用realloc的时候，前面没有开辟过空间，那么realloc的行为会跟malloc一样，之后再发挥realloc自己的行为。而我们的C++是面向对象的编程，当开辟空间失败了malloc只会返回一个空指针，我们还需要自己来判断。所以在C++这里就将malloc升级成为了new，new在开辟空间失败的时候会抛出异常，这跟我们面向对象的理念是一致的。

其实我在C语言阶段学习动态开辟空间的时候，是有点迷糊的，就是不知道如何去开辟，给谁开辟？现在想想其实不难理解，假设我们要开辟10个int类型的空间大小，我们有两种办法，一种就是直接定义一个int类型的数组：int arr[10]，但是这样的空间是定长的空间，我们无法对定长数组进行扩容。第二种就是用到动态开辟的空间了，我们肯定是先要malloc10个int类型的空间，但是我们应该如何取到这段空间呢？用指针变量接收是吧，但是为什么是指针变量呢？我们继续讲解，因为我们先开辟了一段空间，正常情况下是无法取到这段空间的，只有拿到这段空间的地址，才可以访问这段空间。这也就是为什么我们会用指针变量来接收malloc开辟的空间了。

下面是malloc的函数声明：通过malloc的返回值也不难看出要用指针接收。所以我们要开辟空间，一种就是直接定义类型，比如int a、int arr[10]、char ch等等，一种就是用malloc/realloc/calloc开辟空间，用指针接收。

一、介绍

1. malloc、realloc、calloc的介绍

1. malloc只是动态开辟空间，并没有初始化这段空间的内容；

2. realloc是用来扩容的，如果没有预先开辟空间，直接使用realloc，realloc的作用相当于malloc；

3. calloc相当于是malloc的加强版，不仅可以开辟空间，也顺便初始化我们的内容；

4. 面对内置类型可以直接开辟空间，但是对于自定义类型的话，比如我们的栈，则无法一步到位，因为栈里面还有数组空间的开辟，需要两层开辟。

下面就是栈的举例：因为我们仅仅是用的malloc来开辟一个栈的空间，所以栈内部的数组空间还需要开辟，如果我们要是写一个构造函数去初始化，在主函数中是无法调用的，也就完成不了对数组空间的开辟，不过在了解定位new之后是可以调用的，我们这里使用写一个成员函数Init来完成对数组空间的开辟，这样我们在主函数中也可以调用。然后其实这样的方法有点麻烦，而且在malloc失败的时候只是返回空指针，判断条件也需要我们自己去写，这很不满足面向对象的要求，所以C++基于这样的原因创造了new这个操作符。

#include <iostream>
using namespace std;
class Stack
{
public:
    void Init(int capacity)
    {
        _a = (int*)malloc(sizeof(int) * capacity);
        if(_a == nullptr)
        {
            perror("malloc fail");
            exit(-1);
        }
        _size = 0;
        _capacity = capacity;
    }
private:
    int *_a;
    int _size;
    int _capacity;
};
int main()
{
    Stack *st = (Stack*)malloc(sizeof(Stack));
    st->Init(4);
    return 0;
}

2. free的介绍

free专门释放动态开辟的空间，如果释放的不是动态开辟的空间，就会报错，所以这里一定要多加注意！！！

一般就是free( )，括号里面就是指向那段空间的指针就行。

3. new、operator new的介绍（内置类型和自定义类型）

new是在C++中才有的操作符，因为C++兼容C语言，所以在C++中可以写C，但是在C中写不了C++。new也是用来动态开辟空间的，也可以初始化，即可以开辟内置类型的空间，也可以开辟自定义类型的空间，这两种类型都可以初始化；

1. new对内置类型开辟空间：直接开辟

int *a = new int;      //单纯开辟空间
int *b = new int(3);   //开辟空间并初始化

int *arr1 = new int[5]; //单纯开辟5个整型的空间
int *arr2 = new int[5]{1, 2, 3, 4, 5}; //开辟5个整型空间并初始化

2. new对自定义类型开辟空间：第一步：开辟这个自定义类型需要的空间；

第二步：调用这个自定义类型的构造函数；

所以我们上面对于栈的开辟，可以改善为下面这样：

#include <iostream>
using namespace std;
class Stack
{
public:
    Stack(int capacity = 4, int size = 0, int num = 0)
        : _a(new int[capacity]{0})
        , _size(size)
        , _capacity(capacity)
    {
        cout << "Stack(int capacity = 4)" << endl; //方便观察确实调用了构造函数
    }
    
private:
    int *_a;
    int _size;
    int _capacity;
};
int main()
{
    Stack *st = new Stack;
    //Stack *st = new Stack(4, 0, 0);这种就是对于显式构造函数的写法，或者是你想传入的初始化内容
    return 0;
}

3. 那operator new 又是什么呢？

相信大家对这个并不熟悉，所以这部分知识了解即可，operator new 是一种全局函数，对malloc进行了封装，也就是让malloc函数更加面向对象，而不是面向过程了。因为我们在C语言的时候，malloc开辟空间失败，会返回个空指针，我们会根据空指针去找过程中的错误，然后C++是面向对象编程，所以就必须知道是哪个对象出错了，new出错就报new。所以operator new就是对malloc进行了一个包装，底层还是通过malloc实现，只不过在出错的时候，operator new是抛异常，不是返回空指针了。下面就是operator new这个函数的定义：

所以operator new 还是通过malloc实现的，看不懂下面的也没关系，记住operator new 开辟空间失败抛异常，malloc失败是返回NULL；

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);
}

4. delete、operator delete的介绍

delete是用来释放动态开辟的空间，如果释放的不是动态开辟的空间会报错；

他跟free的区别是在自定义类型这里，free仅仅释放他括号里指向的空间；

delete在释放自定义类型的空间时候，会做两件事：

1. 先调用自定义类型的析构函数；

2. 再去调用operator delete函数；

    int *a = new int;
    char *ch = new char;
    double *d = new double[5];
    
    delete a;
    delete ch;
    delete []d;

而operator delete 我们会在new、delete针对数组这里拿出来讲解

二、new、delete的原理

1. new对于自定义类型：

1. new 会先调用 operator new 开自定义类型的空间；

2. 在申请的空间上，再去调用自定义类型的构造函数；

这里解答一下为什么new步调用malloc，而是调用的operator new

因为还是C++是面向对象编程，所以我们不使用malloc这套判断错误的方式，而是选择operator new 这个函数去封装一下new，再让new来调用自己，一切都是为了面向对象，所以new的产生原因也是这样的，因为面向对象。

2. delete对于自定义类型

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

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

需要注意的就是为什么delete要先调用析构函数？

因为我们要知道，再对于栈这样的数据结构，他里面数组的空间是被栈空间的指针指着的，如果先释放栈的空间，就相当于把数组的地址释放了，然后再去调用析构函数就会找不到要析构的位置了，所以就会出错；

基于这样的原因一定要先析构，再释放自定义类型的空间；

3. new、delete对于数组、自定义类型的数组（重点，难点）

这里其实又涉及到一些不一样的知识，我们知道，在new一个数组的时候，我们是告诉他开辟多少个元素的空间的，如下图，我们是知道开5个空间的大小的，那在释放的时候，delete又是如何知道需要释放多大的空间的呢？我们保持这个问题，继续往下看。

#include <iostream>
using namespace std;
class Stack
{
public:
    Stack(int capacity = 4, int size = 0, int num = 0)
        : _a(new int[capacity]{0})
        , _size(size)
        , _capacity(capacity)
    {
        cout << "Stack(int capacity = 4)" << endl; //方便观察确实调用了构造函数
    }
    
private:
    int *_a;
    int _size;
    int _capacity;
};
int main()
{
    Stack *st = new Stack[5];
    delete []st;
    return 0;
}

其实，是因为在开辟空间之前，我们多开辟了一个int的空间，这个空间就是用来存放数组的个数的，相当于是图中这样开辟的空间：

所以delete面对数组这样的空间，他先通过st指针指向的位置，先调用多次析构函数，连续释放完5个_a指针指向的空间之后，返回到a位置处，再用通过调用operator delete释放自定义类型数组的这段空间。

换句话说delete 的[ ] 是识别这个类型是数组，然后知道数组会多开辟4个字节的空间，进而从多开辟的空间的地址处释放。而单独的delete就不会认为这个类型是数组类型，也就不会寻找这段空间，直接在数组首元素这里释放空间，当然一定要注意自定义类型，还需要调用析构函数。

new --> 内置类型数组

new --> operator new[ ] 函数 --> operator new 函数 --> malloc

这里要知道的是，上面都是调用了一次，因为开辟的空间是提前算好的，开辟一次就行

delete --> 内置类型数组

delete --> operator delete[ ] 函数 --> operator delete 函数 --> free

new --> 自定义类型数组

1. new --> operator new[ ] 函数 --> operator new 函数 --> malloc

2. 每一个自定义类型再调用构造函数

开辟的空间都是一次性开辟好的，所以只需要new一次，而每个自定义类型都需要调用构造函数，所以是多个。

delete --> 自定义类型数组

1. 每一个自定义类型先调用自己的析构函数

2. delete --> operator delete[ ] 函数 --> operator delete 函数 --> free

三、面试题：new/delete 和 malloc/free 的异同

共同点：

都是从堆上申请空间，并且需要用户手动释放。

不同点：

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

2. malloc申请的空间不会初始化，new可以初始化；

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

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

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

要捕获异常；

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