c++如何自定义STL容器的内存分配器_c++自定义allocator实现讲解

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;'>// 支持不同类型的rebind
template<typename U>
struct rebind {
    using other = MyAllocator<U>;
};

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

// 分配未初始化内存
pointer allocate(size_type n) {
    void* ptr = ::operator new(n * sizeof(T));
    return static_cast<pointer>(ptr);
}

// 释放内存
void deallocate(pointer p, size_type) {
    ::operator delete(p);
}

// 构造对象
void construct(pointer p, const T& val) {
    new(p) T(val); // placement new
}

// 析构对象
void destroy(pointer p) {
    p->~T();
}

#include <iostream>
#include <vector>
<p>int main() {
std::vector<int, MyAllocator<int>> vec;
vec.push_back(10);
vec.push_back(20);
vec.push_back(30);</p><pre class='brush:php;toolbar:false;'>for (const auto& v : vec) {
    std::cout << v << " ";
}
std::cout << "\n";
return 0;

class PoolAllocator {
    static constexpr size_t BLOCK_SIZE = 1024;
    char* pool = nullptr;
    size_t used = 0;
<p>public:
template<typename T>
struct allocator {
using value_type = T;</p><pre class='brush:php;toolbar:false;'>    PoolAllocator* pool_alloc;

    allocator(PoolAllocator* pa) : pool_alloc(pa) {}

    template<typename U>
    allocator(const allocator<U>& other)
        : pool_alloc(other.pool_alloc) {}

    T* allocate(std::size_t n) {
        if (n != 1 || sizeof(T) > BLOCK_SIZE) {
            throw std::bad_alloc();
        }
        if (pool_alloc->used + sizeof(T) > BLOCK_SIZE) {
            throw std::bad_alloc(); // 简化处理
        }
        void* ptr = pool_alloc->pool + pool_alloc->used;
        pool_alloc->used += sizeof(T);
        return static_cast<T*>(ptr);
    }

    void deallocate(T*, std::size_t) {
        // 实际项目中可实现回收机制
    }
};