STL中的allocator有什么作用 自定义内存分配策略实现方法

std::allocator

new

delete

#include <iostream>
#include <memory>
#include <vector>

template <typename T>
class PoolAllocator {
public:
    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;

    PoolAllocator() : pool_(nullptr), pool_size_(0), current_(nullptr) {}

    PoolAllocator(size_t pool_size) : pool_size_(pool_size) {
        pool_ = static_cast<T*>(::operator new(sizeof(T) * pool_size));
        current_ = pool_;
    }

    template <typename U>
    PoolAllocator(const PoolAllocator<U>& other) : pool_(nullptr), pool_size_(0), current_(nullptr) {}


    ~PoolAllocator() {
        if (pool_) {
            // 析构已构造的对象 (注意：必须手动析构)
            for (T* p = pool_; p < current_; ++p) {
                p->~T();
            }
            ::operator delete(pool_);
        }
    }

    pointer allocate(size_type n) {
        if (n != 1) throw std::bad_alloc(); // 只分配单个对象
        if (current_ == pool_ + pool_size_) {
            throw std::bad_alloc(); // 内存池已满
        }
        return current_++;
    }

    void deallocate(pointer p, size_type n) {
        // 不实际释放内存，仅用于后续复用
        // 在析构函数中统一释放
    }

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

    void destroy(pointer p) {
        p->~T();
    }

    size_type max_size() const {
        return pool_size_;
    }

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

private:
    T* pool_;
    size_t pool_size_;
    T* current_;
};

template <typename T, typename U>
bool operator==(const PoolAllocator<T>&, const PoolAllocator<U>&) {
    return true;
}

template <typename T, typename U>
bool operator!=(const PoolAllocator<T>&, const PoolAllocator<U>&) {
    return false;
}

int main() {
    PoolAllocator<int> alloc(10);
    std::vector<int, PoolAllocator<int>> vec(alloc);

    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
        std::cout << "Value: " << vec[i] << std::endl;
    }

    return 0;
}

std::allocator

#include <iostream>
#include <memory>
#include <mutex>

template <typename T>
class ThreadSafeAllocator {
public:
    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;

    ThreadSafeAllocator() {}

    template <typename U>
    ThreadSafeAllocator(const ThreadSafeAllocator<U>& other) {}

    ~ThreadSafeAllocator() {}

    pointer allocate(size_type n) {
        std::lock_guard<std::mutex> lock(mutex_);
        return static_cast<pointer>(::operator new(sizeof(T) * n));
    }

    void deallocate(pointer p, size_type n) {
        std::lock_guard<std::mutex> lock(mutex_);
        ::operator delete(p);
    }

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

    void destroy(pointer p) {
        p->~T();
    }

    size_type max_size() const {
        return std::numeric_limits<size_type>::max() / sizeof(T);
    }

    template <typename U>
    struct rebind {
        using other = ThreadSafeAllocator<U>;
    };

private:
    std::mutex mutex_;
};

template <typename T, typename U>
bool operator==(const ThreadSafeAllocator<T>&, const ThreadSafeAllocator<U>&) {
    return true;
}

template <typename T, typename U>
bool operator!=(const ThreadSafeAllocator<T>&, const ThreadSafeAllocator<U>&) {
    return false;
}

construct