Do C++17 and newer std::allocators work for a dynamic number of custom heaps?

Question

Here is my scenario:

There is a set of Instance objects, the number of the objects being determined at run time.

For each of those instances, a custom heap is created. (Yes, I refer to ::HeapCreate() et. all win32 functions).

struct Instance
{
   HANDLE heap;
};

Now, there is some Instance specific State object which has access (a pointer) to the Instance. Its a 1:1 relationship. 1 State per Instance.

struct State
{
    Instance * inst;

};

In that State, I want to use STL containers like std::vector and alike, but I want those to use an allocator, which uses the heap created by the instance.

Reading up on the history of std::allocator from the times of C++98 up to C++17 and newer, some old requirements have been dropped, but my take away is, that it is not possible to write such an allocator for my above shown use case. Given that the Allocator would be of the same type each time, but stateful (as in instances using different heap HANDLEs).

So here my question(s):

• Can I/ should I even try to use the STL allocator stuff for this use case or better just roll my select few own container classes instead?
• I stumbled across that std::pmr C++17 namespace and wonder if there is stuff in there I am not yet acquainted with, which would help me with my use case.

Your answers will be very valuable if you show the "idiomatic" way how to solve this problem in modern (c++17 and newer) C++.

Here, my incomplete and current "work in progress". I will fill in more over time, based on answers and comments and my own progress.

#include <Windows.h>

struct custom_heap_allocator
{
    HANDLE heap;

    // No default constructor
    custom_heap_allocator() = delete;

    // an instance is tied to a heap handle.
    explicit custom_heap_allocator(HANDLE h)
        : heap{ h }
    {

    }

    // can I get away with this....

    // copy constructor for same type.
    custom_heap_allocator(const custom_heap_allocator& other)
        : heap{ other.heap }
    {

    }

    //... or do I need something like this? Or is it somehow covered by rebind?
    //template<class U>
    //custom_heap_allocator(const custom_heap_allocator<U>& other)
    //  : heap{ other.heap }
    //{

    //}

    template<class U>
    struct rebind {
        typedef custom_heap_allocator other;
    };
};

template <class T, class U>
constexpr bool operator== (const custom_heap_allocator& a1, const custom_heap_allocator& a2) noexcept
{
    return a1.heap == a2.heap;
}

template <class T, class U>
constexpr bool operator!= (const custom_heap_allocator& a1, const custom_heap_allocator& a2) noexcept
{
    return a1.heap != a2.heap;
}

Note: shutting down an Instance will simply destroy the heap (no need to call destructors for stuff still on the heap, as those are just simple data and not system resources etc. And all dynamic stuff they hold are also from the same heap instance).

Answer 1

Here is a more complete version of the allocator from your (edited) question.

Some basic unit tests using std::vector and std::list at cpp.sh/4viaj

template<typename T>
struct custom_heap_allocator
{
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;

    // No default constructor
    custom_heap_allocator() = delete;

    // An instance is tied to a heap handle.
    explicit custom_heap_allocator(HANDLE h)
        : heap{ h }
    {
    }

    // Instances are copy-constructable and copy-assignable.
    custom_heap_allocator(const custom_heap_allocator&) = default;
    custom_heap_allocator& operator=(const custom_heap_allocator&) = default;

    // All related allocators share the same heap, regardless of type.
    template<class U>
    custom_heap_allocator(const custom_heap_allocator<U>& other)
      : heap{ other.heap }
    {
    }

    // Allocate and deallocate space for objects using the heap.
    T* allocate(size_t n) {
        return static_cast<T*>(HeapAlloc(heap, 0, sizeof(T) * n)); 
    }
    void deallocate(T* ptr, size_t n) {
        HeapFree(heap, 0, ptr);
    }

    // Construct and destroy objects in previously allocated space.
    // This *should* be optional and provided by std::allocator_traits,
    // but it looks like some std containers don't use the traits.
    template< class U, class... Args >
    void construct( U* p, Args&&... args ) {
        ::new((void *)p) U(std::forward<Args>(args)...);
    }
    template< class U >
    void destroy( U* p ) {
        p->~U();
    }

    // Template for related allocators of different types.
    template<class U>
    struct rebind {
        typedef custom_heap_allocator<U> other;
    };

private:
    // Heap used for all allocations/deallocations.
    HANDLE heap;

    // Allow all related types to access our private heap.
    template<typename> friend struct custom_heap_allocator;
};