class MemoryPool {
private:
    struct Block {
        Block* next;
    };
<pre class='brush:php;toolbar:false;'>char*   memory_;        // 池的起始地址
Block*  free_list_;     // 空闲块链表
size_t  block_size_;    // 每个对象占用大小
size_t  pool_size_;     // 总共可容纳对象数
bool    initialized_;

public: MemoryPool(size_t block_size, size_t num_blocks) : blocksize(block_size), poolsize(numblocks), initialized(false) { // 分配总内存：每个块至少能放下一个指针用于链接 if (blocksize )) { blocksize = sizeof(Block); }

    memory_ = new char[block_size_ * num_blocks];
    free_list_ = nullptr;

    // 构建空闲链表：将所有块链接起来
    for (int i = num_blocks - 1; i >= 0; --i) {
        Block* block = reinterpret_cast<Block*>(memory_ + i * block_size_);
        block->next = free_list_;
        free_list_ = block;
    }
    initialized_ = true;
}

~MemoryPool() {
    delete[] memory_;
    memory_ = nullptr;
    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) return;
    Block* block = static_cast<Block*>(ptr);
    block->next = free_list_;
    free_list_ = block;
}

};

class MyObject {
private:
    static MemoryPool pool_;
    int data_[10];
<p>public:
MyObject(int x = 0) { data_[0] = x; }
~MyObject() {}</p><pre class='brush:php;toolbar:false;'>void* operator new(size_t size) {
    return pool_.allocate();
}

void operator delete(void* ptr) {
    if (ptr) pool_.deallocate(ptr);
}

// 静态成员定义
static void* operator new[](size_t) = delete;
static void operator delete[](void*) = delete;

};

// 静态初始化 MemoryPool MyObject::pool_(sizeof(MyObject), 100);