Allocate memory for polymorphic object with allocator - c++

Question

Very simple question - how to allocate and deallocate memory via allocator, for polymorphic object? Okay, allocate memory is not a big problem:
SomeAllocator::rebind<Child>::other allocator;
Parent*pointer=allocator.allocate(1);
new(pointer) Child;
For deallocate this memory, I should call SomeAllocator::rebind<Child>::other::deallocate... Or SomeAllocator::rebind<GrandChild>::other::deallocate? It's polymorphic object and I don't know what exactly type he have. So, I don't know what allocator I must call. I can imagine some tricks. For example - allocate and deallocate memory via std::allocator<char>().allocate(sizeof(ObjectType)) and std::allocator<char>().deallocate((char*)pointer,sizeof(ObjectType)). But this trick throw away any potential optimizations like "this allocator use pool of Child objects". Plus, in polymorphic object, I don't know sizeof for this object. So, I must save this size somewhere. After allocate implementation already save it (of course, only in 99% cases, where allocate() - just redirect to malloc, lol). It don't see this as very good practice. Also, I can use virtual functions like:
virtual void Child::destroy(){
~Child();
SomeAllocator::rebind<Child>::other().deallocate(this,1);
}
But it's also not very good idea, because I must duplicate this code in all derivate classes.
So, what is best decision for allocate and deallocate memory for polymorphic object vis allocators?
PS Sorry if my English is bad.

Answer 1

I would think about using a concept/model idiom.
The concept defines the concepts (services) available on the common interface, the model describes the implementation of handling the allocator conversion and storage.
e.g.:
#include <memory>
struct I
{
virtual ~I() = default;
};
struct A : I
{
int x, y, z;
};
struct B : I
{
int a, b, c, x, y, z;
};
template<class T> struct tag {};
struct IPtr
{
struct concept
{
template<class T> void construct(void * addr)
{
ptr_ = new (addr) T ();
}
virtual void dealloc() = 0;
void destroy()
{
ptr_->~I();
dealloc();
}
void* mem_ = nullptr;
I* ptr_ = nullptr;
};
template<class T, class Allocator>
struct model : concept
{
model(Allocator alloc)
: alloc_(alloc)
{
using A2 = typename Allocator::template rebind<T>::other;
auto a2 = A2(alloc_);
mem_ = a2.allocate(1);
ptr_ = new (mem_) T ();
}
virtual void dealloc() override
{
using A2 = typename Allocator::template rebind<T>::other;
auto a2 = A2(alloc_);
a2.deallocate(reinterpret_cast<typename A2::pointer>(mem_), 1);
}
Allocator alloc_;
};
template<class T, class Allocator>
IPtr(tag<T>, Allocator alloc)
: impl_(new model<T, Allocator>(alloc))
{
}
IPtr(IPtr&& r)
: impl_(r.impl_)
{
r.impl_ = nullptr;
}
~IPtr()
{
if (impl_) {
impl_->destroy();
delete impl_;
}
}
private:
concept* impl_;
};
int main()
{
auto alloc = std::allocator<int>();
auto a = IPtr(tag<A>(), alloc);
auto b = IPtr(tag<B>(), alloc);
a;
b;
}