#include <iostream>
#include <vector>
#include <memory>  // for allocator_traits
#include <cstdlib> // for malloc, free

template <typename T>
class SimpleMallocAllocator {
public:
    using value_type = T;

    T* allocate(std::size_t n) {
        std::cout << "Allocate " << n << " objects of size " << sizeof(T) << std::endl;
        // 使用malloc分配原始内存，自动处理对齐（malloc保证至少对齐到sizeof(void*)）
        void* ptr = std::malloc(n * sizeof(T));
        if (!ptr) throw std::bad_alloc();
        return static_cast<T*>(ptr);
    }

    void deallocate(T* p, std::size_t n) noexcept {
        std::cout << "Deallocate " << n << " objects" << std::endl;
        std::free(p);
    }

    // 为了让容器知道所有相同模板参数的分配器是相等的
    template <typename U>
    bool operator==(const SimpleMallocAllocator<U>&) const { return true; }
    template <typename U>
    bool operator!=(const SimpleMallocAllocator<U>&) const { return false; }
};

int main() {
    std::vector<int, SimpleMallocAllocator<int>> vec;
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    std::cout << "Vector size: " << vec.size() << std::endl;
    return 0;
}

Allocate 1 objects of size 4
Allocate 2 objects of size 4
Allocate 4 objects of size 4
Deallocate 4 objects
Deallocate 1 objects

template <typename T>
class IDedAllocator {
    int id_;  // 每个分配器实例有一个ID
public:
    using value_type = T;

    explicit IDedAllocator(int id) : id_(id) {}
    // 默认构造（无参）不推荐，但有时需要，可赋默认ID
    IDedAllocator() : id_(0) {}

    T* allocate(std::size_t n) {
        void* ptr = std::malloc(n * sizeof(T));
        if (!ptr) throw std::bad_alloc();
        std::cout << "Allocator ID=" << id_ << " allocate " << n << " objects\n";
        return static_cast<T*>(ptr);
    }
    void deallocate(T* p, std::size_t n) noexcept {
        std::cout << "Allocator ID=" << id_ << " deallocate\n";
        std::free(p);
    }

    // 只有ID相同的分配器才相等
    bool operator==(const IDedAllocator& other) const { return id_ == other.id_; }
    bool operator!=(const IDedAllocator& other) const { return id_ != other.id_; }

    // 注意：当容器拷贝时，如何传递ID？标准做法是通过rebind的构造函数
    // 但简化起见，我们这里仅演示概念
};

#include <iostream>
#include <vector>
#include <cstddef>
#include <new>  // for bad_alloc

// 全局统计变量（可改为静态成员）
static std::size_t total_allocated = 0;   // 总分配字节数
static std::size_t allocation_count = 0;  // 分配次数

template <typename T>
class StatsAllocator {
public:
    using value_type = T;

    T* allocate(std::size_t n) {
        void* ptr = std::malloc(n * sizeof(T));
        if (!ptr) throw std::bad_alloc();
        total_allocated += n * sizeof(T);
        ++allocation_count;
        std::cout << ">>> Allocate " << n << " objects, total bytes=" << total_allocated
                  << ", count=" << allocation_count << "\n";
        return static_cast<T*>(ptr);
    }

    void deallocate(T* p, std::size_t n) noexcept {
        std::cout << "<<< Deallocate " << n << " objects\n";
        std::free(p);
    }

    // 无状态分配器，所有实例相等
    template <typename U>
    bool operator==(const StatsAllocator<U>&) const { return true; }
    template <typename U>
    bool operator!=(const StatsAllocator<U>&) const { return false; }
};

int main() {
    std::vector<int, StatsAllocator<int>> scores;  // 考试分数，用自定义分配器
    scores.push_back(85);
    scores.push_back(92);
    scores.push_back(78);

    // 打印总统计
    std::cout << "\nFinal statistics:\n";
    std::cout << "Total allocated bytes: " << total_allocated << "\n";
    std::cout << "Allocation count: " << allocation_count << "\n";

    return 0;
}

>>> Allocate 1 objects, total bytes=4, count=1
>>> Allocate 2 objects, total bytes=12, count=2
>>> Allocate 4 objects, total bytes=28, count=3
<<< Deallocate 1 objects
<<< Deallocate 2 objects
<<< Deallocate 4 objects

Final statistics:
Total allocated bytes: 28
Allocation count: 3

class ObjectPool:
    def __init__(self, cls, max_size=10):
        self.cls = cls
        self.pool = []
        self.max_size = max_size

    def acquire(self, *args, **kwargs):
        if self.pool:
            obj = self.pool.pop()
            # 重新初始化对象（如有需要）
            obj.__init__(*args, **kwargs)  # 注意：这可能会产生副作用
            return obj
        else:
            return self.cls(*args, **kwargs)

    def release(self, obj):
        if len(self.pool) < self.max_size:
            self.pool.append(obj)
        else:
            del obj

# 使用示例
class MyClass:
    def __init__(self, val):
        self.val = val

pool = ObjectPool(MyClass, 5)
obj1 = pool.acquire(10)   # 新建
pool.release(obj1)
obj2 = pool.acquire(20)   # 从池中取出，覆盖val
print(obj2.val)  # 20