如何实现自定义内存管理器重载new和delete操作符示例-C++-PHP中文网

<p>自定义内存管理器通过重载new/delete接管内存分配，实现性能优化、减少碎片、辅助调试。1. 重载全局operator new(size_t size)实现自定义分配逻辑；2. 重载operator delete(void* ptr)实现内存回收；3. 需同步处理new[]/delete[]数组版本；4. 可结合块分配器预分配大内存并切分固定大小块，通过空闲链表高效管理；5. 实际应用需注意递归调用、内存对齐、线程安全、异常处理及数组头部信息管理等陷阱。</p>

如何实现自定义内存管理器重载new和delete操作符示例

实现自定义内存管理器，核心在于接管程序的内存分配与释放机制。这通常通过重载C++的全局或类成员

new

登录后复制

和

delete

登录后复制

操作符来完成，从而替换掉默认的内存分配器，获得对内存行为的精细控制，比如优化性能、减少碎片、或者辅助调试。

解决方案

要实现一个自定义内存管理器并重载

new

登录后复制

和

delete

登录后复制

操作符，最直接的方式是重载全局的

operator new

登录后复制

和

operator delete

登录后复制

。这会影响到程序中所有使用

new

登录后复制

和

delete

登录后复制

进行动态内存分配的地方。

一个基础的实现思路是：

重载
operator new(size_t size)
登录后复制
：在这个函数里，你不再调用标准库的
```
malloc
```
登录后复制
，而是调用你自己的内存分配逻辑。这可能是一个预先分配好的内存池、一个块分配器，或者任何你设计的复杂策略。分配成功后，返回指向这块内存的指针。

*重载 `operator delete(void ptr)

：** 对应地，当内存被释放时，你的

登录后复制

delete

操作符会接管。你在这里实现自己的内存回收逻辑，将

登录后复制

ptr` 指向的内存归还到你的管理池中。

以下是一个非常简化的示例，它仅仅是把内存分配和释放委托给了

malloc

登录后复制

和

free

登录后复制

，但加上了一些日志输出，让你能看到重载确实生效了。在实际应用中，你需要用更复杂的内存管理算法替换

malloc

登录后复制

free

登录后复制

。

#include <iostream>
#include <cstdlib> // For malloc and free

// 重载全局的 new 操作符
void* operator new(size_t size) {
    std::cout << "Custom new: Allocating " << size << " bytes." << std::endl;
    void* p = std::malloc(size); // 实际的内存分配
    if (!p) {
        throw std::bad_alloc(); // 分配失败时抛出异常
    }
    return p;
}

// 重载全局的 delete 操作符
void operator delete(void* p) noexcept {
    std::cout << "Custom delete: Deallocating memory." << std::endl;
    std::free(p); // 实际的内存释放
}

// 重载全局的 new[] 操作符 (数组版本)
void* operator new[](size_t size) {
    std::cout << "Custom new[]: Allocating array of " << size << " bytes." << std::endl;
    void* p = std::malloc(size);
    if (!p) {
        throw std::bad_alloc();
    }
    return p;
}

// 重载全局的 delete[] 操作符 (数组版本)
void operator delete[](void* p) noexcept {
    std::cout << "Custom delete[]: Deallocating array memory." << std::endl;
    std::free(p);
}

// 示例类
class MyClass {
public:
    int data;
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

int main() {
    std::cout << "--- Testing single object allocation ---" << std::endl;
    MyClass* obj = new MyClass(); // 会调用我们重载的 operator new
    obj->data = 10;
    std::cout << "Obj data: " << obj->data << std::endl;
    delete obj; // 会调用我们重载的 operator delete

    std::cout << "\n--- Testing array allocation ---" << std::endl;
    MyClass* arr = new MyClass[3]; // 会调用我们重载的 operator new[]
    arr[0].data = 1;
    arr[1].data = 2;
    arr[2].data = 3;
    delete[] arr; // 会调用我们重载的 operator delete[]

    std::cout << "\n--- Testing primitive type allocation ---" << std::endl;
    int* i = new int; // 也会调用我们重载的 operator new
    *i = 5;
    delete i; // 调用我们重载的 operator delete

    return 0;
}

登录后复制

运行这段代码，你会看到自定义的

new

登录后复制

和

delete

登录后复制

消息被打印出来，证明它们已经成功接管了内存操作。

为什么自定义内存管理在高性能应用中不可或缺？

说实话，很多人一开始觉得自定义内存管理是不是有点“过度工程”了。毕竟，标准库的

malloc

登录后复制

和

free

登录后复制

运行得好好的，为什么还要费劲自己写一套？但当你深入到一些对性能、内存占用或特定行为有极高要求的场景时，比如游戏开发、嵌入式系统、高性能计算（HPC），甚至是某些服务器后端，你就会发现默认的分配器有时候真的不够用。

首先是性能瓶颈。标准的

malloc

登录后复制

和

free

登录后复制

为了通用性，通常会包含复杂的同步机制（比如多线程锁）和碎片管理策略。这意味着每次内存请求都可能涉及锁竞争，或者耗时的内存块查找。对于频繁的小对象分配和释放，这会带来显著的开销。我记得有一次在优化一个游戏引擎的粒子系统时，发现大部分CPU时间竟然花在了

new

登录后复制

和

delete

登录后复制

上，而不是渲染或物理计算，那时候我就意识到，是时候自己动手了。自定义分配器可以针对特定模式（比如只分配固定大小的块）进行高度优化，避免不必要的开销。

其次是内存碎片。长时间运行的程序，尤其是有大量不同大小对象频繁分配和释放的，很容易产生内存碎片。这就像你往一个箱子里装东西，尽管总空间够，但因为小缝隙太多，大件物品反而放不进去。内存碎片会导致程序无法分配到连续的大块内存，即使物理内存总量充足，最终可能导致

std::bad_alloc

登录后复制

或者性能下降。自定义内存池或者分代分配器能有效缓解这个问题，通过预先分配大块内存并按需切分，或者将生命周期相似的对象放在一起，减少碎片。

再者是调试和诊断。标准库的内存分配器通常是黑盒，你很难知道内存是如何被使用的，哪里发生了内存泄漏，或者哪里出现了越界访问。通过重载

new

登录后复制

和

delete

登录后复制

，你可以轻松地在内存分配和释放时加入日志、断言、堆栈跟踪，甚至实现简单的内存泄漏检测器。比如，你可以维护一个所有已分配内存块的列表，在程序结束时检查哪些块没有被释放，这对于定位内存泄漏简直是神器。我曾经用这种方法在一个老项目中迅速找到了几个隐藏很深的内存泄漏点，比Valgrind这类工具直接多了，因为它就集成在我的代码里。

最后，还有一些特殊需求。比如，你可能需要将特定类型的数据分配到特定的内存区域（例如GPU内存、非易失性内存），或者实现一个线程局部的内存分配器来避免全局锁。这些都是标准分配器无法提供的能力。自定义，意味着掌控一切。

深入探究：重载

new

登录后复制

和

delete

登录后复制

操作符时常见的陷阱与应对策略

重载

new

登录后复制

和

delete

登录后复制

绝不是简单地替换几个函数调用那么轻松，它是一把双刃剑。稍有不慎，你可能会引入比解决更多的问题。我个人在实践中就踩过不少坑，有些问题排查起来简直让人头秃。

一个最常见的陷阱是递归调用。如果你在自定义的

operator new

登录后复制

或

operator delete

登录后复制

内部又直接或间接地调用了

new

登录后复制

或

delete

登录后复制

，那恭喜你，你将得到一个无限递归，最终栈溢出。例如，在

operator new

登录后复制

中使用

std::vector

登录后复制

，而

std::vector

登录后复制

的底层内存分配又会调用

new

登录后复制

。解决办法通常是，在你的自定义操作符内部，只能使用像

malloc

登录后复制

free

登录后复制

这样不依赖

new

登录后复制

delete

登录后复制

的底层C函数，或者使用专门的无分配函数（placement new）。

Rustic AI

AI驱动的创意设计平台

108

查看详情

内存对齐也是个大问题。现代CPU为了性能，经常要求数据在内存中按照特定边界对齐。例如，一个

int

登录后复制

可能需要4字节对齐，一个

double

登录后复制

可能需要8字节对齐。如果你自定义的分配器返回的内存地址没有正确对齐，那么访问这些数据时可能会导致性能下降，甚至引发崩溃（尤其是对于一些SIMD指令或特定硬件）。C++17引入了带对齐参数的

operator new(size_t size, std::align_val_t alignment)

登录后复制

，这让处理对齐变得更方便。在此之前，你可能需要使用

posix_memalign

登录后复制

或

_aligned_malloc

登录后复制

等平台特定的函数来确保对齐。

线程安全是另一个重头戏。在多线程环境中，如果你的自定义分配器没有妥善处理并发访问，就会出现竞争条件，导致内存损坏、崩溃或者数据不一致。这意味着你需要使用互斥锁（

std::mutex

登录后复制

）或其他同步原语来保护对内存池数据结构的访问。当然，锁本身会引入开销，所以设计高效的无锁或细粒度锁的内存分配器是一个高级课题，比如使用原子操作或者线程局部存储（TLS）来减少锁的竞争。

别忘了异常安全。当

operator new

登录后复制

分配失败时，它应该抛出

std::bad_alloc

登录后复制

异常。如果你的自定义分配器没有正确处理这种情况，或者在分配过程中发生了其他异常而没有清理好状态，都可能导致资源泄露或程序状态不一致。

最后，还有数组版本的

new[]

登录后复制

和
delete[]
登录后复制
。它们和单对象版本行为略有不同。

new[]

登录后复制

通常会额外分配一些空间来存储数组元素的数量，以便

delete[]

登录后复制

能够正确调用每个元素的析构函数。当你重载

new[]

登录后复制

和

delete[]

登录后复制

时，你需要确保你的分配器能够正确处理这个额外的头部信息。如果你的分配器只是简单地返回原始内存，那么

delete[]

登录后复制

可能会因为无法获取元素数量而行为异常。这就是为什么在上面的示例中，我也重载了

new[]

登录后复制

和

delete[]

登录后复制

。

处理这些陷阱，需要对C++内存模型、底层操作系统内存管理以及并发编程有扎实的理解。这是一个不断学习和迭代的过程。

构建一个基础的块分配器：自定义内存管理的实用起点

既然我们谈到了自定义内存管理器，那就不可能不提块分配器（Block Allocator）。在我看来，它是一个非常实用且相对容易上手的自定义内存管理方案，尤其适用于那些需要频繁分配和释放固定大小对象的场景。比如，游戏中的粒子、AI寻路节点、网络消息包等，它们通常大小固定且生命周期短暂。

一个简单的块分配器核心思想是：

预先分配一大块内存： 启动时，或者在需要时，一次性向操作系统请求一大块连续的内存（比如1MB、4MB）。这避免了频繁向操作系统请求小块内存的开销。
将大块内存切分成固定大小的“块”： 比如，如果你知道你主要分配128字节的对象，就把这1MB内存切分成若干个128字节的小块。
维护一个空闲块列表： 使用一个链表（或者其他数据结构）来管理所有当前可用的空闲内存块。每个空闲块的头部可以存储指向下一个空闲块的指针。

当请求分配内存时：

从空闲块列表中取出一个块，返回其地址。
如果空闲列表为空，说明当前预分配的内存块都用完了。这时候可以选择：
- 向操作系统请求另一大块内存，并将其切分后加入空闲列表。
- 或者，直接抛出
```
std::bad_alloc
```
  登录后复制
  异常，表示内存池已满。

当请求释放内存时：

将待释放的内存块重新添加到空闲块列表的头部。

下面是一个概念性的代码结构，展示了如何实现一个非常简陋的固定大小块分配器。它省略了线程安全、错误检查和更复杂的内存池管理（比如多个内存池、动态扩展），但足以说明其工作原理。

#include <cstddef> // for size_t
#include <iostream>

// 假设我们只分配固定大小的块，比如128字节
const size_t BLOCK_SIZE = 128;
const size_t NUM_BLOCKS = 100; // 预分配100个块

// 定义一个简单的空闲块结构，它会覆盖掉实际的数据
// 当一个块是空闲的时候，它的开头被用作指向下一个空闲块的指针
struct FreeBlock {
    FreeBlock* next;
};

// 我们的块分配器类
class FixedBlockAllocator {
private:
    char* _memoryPool; // 预分配的内存池
    FreeBlock* _freeList; // 空闲块链表

public:
    FixedBlockAllocator() : _memoryPool(nullptr), _freeList(nullptr) {
        // 预分配一大块内存
        _memoryPool = new char[BLOCK_SIZE * NUM_BLOCKS];
        if (!_memoryPool) {
            throw std::bad_alloc();
        }

        // 初始化空闲链表：将所有块串联起来
        for (size_t i = 0; i < NUM_BLOCKS; ++i) {
            FreeBlock* currentBlock = reinterpret_cast<FreeBlock*>(_memoryPool + i * BLOCK_SIZE);
            currentBlock->next = _freeList; // 将当前块指向之前的空闲列表头
            _freeList = currentBlock;       // 更新空闲列表头为当前块
        }
        std::cout << "FixedBlockAllocator initialized with " << NUM_BLOCKS << " blocks of " << BLOCK_SIZE << " bytes each." << std::endl;
    }

    ~FixedBlockAllocator() {
        delete[] _memoryPool;
        _memoryPool = nullptr;
        _freeList = nullptr; // 确保指针清空
        std::cout << "FixedBlockAllocator destroyed." << std::endl;
    }

    // 分配一个块
    void* allocate(size_t size) {
        if (size > BLOCK_SIZE) {
            // 如果请求的内存大小超过了我们块的大小，这个分配器无法处理
            // 实际中可能退化到调用全局new，或者抛出异常
            std::cerr << "Warning: Request size " << size << " exceeds block size " << BLOCK_SIZE << ". Cannot allocate." << std::endl;
            return nullptr;
        }

        if (!_freeList) {
            // 没有可用的空闲块了
            std::cerr << "Error: FixedBlockAllocator out of memory!" << std::endl;
            return nullptr; // 或者抛出 std::bad_alloc
        }

        FreeBlock* allocatedBlock = _freeList;
        _freeList = _freeList->next; // 更新空闲列表头
        std::cout << "Allocated a block." << std::endl;
        return allocatedBlock;
    }

    // 释放一个块
    void deallocate(void* ptr) {
        if (!ptr) return;

        // 简单检查ptr是否在我们内存池范围内 (实际需要更严格的检查)
        if (ptr < _memoryPool || ptr >= (_memoryPool + BLOCK_SIZE * NUM_BLOCKS)) {
            std::cerr << "Warning: Deallocating memory not from this allocator. Ignoring." << std::endl;
            return;
        }

        FreeBlock* freedBlock = reinterpret_cast<FreeBlock*>(ptr);
        freedBlock->next = _freeList; // 将释放的块加回空闲列表头
        _freeList = freedBlock;
        std::cout << "Deallocated a block." << std::endl;
    }
};

// 全局的块分配器实例
FixedBlockAllocator g_allocator;

// 重载全局的 new 和 delete，让它们使用我们的块分配器
void* operator new(size_t size) {
    return g_allocator.allocate(size);
}

void operator delete(void* p) noexcept {
    g_allocator.deallocate(p);
}

// 示例类，大小刚好是128字节 (为了演示方便)
struct MyData {
    char data[120]; // 加上VMT和padding，假设总共128字节
    int id;
    MyData(int _id = 0) : id(_id) { std::cout << "MyData " << id << " constructed." << std::endl; }
    ~MyData() { std::cout << "MyData " << id << " destructed." << std::endl; }
};

int main() {
    std::cout << "--- Using custom fixed block allocator ---" << std::endl;
    MyData* obj1 = new MyData(1);
    MyData* obj2 = new MyData(2);
    MyData* obj3 = new MyData(3);

    delete obj1;
    delete obj2;

    MyData* obj4 = new MyData(4); // 应该复用之前释放的块

    // 尝试分配一个过大的对象，会失败
    // struct LargeData { char big_data[200]; };
    // LargeData* bigObj = new LargeData(); // 这会打印错误信息并返回nullptr

    delete obj3;
    delete obj4;

    // 此时，所有块应该都已回到空闲列表
    return 0;
}

登录后复制

这个例子展示了块分配器的基本工作模式：预分配、切分、通过空闲列表管理。它的优点在于分配和释放的速度极快，因为它们仅仅是链表头部的操作，几乎是O(1)复杂度，并且完全消除了内存碎片问题（对于固定大小的块而言）。当然，它的缺点也很明显：只能分配特定大小的内存，如果请求大小不匹配，它就无能为力了。

实际的生产级内存管理器会复杂得多，比如会包含多个不同大小的内存池、内存池的动态扩展、线程局部缓存、以及更精细的错误处理和调试工具。但这个基础的块分配器，无疑是理解自定义内存管理一个非常好的切入点。

以上就是如何实现自定义内存管理器重载new和delete操作符示例的详细内容，更多请关注php中文网其它相关文章！