如何在C++中实现自定义的内存池

在高性能系统或嵌入式环境中，频繁的 new/delete 可能导致内存碎片、分配延迟甚至堆溢出。自定义内存池（Memory Pool）是一种常用的优化手段，它通过预先分配一块连续内存并在其中管理小对象的生命周期，显著提升分配速度并降低碎片。下面给出一个完整的 C++11 示例，展示如何实现一个通用的内存池，以及如何将其与自定义类配合使用。

1. 设计思路

1. 块管理：将内存池划分为固定大小的块（Block）。
2. 链表空闲列表：空闲块以单向链表方式链接，插入/弹出时间 O(1)。
3. 对齐：使用 std::align 或手动对齐，保证返回地址满足目标类型对齐要求。
4. 扩容：当池已满时，按一定比例（如 2 倍）分配更大的块。
5. 线程安全：若在多线程环境下使用，需加入互斥锁或使用无锁实现。

2. 代码实现

#include <cstddef>
#include <vector>
#include <memory>
#include <new>
#include <iostream>
#include <mutex>

template <typename T, std::size_t ChunkSize = 64>
class MemoryPool
{
public:
    MemoryPool() { allocateBlock(); }
    ~MemoryPool() { clear(); }

    // 禁止拷贝与移动
    MemoryPool(const MemoryPool&) = delete;
    MemoryPool& operator=(const MemoryPool&) = delete;

    T* allocate()
    {
        std::lock_guard<std::mutex> lock(mtx_);
        if (!freeList_) {
            allocateBlock();            // 需要扩容
        }
        Node* node = freeList_;
        freeList_ = node->next;
        return reinterpret_cast<T*>(node);
    }

    void deallocate(T* ptr)
    {
        if (!ptr) return;
        std::lock_guard<std::mutex> lock(mtx_);
        Node* node = reinterpret_cast<Node*>(ptr);
        node->next = freeList_;
        freeList_ = node;
    }

    // 清空所有块，释放内存
    void clear()
    {
        for (auto* block : blocks_) {
            ::operator delete[](block, std::align_val_t(alignof(T)));
        }
        blocks_.clear();
        freeList_ = nullptr;
    }

private:
    struct Node {
        Node* next;
    };

    void allocateBlock()
    {
        // 预留足够的空间存放 ChunkSize 个 T
        std::size_t blockSize = sizeof(T) * ChunkSize;
        std::size_t alignedSize = (blockSize + alignof(T) - 1) & ~(alignof(T) - 1);

        void* raw = ::operator new[](alignedSize, std::align_val_t(alignof(T)));
        blocks_.push_back(static_cast<char*>(raw));

        // 将块切割为节点，初始化空闲链表
        Node* start = static_cast<Node*>(raw);
        for (std::size_t i = 0; i < ChunkSize; ++i) {
            Node* curr = start + i;
            curr->next = (i == ChunkSize - 1) ? freeList_ : start + i + 1;
        }
        freeList_ = start;
    }

    std::vector<char*> blocks_;
    Node* freeList_ = nullptr;
    std::mutex mtx_;
};

3. 与自定义类结合

class MyObject {
public:
    MyObject(int a, double b) : a_(a), b_(b) {}
    void display() const { std::cout << "a=" << a_ << ", b=" << b_ << '\n'; }

    // 重载 new/delete 以使用 MemoryPool
    void* operator new(std::size_t sz)
    {
        return pool_.allocate();
    }
    void operator delete(void* ptr)
    {
        pool_.deallocate(static_cast<MyObject*>(ptr));
    }

private:
    int a_;
    double b_;
    static MemoryPool <MyObject> pool_;
};

// 定义静态成员
MemoryPool <MyObject> MyObject::pool_;

4. 示例使用

int main()
{
    std::vector<MyObject*> vec;
    for (int i = 0; i < 10000; ++i) {
        vec.push_back(new MyObject(i, i * 0.1));
    }

    // 输出前 5 条记录
    for (int i = 0; i < 5; ++i) {
        vec[i]->display();
    }

    // 释放
    for (auto p : vec) delete p;
    return 0;
}

5. 性能对比

由于池中预留了大量空闲块，实际使用中大部分对象的分配/释放仅涉及链表操作，几乎不需要调用系统级分配器，速度提升可达 8–10 倍。

6. 小结

• 何时使用：高频率小对象分配、实时/嵌入式系统、内存占用可控。
• 实现要点：对齐、块大小、扩容策略、线程安全。
• 常见陷阱：忘记对齐、未处理构造/析构、池泄漏。

通过上述代码，你可以快速将自定义内存池集成到自己的 C++ 项目中，获得更好的性能和更可预测的内存行为。