一、new 表达式和 delete 表达式的工作机理

二、operator new 和 operator delete 函数

2.1 - 标准库定义

2.2 - 重载

三、定位 new 表达式

四、常见面试题

4.1 - malloc/free 和 new/delete 的区别

4.2 - 内存泄漏

在 C++ 中，new 和 delete 既是关键字，也是一种特殊的操作符。C++ 程序中的动态内存管理主要就是通过操作符 new/delete 和 new[]/delete[] 实现的。

一、new 表达式和 delete 表达式的工作机理

假设有一个类 A：

class A
{
public:
    A(int x = 0) : _i(x) 
    {
        cout << "A(int x = 0), _i: " << _i << endl;
    }
    ~A()
    {
        cout << "~A(), _i: " << _i << endl;
    }
private:
    int _i;
};

当我们使用一条 new 表达式时：

A* p1 = new A;  // 分配一个默认初始化的 A 类对象
A* p2 = new A(10);  // 分配并初始化一个 A 类对象
// A(int x = 0), _i: 0
// A(int x = 0), _i: 10

A* arr1 = new A[5];  // 分配五个默认初始化的 A 类对象
A* arr2 = new A[5]{ 1, 2, 3, 4, 5 };  // 分配并初始化五个 A 类对象
A* arr3 = new A[5]{ A(1), A(2), A(3), A(4), A(5) };  // 分配并初始化五个 A 类对象
// A(int x = 0), _i: 0 --> 输出 5 次
// A(int x = 0), _i: 1 ~ 5
// A(int x = 0), _i: 1 ~ 5

实际上执行了以下两步操作：

调用一个名为 operator new（或者 operator new[]）的标准库函数。该函数分配一块足够大的、原始的、未命名的内存空间以便存储特定类型的对象（或对象的数组）。

operator new[] 实际上通过调用 operator new 完成 N 个对象空间的申请。
编译器运行相应的构造函数以构造这些对象，并为其传入初始值。

当我们使用一条 delete 表达式时：

delete p1;  // 销毁 *p1，然后释放 p1 指向的内存空间
delete p2;  // 销毁 *p2，然后释放 p2 指向的内存空间
// ~A(), _i: 0
// ~A(), _i: 10

delete[] arr1;  // 销毁数组中的元素，然后释放对应的内存空间
delete[] arr2;  // 销毁数组中的元素，然后释放对应的内存空间
delete[] arr3;  // 销毁数组中的元素，然后释放对应的内存空间
// ~A(), _i: 0  --> 输出 5 次
// ~A(), _i: 5 ~ 1
// ~A(), _i: 5 ~ 1

实际上执行了以下两步操作：

对 p1/p2 所指的对象或者 arr1/arr2/arr3 所指的数组中的元素执行对应的析构函数。
编译器调用名为 operator delete（或者 operator delete[]）的标准库函数释放内存空间。

operator delete[] 实际上通过调用 operator delete 完成内存空间的释放。

二、operator new 和 operator delete 函数

2.1 - 标准库定义

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

抛出异常：

int main()
{
    int* p = nullptr;
    do
    {
        p = new int[1024 * 1024];
    } while (p);
    return 0;
}

捕获异常：

#include <iostream>
using namespace std;

int main()
{
    int* p = nullptr;
    try
    {
        do
        {
            p = new int[1024 * 1024];
        } while (p);
    }
    catch (exception& e)
    {
        cout << e.what() << endl;  // bad allocation
    }
    return 0;
}

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)

2.2 - 重载

一般情况下不需要自定义 operator new 和 operator delete，除非在申请和释放空间时有某些特殊的需求，例如：在使用 new 和 delete 申请和释放空间时，打印一些日志信息，可以简单帮助用户来检测是否存在内存泄漏。

#include <iostream>
using namespace std;

// 重载 operator delete，在申请空间时：打印在哪个文件、哪个函数、第多少行，申请了多少个字节
void* operator new(size_t size, const char* fileName, const char* funcName,
    size_t lineNo)
{
    void* p = ::operator new(size);
    cout << fileName << "-" << funcName << "-" << lineNo << "-" << p << "-"
        << size << endl;
    return p;
}

// 重载 operator delete，在释放空间时：打印再那个文件、哪个函数、第多少行释放
void operator delete(void* p, const char* fileName, const char* funcName,
    size_t lineNo)
{
    cout << fileName << "-" << funcName << "-" << lineNo << "-" << p <<
        endl;
    ::operator delete(p);
}

int main()
{
    // 对重载的operator new 和 operator delete进行调用
    int* p = new(__FILE__, __FUNCTION__, __LINE__) int;
    operator delete(p, __FILE__, __FUNCTION__, __LINE__);
    return 0;
}

上述调用显然太麻烦了，可以使用宏对调用进行简化（只有在 Debug 模式下，才调用用户重载的 operator new 和 operator delete）：

#ifdef _DEBUG
#define new new(__FILE__, __FUNCTION__, __LINE__)
#define delete(p) operator delete(p, __FILE__, __FUNCTION__, __LINE__)
#endif

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

三、定位 new 表达式

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

使用格式：

new(place_address) type
// 或者
new(place_address) type(initializer-list)
// place_address 必须是一个指针，initializer-list 是初始化列表

使用场景：

定位 new 表达式在实际中一般是配合内存池使用，因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用定位 new 表达式进行显示调用构造函数进行初始化。

#include <iostream>
using namespace std;

class A
{
public:
    A(int x = 0) : _i(x)
    {
        cout << "A(int x = 0), _i: " << _i << endl;
    }
    ~A()
    {
        cout << "~A(), _i: " << _i << endl;
    }
private:
    int _i;
};

int main()
{
    // A* p = (A*)malloc(sizeof(A));
    // 或者
    A* p = (A*)operator new(sizeof(A));
    new(p) A(10);
    // A(int x = 0), _i: 10

    p->~A();
    // ~A(), _i: 10
    free(p);
    return 0;
}

四、常见面试题

4.1 - malloc/free 和 new/delete 的区别

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

malloc 和 free 是函数，new 和 delete 是操作符；
malloc 申请的空间不会初始化，new 可以初始化；
malloc 申请空间时，需要手动计算空间大小并传递，new 只需要在其后跟上空间的类型即可，如果是多个对象，则在 [] 中指定对象个数即可；
malloc 的返回值为 void*，在使用时必须强转，new 不需要，因为 new 后跟的是空间的类型；
malloc 申请空间失败时，返回的是 NULL，因此使用前必须判空，new 不需要，但是 new 需要捕获异常；
申请自定义类型对象时，malloc/free 只会开辟和释放空间，不会调用构造与析构函数，而 new 在申请空间后会调用构造函数完成对象的初始化，delete 在释放空间前会调用析构函数完成空间中资源的清理。

4.2 - 内存泄漏

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

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等，出现内存泄漏会导致响应越来越慢，最终卡死。

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

堆内存泄漏（Heap Leak）

堆内存指的是程序执行中依据需要通过 malloc/ calloc/ realloc/ new 等从堆中分配的一块内存，用完后必须通过调用相应的 free 或者 delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生 Heap Leak。
系统资源泄漏

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