C++ 自定义 `operator new` 与 `operator delete`：定制内存分配行为

C++ 里的“包租婆”：定制你的内存分配策略

各位 C++ 码农们，你们有没有想过，每次用 new 申请内存，就像去找“包租婆”租房子一样？“包租婆”（C++ 默认的内存分配器）二话不说，直接给你块地儿，然后告诉你： “行了，这就是你的了，记得按时交‘房租’（内存释放）！”

但是，如果“包租婆”的房子你不满意呢？比如，她给你的房子永远都在城市的边边角角，离你的程序“核心业务区”十万八千里，每次访问都要长途跋涉，效率低到爆。或者，她总是给你一些奇形怪状的“户型”，导致你的对象们住得非常拥挤，甚至引发邻里纠纷（内存碎片）？

别慌！C++ 给了我们“重新装修”甚至“自己盖房”的权力。这就是今天要聊的 —— 定制 operator new 和 operator delete，也就是咱们自己当“包租婆”，掌控内存分配的大权！

为什么要自己当“包租婆”？

在深入技术细节之前，我们先来聊聊，为啥要费劲巴拉地定制内存分配器。难道 C++ 默认的分配器不好吗？默认的分配器确实“够用”，但很多时候，“够用”距离“好用”还差十万八千里。让我们来看看几个常见的痛点：

性能瓶颈： 默认的分配器通常是通用型的，要考虑各种情况，因此不可避免地会有一些额外的开销。在高并发、频繁分配释放内存的场景下，这些开销会累积成巨大的性能瓶颈。
内存碎片： 频繁的分配和释放会导致内存中出现很多小块的空闲区域，这些区域不足以满足较大对象的分配需求，造成内存浪费，这就是内存碎片。
内存泄漏： 如果忘记释放已经分配的内存，就会导致内存泄漏。虽然现代操作系统会在程序退出时回收内存，但在长时间运行的程序中，内存泄漏会逐渐消耗系统资源，最终导致程序崩溃。
安全性问题： 恶意程序可能会利用内存分配漏洞进行攻击。

所以，在一些对性能、资源利用率、安全性有较高要求的场景下，定制内存分配器就显得非常有必要了。比如：

游戏引擎： 游戏引擎需要频繁地创建和销毁大量的对象，定制内存分配器可以减少内存碎片，提高性能。
嵌入式系统： 嵌入式系统的资源非常有限，定制内存分配器可以更好地管理内存，提高资源利用率。
高性能服务器： 高性能服务器需要处理大量的并发请求，定制内存分配器可以减少内存分配的开销，提高吞吐量。

“包租婆”的基本功：operator new 和 operator delete

在 C++ 中， new 运算符实际上做了两件事情：

分配内存： 调用 operator new 分配一块原始的、未初始化的内存。
构造对象： 在分配的内存上调用对象的构造函数进行初始化。

而 delete 运算符则做了相反的两件事情：

析构对象： 调用对象的析构函数清理资源。
释放内存： 调用 operator delete 释放之前分配的内存。

所以，我们要定制内存分配行为，核心就是重载 operator new 和 operator delete。让我们先来看看它们的函数原型：

// 分配内存
void* operator new(std::size_t size) throw (std::bad_alloc);

// 释放内存
void operator delete(void* ptr) throw();

// 带有 placement new 的版本
void* operator new(std::size_t size, const std::nothrow_t& nothrow_value) throw();
void operator delete(void* ptr, const std::nothrow_t& nothrow_value) throw();

// 带有 placement new 的版本，可以处理分配失败的情况
void operator delete(void* ptr, std::size_t size) throw(); // C++11 之后才支持

size：要分配的内存大小（以字节为单位）。
ptr：要释放的内存块的指针。
std::nothrow_t：一个空结构体，用于指示 new 在分配失败时不抛出异常，而是返回 nullptr。

自己动手，丰衣足食：重载 operator new 和 operator delete

重载 operator new 和 operator delete 非常简单，只需要在类中或者全局作用域中定义它们即可。

1. 类级别的重载:

如果你只想为某个特定的类定制内存分配行为，可以在该类中重载 operator new 和 operator delete。例如：

class MyClass {
public:
    // 自定义的 operator new
    void* operator new(std::size_t size) {
        std::cout << "MyClass operator new called, size: " << size << std::endl;
        void* p = std::malloc(size); // 使用 malloc 分配内存
        if (!p) {
            throw std::bad_alloc();
        }
        return p;
    }

    // 自定义的 operator delete
    void operator delete(void* ptr) {
        std::cout << "MyClass operator delete called" << std::endl;
        std::free(ptr); // 使用 free 释放内存
    }

private:
    int data[100];
};

int main() {
    MyClass* obj = new MyClass(); // 会调用 MyClass 的 operator new
    delete obj; // 会调用 MyClass 的 operator delete
    return 0;
}

在这个例子中，我们重载了 MyClass 的 operator new 和 operator delete。当我们使用 new MyClass() 创建对象时，实际上会调用我们自定义的 operator new 来分配内存。当我们使用 delete obj 释放对象时，实际上会调用我们自定义的 operator delete 来释放内存。

2. 全局级别的重载:

如果你想为所有类都定制内存分配行为，可以在全局作用域中重载 operator new 和 operator delete。这种方式会影响到整个程序的内存分配行为，要谨慎使用。

// 全局的 operator new
void* operator new(std::size_t size) {
    std::cout << "Global operator new called, size: " << size << std::endl;
    void* p = std::malloc(size);
    if (!p) {
        throw std::bad_alloc();
    }
    return p;
}

// 全局的 operator delete
void operator delete(void* ptr) {
    std::cout << "Global operator delete called" << std::endl;
    std::free(ptr);
}

int main() {
    int* num = new int(10); // 会调用全局的 operator new
    delete num; // 会调用全局的 operator delete

    MyClass* obj = new MyClass(); // 如果 MyClass 没有自定义 operator new, 也会调用全局的
    delete obj;

    return 0;
}

在这个例子中，我们重载了全局的 operator new 和 operator delete。所有的 new 和 delete 操作都会调用我们自定义的全局 operator new 和 operator delete，除非某个类自己定义了 operator new 和 operator delete。

一些“装修”的小技巧

现在我们已经掌握了重载 operator new 和 operator delete 的基本方法。接下来，我们来聊聊一些常用的“装修”技巧，让你的内存分配器更加高效、安全。

使用 placement new:

placement new 允许你在已经分配好的内存上构造对象。它的语法是：

new (address) ClassName(arguments);

其中，address 是已经分配好的内存地址， ClassName 是要构造的对象的类型， arguments 是构造函数的参数。

placement new 的一个常见的应用场景是内存池。我们可以预先分配一大块内存，然后使用 placement new 在这块内存上创建对象，避免频繁地分配和释放内存。

#include <iostream>
#include <new> // 包含 placement new 的头文件

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "MyClass constructor called, data: " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called, data: " << data << std::endl;
    }
private:
    int data;
};

int main() {
    // 预先分配一块内存
    void* buffer = std::malloc(sizeof(MyClass));

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

    // 使用 placement new 构造的对象需要手动调用析构函数
    obj->~MyClass();

    // 释放预先分配的内存
    std::free(buffer);

    return 0;
}

注意： 使用 placement new 构造的对象，在销毁时不能使用 delete 运算符，而是需要手动调用析构函数。并且，预先分配的内存需要手动释放。

内存池：

内存池是一种常用的内存管理技术。它的基本思想是预先分配一大块内存，然后将这块内存分割成若干个固定大小的块，每次分配内存时，直接从内存池中取出一个块即可。释放内存时，将块放回内存池中。

内存池的优点是可以减少内存碎片，提高内存分配的效率。它的缺点是只能分配固定大小的内存块，灵活性较差。

对齐：

在某些情况下，我们需要保证分配的内存地址是对齐的。例如，某些 CPU 指令只能访问对齐的内存地址。为了保证内存对齐，我们可以使用 std::align 函数。

异常处理：

在重载 operator new 时，要特别注意异常处理。如果分配内存失败，应该抛出 std::bad_alloc 异常。否则，可能会导致程序崩溃。

调试：

定制内存分配器后，调试可能会变得更加困难。为了方便调试，可以在 operator new 和 operator delete 中添加一些调试信息，例如打印分配和释放的内存地址、大小等。

总结：

定制 operator new 和 operator delete 就像给自己家的房子重新装修一样，虽然需要花费一些时间和精力，但可以让我们更好地掌控内存分配，提高程序的性能、资源利用率和安全性。当然，定制内存分配器并不是万能的，只有在确实需要的时候才应该考虑使用。否则，可能会增加代码的复杂性，降低可维护性。

希望这篇文章能够帮助你更好地理解 C++ 中的 operator new 和 operator delete，让你在内存管理的道路上越走越远！记住，掌握了内存分配的技巧，你就能成为 C++ 世界里真正的“包租婆”，掌控一切！

C++ 里的“包租婆”：定制你的内存分配策略

发表回复 取消回复

发表回复取消回复