template <typename T>
struct MyAllocator {
    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 = MyAllocator<U>;
};

MyAllocator() = default;

template <typename U>
MyAllocator(const MyAllocator<U>&;) {}

pointer allocate(size_type n) {
    if (n == 0) return nullptr;
    pointer p = static_cast<pointer>(::operator new(n * sizeof(T)));
    // 可添加日志或统计
    return p;
}

void deallocate(pointer p, size_type n) {
    ::operator delete(p);
    // 可记录释放信息
}

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

template <typename U>
void destroy(U* p) {
    p->~U();
}

};

std::vector<int, MyAllocator<int>> vec;
vec.push_back(10);
vec.push_back(20);

template <typename T, size_t BlockSize = 4096>
class PoolAllocator {
private:
    struct Block {
        std::aligned_storage_t<BlockSize> data;
    };
<pre class='brush:php;toolbar:false;'>union Node {
    T data;
    Node* next;
};

Node* free_list = nullptr;
std::vector<Block> blocks;
size_t current_offset = 0;

public: using value_type = T; using pointer = T; using const_pointer = const T; using size_type = std::size_t;

template <typename U>
struct rebind {
    using other = PoolAllocator<U, BlockSize>;
};

PoolAllocator() = default;

~PoolAllocator() = default;

pointer allocate(size_type n) {
    if (n != 1) {
        throw std::bad_alloc{};
    }
    if (!free_list) {
        refill_pool();
    }
    Node* p = free_list;
    free_list = free_list->next;
    return reinterpret_cast<pointer>(p);
}

void deallocate(pointer p, size_type n) {
    if (n != 1 || !p) return;
    Node* node = reinterpret_cast<Node*>(p);
    node->next = free_list;
    free_list = node;
}

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

template <typename U>
void destroy(U* p) {
    p->~U();
}

private: void refill_pool() { Block& block = blocks.emplace_back(); char start = reinterpret_cast>(&block.data); const size_t nodes_per_block = BlockSize / sizeof(Node); Node nodes = reinterpret_cast>(start);

    for (size_t i = 0; i < nodes_per_block - 1; ++i) {
        nodes[i].next = &nodes[i + 1];
    }
    nodes[nodes_per_block - 1].next = nullptr;

    free_list = &nodes[0];
}

};