我如何将 scoped_allocator_adaptor 与自定义分配器（包装在 class 中）一起使用，以便它可以针对某些类型而不是 STL 容器展开？

Question

我不知道如何更好地表达我的问题。

我对 std::scoped_allocator_adaptor 的理解是，它会将分配器实例传递给容器并将其用于通过 emplace_back 在容器中构建的 elements/containers 的构造，如果它们需要这样的分配器参数）。

我有以下内容，它有点冗长，但这是我能做到的最低限度说明我正在尝试做的事情：

#include <cstdint>
#include <cstdlib>
#include <memory>
#include <vector>
#include <scoped_allocator>
#include <concepts>

namespace custom_memory
{
    class CustomAllocator
    {
    public:
        CustomAllocator(const std::size_t sizeBytes,
                        void* const start)
        :
            m_sizeBytes(sizeBytes),
            m_usedBytes(0),
            m_start(start),
            m_current(start)
        {

        }

        void* Allocate(const std::size_t& numBytes,
                       const std::uintptr_t& alignment)
        {
            std::size_t space = m_sizeBytes - m_usedBytes;
            if(std::align(alignment, numBytes, m_current, space))
            {
                // the amount used for alignment
                m_usedBytes += (m_sizeBytes-m_usedBytes) - space;
                // the amount actually needed
                m_usedBytes += numBytes;

                void* address = m_current;

                m_current = reinterpret_cast<void*>(
                    reinterpret_cast<std::uintptr_t>(m_current) + numBytes);

                return address;
            }
            throw std::bad_alloc();
        }

        void Free(void* const ptr)
        {
            // do nothing in this Allocator, but other derived types may
        }

        void Clear()
        {
            m_current = m_start;
            m_usedBytes = 0;
        }

        std::size_t GetSize() const { return m_sizeBytes; }

    protected:
        const std::size_t m_sizeBytes;
        std::size_t m_usedBytes;
        void* const m_start;
        void* m_current;
    };
    // many types derive from base CustomAllocator type

    // allows for my custom allocators to be used in STL containers
    template<typename T, typename Alloc>
    class STLAdaptor
    {
    public:

        typedef T value_type;


        STLAdaptor(Alloc* allocator)
        :
            m_allocator(allocator)
        {

        }

        [[nodiscard]] constexpr T* allocate(std::size_t n)
        {
            return reinterpret_cast<T*>
                (m_allocator->Allocate(n * sizeof(T), alignof(T)));
        }

        constexpr void deallocate(T* p, std::size_t n)
        {
            m_allocator->Free(p);
        }

        std::size_t MaxAllocationSize() const
        {
            return m_allocator->GetSize();
        }

    protected:
        Alloc* m_allocator;
    };

    template<typename T, typename Allocator>
    using vector = std::vector<T,
        std::scoped_allocator_adaptor<STLAdaptor<T, Allocator>>>;
}

// overloads of global new and delete so I can use them with
// my custom allocators
void* operator new(std::size_t size, custom_memory::CustomAllocator& allocator,
                   std::uintptr_t alignment)
{
    return allocator.Allocate(size, alignment);
}

void operator delete(void* ptr, custom_memory::CustomAllocator& allocator)
{
    allocator.Free(ptr);
}

// a type that needs an allocator for it's own internal use
template<typename A>
requires std::derived_from<A, custom_memory::CustomAllocator>
struct Foo
{
    A* m_allocator;
    int* m_foos;

    Foo(A* a)
    :
        m_allocator(a),
        m_foos(new (*a, alignof(int)) int(7))
    {

    }

    Foo(const Foo<A>& other)
    :
        m_allocator(other.m_allocator),
        m_foos(new (*m_allocator, alignof(int)) int(*(other.m_foos)))
    {

    }

    ~Foo()
    {
        operator delete (m_foos, *m_allocator);
    }

    Foo<A>& operator=(const Foo<A>& rhs)
    {
        m_allocator = rhs.m_allocator;
        *m_foos = *(rhs.m_foos);

        return *this;
    }
};

int main()
{
    const std::size_t memSize = 10000000;
    void* mem = std::malloc(memSize);

    typedef Foo<custom_memory::CustomAllocator> FooType;

    custom_memory::CustomAllocator customAlloc(memSize, mem);

    // this works
    {
        std::vector<FooType, custom_memory::STLAdaptor<FooType,
            custom_memory::CustomAllocator>>
            vec(&customAlloc);

        vec.emplace_back(&customAlloc);
    }

    // this works
    {
        custom_memory::vector<FooType,custom_memory::CustomAllocator>
            vec(&customAlloc);

        vec.emplace_back(&customAlloc); // <-- I don't want to pass this
    }

    // this doesn't work
    {
        custom_memory::vector<FooType,custom_memory::CustomAllocator>
            vec(&customAlloc);

        vec.emplace_back(); // <--- I thought scoped_allocator_adaptor
                            // would pass the allocator to constructed
                            // elements?
    }

    // this also doesn't work
    {
        typedef std::basic_string<char, std::char_traits<char>,
        custom_memory::STLAdaptor<char, custom_memory::CustomAllocator>>
        StringType;

        custom_memory::vector<StringType,custom_memory::CustomAllocator>
            vec(&customAlloc);

        vec.emplace_back("string");
    }

    std::free(mem);

    return 0;
}

我有一个 CustomAllocator 派生自一个基类（未显示），并且有许多不同的分配器派生自该基类。

我有一个 STLAdaptor 允许 CustomAllocator 在 STL 容器中使用。这是一个模板化的 class，因为上面提到了很多不同的分配器（我实际上有 STLAdaptor 的专门化以及不同的分配器，未显示）。

我已经尝试 typedef 一个 std::vector，它使用我的 STLAdaptor 包裹 CustomAllocator 在 std::scoped_allocator_adaptor.

然后我重载全局 new 和 delete 以接受 CustomAllocator 进行分配。

最后，我有一个需要 CustomAllocator 的 class，它在内部使用它为内部类型分配内存（这是我的用例）。

你可以在我的测试中看到我可以：

制作一个成功使用我的 STLAdaptor 包装的 CustomAllocator 的 std::vector。我可以用 Foo<CustomerAllocator> 类型填充它。
我可以使用我的 std::scoped_allocator_adaptor std::vector 的 typedef。但是我需要明确地将 CustomAllocator 实例传递给内部类型
我不能省略，但我愿意
我也想使用其他STL容器

我很确定问题是 std::scoped_allocator_adaptor 有一个 STLAdaptor 分配器，而不是 CustomAllocator。但是后来我也无法让它与 std::string 一起工作，但我认为这与 std::vector 和 std::string 之间具有不同类型的 STLAdaptor 有关（这是 rebind 发挥作用的地方吗？

我正在使用 GCC 10.2.0 和 C++20

如有任何帮助，我们将不胜感激。

Answer 1

I am pretty sure the problem is that std::scoped_allocator_adaptor has an STLAdaptor allocator, not a CustomAllocator.

就目前而言，这是正确的。 scoped_allocator_adaptor 将传递它所拥有的，而不是它不知道的其他类型。

此外，scoped_allocator_adaptor 将使用 uses_allocator 来确定类型是否使用分配器。该特征默认查看类型是否定义了分配器可以转换为的成员类型allocator_type。

But then I can't get it to work with an std::string either, but I think that has to do with the STLAdaptor having different types between the std::vector and the std::string (is this where rebind comes into play?

正确。 STLAdaptor 不符合 the allocator requirements.

我如何将 scoped_allocator_adaptor 与自定义分配器（包装在 class 中）一起使用，以便它可以针对某些类型而不是 STL 容器展开？

How can I use scoped_allocator_adaptor with a custom allocator (wrapped in a class) so that it can be unwrapped for some types but not STL containers?

c++

memory-management

template-specialization

c++20

allocator