C++手写内存池，原理：

申请一大块内存，切分成多个小块内存，各个小块内存用链表串连起来；

freeList就是链表头。

每次需要内存时，从链表头拿走一块空闲内存，链表头向后移动。

每次归还内存时，链表头指向归还的内存，这块归还的内存则指向原来的链表头。

相当于插入和删除都是从链表头进行的。

#include <iostream>
using namespace std;

class MemoryPool {
private:
    struct Block {
        Block* next;
    };
    Block* freeList;
    void *pool;
    size_t blockSize;
    size_t blockCount;
public:
    MemoryPool(int blockSize, int blockCount): freeList(nullptr), pool(nullptr), blockSize(blockSize), blockCount(blockCount) {
        if (blockSize < sizeof(Block)) {
            blockSize = sizeof(Block);
        }
        pool = ::operator new(blockCount * blockSize);
        char *start = static_cast<char *>(pool);
        for (size_t i = 0; i < blockCount; ++i) {
            Block *block = reinterpret_cast<Block *>(start + i * blockSize);
            block->next = freeList;
            freeList = block;
        }
    }
    ~MemoryPool() {
        ::operator delete(pool);
    }
    void* allocate() {
        if (!freeList) {
            throw std::bad_alloc();
        }
        Block* block = freeList;
        freeList = freeList->next;
        return block;
    }

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

struct MyObject {
    int x, y;
};

int main() {
    MemoryPool pool(sizeof(MyObject), 10);
    void *mem = pool.allocate();
    MyObject *obj = new(mem) MyObject{1, 2};
    std::cout << obj->x << ", " << obj->y << std::endl;
    // 手动析构 + 归还内存
    obj->~MyObject();
    pool.deallocate(obj);
    return 0;
}