c++ allocator 如何设置分配策略

在C++中，分配器（allocator）是用于管理内存的模板类，它允许用户自定义内存分配和释放的行为。C++标准库提供了一些预定义的分配器，如std::allocator，但用户也可以创建自定义分配器以满足特定需求。

要设置自定义分配策略，您需要定义一个分配器类，并重写其allocate和deallocate成员函数。以下是一个简单的示例，展示了如何创建一个自定义分配器，该分配器使用固定大小的内存块：

#include <iostream>
#include <memory>

template <typename T>
class FixedSizeAllocator {
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;

    FixedSizeAllocator() noexcept {}

    template <typename U>
    FixedSizeAllocator(const FixedSizeAllocator<U>&) noexcept {}

    pointer allocate(size_type n, const void* hint = 0) {
        if (n > max_size()) {
            throw std::bad_alloc();
        }

        pointer result = static_cast<pointer>(::operator new(n * sizeof(T)));
        if (!result) {
            throw std::bad_alloc();
        }

        return result;
    }

    void deallocate(pointer p, size_type n) noexcept {
        ::operator delete(p);
    }

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

    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();
    }
};

int main() {
    FixedSizeAllocator<int> allocator;
    int* arr = allocator.allocate(10);

    for (int i = 0; i < 10; ++i) {
        allocator.construct(arr + i, i);
    }

    for (int i = 0; i < 10; ++i) {
        std::cout << *(arr + i) << ' ';
    }

    for (int i = 0; i < 10; ++i) {
        allocator.destroy(arr + i);
    }

    allocator.deallocate(arr, 10);

    return 0;
}

在这个示例中，FixedSizeAllocator类重写了allocate和deallocate成员函数，以便使用固定大小的内存块分配和释放内存。allocate函数接受一个大小参数n，并尝试分配足够的连续内存来存储n个T类型的对象。如果分配失败，它将抛出一个std::bad_alloc异常。

请注意，这个示例仅用于演示目的，实际应用中可能需要根据具体需求调整分配策略。