C++内存池如何实现 自定义分配器开发指南

class MemoryPool {
private:
    struct Block {
        Block* next;
    };
    Block* free_list;
    char* memory;
    size_t block_size;
    size_t pool_size;
    size_t block_count;
<p>public:
MemoryPool(size_t count, size_t size)
: block_size((size + 7) & ~7), // 8字节对齐
pool_size(count * block_size),
block_count(count) {
memory = new char[pool_size];
free_list = nullptr;</p><pre class='brush:php;toolbar:false;'>    // 构建空闲链表
    for (size_t i = 0; i < count; ++i) {
        Block* block = reinterpret_cast<Block*>(memory + i * block_size);
        block->next = free_list;
        free_list = block;
    }
}

~MemoryPool() {
    delete[] memory;
    free_list = nullptr;
}

void* allocate() {
    if (!free_list) return nullptr;
    Block* block = free_list;
    free_list = free_list->next;
    return block;
}

void deallocate(void* ptr) {
    if (ptr) {
        Block* block = static_cast<Block*>(ptr);
        block->next = free_list;
        free_list = block;
    }
}

template<typename T, size_t N = 1024>
class PoolAllocator {
public:
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
<pre class='brush:php;toolbar:false;'>template<typename U>
struct rebind {
    using other = PoolAllocator<U, N>;
};

pointer allocate(size_type n) {
    if (n != 1 || sizeof(T) * n != sizeof(T)) {
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    return static_cast<T*>(get_pool()->allocate());
}

void deallocate(pointer p, size_type n) {
    if (n != 1) {
        ::operator delete(p);
        return;
    }
    get_pool()->deallocate(p);
}

template<typename U, typename... Args>
void construct(U* p, Args&&... args) {
    new(p) U(std::forward<Args>(args)...);
}

void destroy(pointer p) {
    p->~T();
}

bool operator==(const PoolAllocator&) const { return true; }
bool operator!=(const PoolAllocator&) const { return false; }

std::vector<int, PoolAllocator<int, 512>> vec;
vec.push_back(1);
vec.push_back(2);