C++ 定制 `new` 和 `delete` 操作符：全局与类级别重载

好的，各位观众老爷，欢迎来到今天的C++定制内存管理专场！今天咱们不聊风花雪月，就聊聊C++里那些你可能用过，也可能没用过，但关键时刻能救命的new和delete操作符的“整容”大法。

开场白：内存，你的地盘你做主

在C++的世界里，内存就像一块巨大的土地，而new和delete就是帮你在这片土地上圈地盖房和拆迁的工具。默认情况下，这些工具都是由C++标准库提供的，它们兢兢业业地工作，但有时候，它们可能无法完全满足你的特殊需求。比如：

• 性能瓶颈？ 默认的内存分配器可能在某些场景下效率不高，导致程序运行缓慢。
• 内存泄漏？ 你可能需要更精细的内存管理策略，避免内存泄漏的发生。
• 安全需求？ 你可能需要对分配的内存进行额外的安全检查，防止缓冲区溢出等问题。
• 嵌入式系统？ 在资源受限的嵌入式系统中，你需要更严格地控制内存的使用。

这时候，“定制”就显得尤为重要了。就像装修房子一样，你不满意开发商的默认配置，就可以自己动手，打造一个更符合自己需求的家。

第一幕：全局级别的“改头换面”

最直接的方式就是重载全局的new和delete操作符。这意味着你将接管整个程序的内存分配和释放，所有对象都会使用你定制的分配器。

语法糖时间：

void* operator new(size_t size);
void operator delete(void* ptr);
void* operator new[](size_t size); // 数组形式
void operator delete[](void* ptr); // 数组形式

//placement new
void* operator new(size_t size, void* placement);
void operator delete(void* ptr, void* placement); //placement delete

• size_t size: 需要分配的内存大小（以字节为单位）。
• void* ptr: 指向需要释放的内存块的指针。
• 返回值: 成功分配的内存块的起始地址，如果分配失败，则抛出 std::bad_alloc 异常（对于new）。delete 没有返回值。
• void* placement: placement new 的额外参数，通常是一个指针，指示在哪个位置分配内存。

实战演练：一个简单的内存池

咱们先来一个最简单的例子：用一个固定大小的内存池来分配内存。

#include <iostream>
#include <new> // 包含 std::bad_alloc

const size_t POOL_SIZE = 1024 * 1024; // 1MB
char memoryPool[POOL_SIZE];
char* poolPtr = memoryPool;

void* operator new(size_t size) {
    if (poolPtr + size > memoryPool + POOL_SIZE) {
        std::cout << "内存池耗尽，分配失败！" << std::endl;
        throw std::bad_alloc(); // 分配失败，抛出异常
    }
    void* ptr = poolPtr;
    poolPtr += size;
    std::cout << "从内存池分配了 " << size << " 字节，地址： " << ptr << std::endl;
    return ptr;
}

void operator delete(void* ptr) noexcept {
    // 这是一个非常简化的版本，实际上需要更复杂的处理
    // 比如记录已分配的内存块，以便后续释放
    std::cout << "释放了内存，地址： " << ptr << std::endl;
    // 在这个例子中，我们不真正释放内存，只是打印一条消息
}

void* operator new[](size_t size) {
    std::cout << "数组 new 操作符被调用，大小： " << size << std::endl;
    return operator new(size); // 调用单对象的 new
}

void operator delete[](void* ptr) noexcept {
    std::cout << "数组 delete 操作符被调用，地址： " << ptr << std::endl;
    operator delete(ptr); // 调用单对象的 delete
}

//placement new
void* operator new(size_t size, void* placement) {
    std::cout << "Placement new 操作符被调用，大小： " << size << ", placement: " << placement << std::endl;
    return placement;
}

void operator delete(void* ptr, void* placement) noexcept {
    std::cout << "Placement delete 操作符被调用，地址： " << ptr << ", placement: " << placement << std::endl;
    // Placement delete 通常不需要做任何事情，因为内存不是由 new 分配的
}

class MyClass {
public:
    MyClass() { std::cout << "MyClass 构造函数被调用" << std::endl; }
    ~MyClass() { std::cout << "MyClass 析构函数被调用" << std::endl; }
};

int main() {
    MyClass* obj1 = new MyClass();
    delete obj1;

    MyClass* arr = new MyClass[3];
    delete[] arr;

    char buffer[sizeof(MyClass)];
    MyClass* obj2 = new (buffer) MyClass(); //Placement new
    obj2->~MyClass(); // 显式调用析构函数
    // delete obj2; // 不要使用 delete 释放 placement new 分配的内存
     operator delete(obj2, buffer);

    return 0;
}

代码解读：

1. 内存池： 我们定义了一个固定大小的字符数组memoryPool作为内存池。
2. 指针： poolPtr指向内存池中下一个可用的位置。
3. new操作符： operator new函数负责从内存池中分配指定大小的内存。如果内存池已满，则抛出std::bad_alloc异常。
4. delete操作符： operator delete函数负责释放内存。在这个简单的例子中，我们只是打印一条消息，并没有真正释放内存（因为内存池的实现比较复杂）。
5. 数组形式： operator new[]和operator delete[]分别对应于数组的分配和释放。
6. Placement new: operator new(size_t size, void* placement) 允许你在指定的内存地址上构造对象。通常与预先分配好的缓冲区一起使用。对应的 operator delete(void* ptr, void* placement) ，通常不释放内存，只负责调用析构函数。

注意事项：

• 异常处理： 如果new操作符分配失败，必须抛出std::bad_alloc异常，否则程序的行为是未定义的。
• 内存对齐： 你需要确保分配的内存地址满足对齐要求，否则可能会导致程序崩溃。
• 线程安全： 如果你的程序是多线程的，你需要考虑线程安全问题，可以使用互斥锁等机制来保护内存池。
• 释放问题： 这个例子中的delete操作符并没有真正释放内存，这只是一个简化的版本。在实际应用中，你需要实现更复杂的内存管理机制，比如记录已分配的内存块，以便后续释放。
• Placement new 只能显式调用析构函数: placement new 构造的对象，只能显式调用析构函数，不能使用 delete 释放内存，否则会造成未定义行为.

全局重载的优缺点：

特性	优点	缺点
影响范围	影响整个程序的所有内存分配和释放	对整个程序都有影响，可能会与其他库或代码产生冲突。
控制程度	可以完全控制内存分配和释放的行为	需要小心处理内存管理的所有细节，包括对齐、异常处理、线程安全等。
适用场景	适用于需要对整个程序的内存管理进行统一优化的场景，例如嵌入式系统、高性能计算等。	不适用于只需要对部分代码进行内存管理优化的场景，因为全局重载可能会影响其他代码的正常运行。
代码复杂度	实现简单，但需要考虑各种边界情况和错误处理，代码复杂度较高。	需要编写大量的代码来处理内存管理的各种细节，包括内存池的初始化、分配、释放、对齐、异常处理、线程安全等。
风险	如果实现不正确，可能会导致内存泄漏、内存溢出、程序崩溃等问题。	如果内存管理实现不正确，可能会导致各种难以调试的错误，例如内存损坏、数据污染等。

第二幕：类级别的“私人定制”

如果你不想影响整个程序的内存分配，只想对某个特定的类进行优化，那么你可以重载该类的new和delete操作符。

语法糖时间：

class MyClass {
public:
    void* operator new(size_t size);
    void operator delete(void* ptr) noexcept;
    void* operator new[](size_t size);
    void operator delete[](void* ptr) noexcept;
};

实战演练：为类定制内存池

#include <iostream>
#include <new>

const size_t CLASS_POOL_SIZE = 512;
char classMemoryPool[CLASS_POOL_SIZE];
char* classPoolPtr = classMemoryPool;

class MyClass {
public:
    MyClass() { std::cout << "MyClass 构造函数被调用" << std::endl; }
    ~MyClass() { std::cout << "MyClass 析构函数被调用" << std::endl; }

    void* operator new(size_t size) {
        if (classPoolPtr + size > classMemoryPool + CLASS_POOL_SIZE) {
            std::cout << "MyClass 内存池耗尽，分配失败！" << std::endl;
            throw std::bad_alloc();
        }
        void* ptr = classPoolPtr;
        classPoolPtr += size;
        std::cout << "MyClass 从内存池分配了 " << size << " 字节，地址： " << ptr << std::endl;
        return ptr;
    }

    void operator delete(void* ptr) noexcept {
        // 同样，这里只是打印消息，不真正释放内存
        std::cout << "MyClass 释放了内存，地址： " << ptr << std::endl;
    }

     void* operator new[](size_t size) {
        std::cout << "MyClass 数组 new 操作符被调用，大小： " << size << std::endl;
        return operator new(size); // 调用单对象的 new
    }

    void operator delete[](void* ptr) noexcept {
        std::cout << "MyClass 数组 delete 操作符被调用，地址： " << ptr << std::endl;
        operator delete(ptr); // 调用单对象的 delete
    }

private:
    int data;
};

int main() {
    MyClass* obj1 = new MyClass();
    delete obj1;

    MyClass* arr = new MyClass[2];
    delete[] arr;

    // 其他类型的对象仍然使用全局的 new 和 delete
    int* num = new int(10);
    delete num;

    return 0;
}

代码解读：

1. 类内定义： operator new和operator delete函数在MyClass类内部定义。
2. 独立的内存池： MyClass类拥有自己的内存池classMemoryPool。
3. 只影响该类： 只有MyClass的对象才会使用这个定制的分配器，其他类型的对象仍然使用全局的new和delete。

类级别重载的优缺点：

特性	优点	缺点
影响范围	只影响特定类的对象	如果需要对多个类进行类似的优化，需要为每个类都实现 new 和 delete 操作符，代码重复度较高。
控制程度	可以对特定类的内存分配和释放进行精细控制	只能控制特定类的内存分配和释放，无法影响其他类的行为。
适用场景	适用于只需要对特定类的对象进行内存管理优化的场景，例如需要频繁创建和销毁的类、需要使用特定内存池的类等。	不适用于需要对整个程序的内存管理进行统一优化的场景，因为类级别的重载只能影响特定类的对象。
代码复杂度	实现相对简单，但仍然需要考虑各种边界情况和错误处理。	与全局重载类似，需要考虑内存对齐、异常处理、线程安全等问题。
风险	如果实现不正确，可能会导致内存泄漏、内存溢出、程序崩溃等问题，但影响范围仅限于特定类的对象。	与全局重载类似，如果内存管理实现不正确，可能会导致各种难以调试的错误。

第三幕：Placement new的妙用

Placement new 是一种特殊的 new 操作符，它允许你在已分配的内存上构造对象，而不是分配新的内存。这在某些场景下非常有用，比如：

• 对象复用： 你可以重复使用同一块内存来构造不同的对象，避免频繁的内存分配和释放。
• 内存池： 你可以先从内存池中分配一块内存，然后使用 placement new 在这块内存上构造对象。
• 序列化/反序列化： 你可以将对象序列化到一块预先分配的内存中，或者从内存中反序列化对象。

语法糖时间：

void* operator new(size_t size, void* placement); //placement new
void operator delete(void* ptr, void* placement) noexcept; //placement delete

实战演练：在预分配的内存上构造对象

#include <iostream>
#include <new>

class MyClass {
public:
    MyClass() { std::cout << "MyClass 构造函数被调用" << std::endl; }
    ~MyClass() { std::cout << "MyClass 析构函数被调用" << std::endl; }
    void print() { std::cout << "Hello from MyClass!" << std::endl; }
};

int main() {
    // 预先分配一块内存
    char buffer[sizeof(MyClass)];

    // 使用 placement new 在 buffer 上构造 MyClass 对象
    MyClass* obj = new (buffer) MyClass();

    // 调用对象的方法
    obj->print();

    // 显式调用析构函数
    obj->~MyClass();

    // 不要使用 delete 释放 placement new 分配的内存
    // delete obj; // 错误！

    return 0;
}

代码解读：

1. 预分配内存： 我们定义了一个字符数组buffer，大小足够容纳一个MyClass对象。
2. Placement new： new (buffer) MyClass()使用 placement new 在buffer上构造一个MyClass对象。
3. 显式析构： 由于buffer不是通过new分配的，所以不能使用delete来释放它。你需要显式调用析构函数obj->~MyClass()来销毁对象。

注意事项：

• 不要使用delete： 绝对不要使用delete来释放 placement new 分配的内存，否则会导致未定义行为。
• 显式析构： 必须显式调用析构函数来销毁对象。
• 内存对齐： 确保预分配的内存地址满足对齐要求。

第四幕：注意事项与最佳实践

1. RAII原则： 使用RAII（资源获取即初始化）原则来管理内存，可以有效避免内存泄漏。
2. 智能指针： 使用智能指针（std::unique_ptr、std::shared_ptr等）可以自动管理内存，减少手动分配和释放的错误。
3. 内存分析工具： 使用内存分析工具（如Valgrind）可以帮助你检测内存泄漏、内存溢出等问题。
4. 谨慎使用全局重载： 全局重载可能会与其他库或代码产生冲突，尽量避免使用。
5. 充分测试： 在定制new和delete操作符后，进行充分的测试，确保程序的稳定性和可靠性。
6. 自定义内存分配器: 可以考虑使用现有的内存分配器库，例如 Boost.Pool，或者自己实现一个更高效的内存分配器。

结尾语：掌控你的内存，掌控你的程序

定制new和delete操作符是一项强大的技术，它可以让你更精细地控制内存管理，优化程序性能，提高代码安全性。但同时，它也是一项具有挑战性的任务，需要你对C++的内存管理机制有深入的理解。希望今天的讲解能帮助你更好地理解和使用这项技术，让你的程序在内存的世界里自由驰骋！

记住，内存是你的地盘，你说了算！

感谢大家的观看，咱们下期再见！