C++内存碎片如何减少 自定义分配器与内存池设计实践

class MyClass {
public:
    void* operator new(size_t size) {
        // 自定义分配逻辑
        return my_custom_allocator.allocate(size);
    }

    void operator delete(void* ptr) {
        // 自定义释放逻辑
        my_custom_allocator.deallocate(ptr);
    }

private:
    static MyAllocator my_custom_allocator;
};

template <typename T>
class MemoryPool {
public:
    MemoryPool(size_t size) : pool_size(size), memory(new char[size * sizeof(T)]), free_list(nullptr) {
        // 初始化内存池
        char* current = memory;
        for (size_t i = 0; i < size; ++i) {
            T* obj = reinterpret_cast<T*>(current);
            obj->~T(); // placement new 需要手动析构
            *reinterpret_cast<T**>(obj) = free_list; // 将当前块链接到 free list
            free_list = obj;
            current += sizeof(T);
        }
    }

    ~MemoryPool() {
        delete[] memory;
    }

    T* allocate() {
        if (free_list == nullptr) {
            return nullptr; // 内存池已满
        }
        T* obj = free_list;
        free_list = *reinterpret_cast<T**>(free_list); // 从 free list 中移除
        return obj;
    }

    void deallocate(T* ptr) {
        *reinterpret_cast<T**>(ptr) = free_list; // 将 ptr 添加到 free list
        free_list = ptr;
    }

private:
    char* memory;
    T* free_list;
    size_t pool_size;
};

MemoryPool<MyClass> pool(100); // 创建一个可以容纳100个 MyClass 对象的内存池
MyClass* obj = pool.allocate(); // 从内存池中分配一个 MyClass 对象
if (obj) {
  // 使用 obj
  pool.deallocate(obj); // 释放 obj
}