用模板化 function 覆盖虚拟 function

Question

I've got a base class with a pure virtual function:

class Allocator 
{
public:
    template< class T >
    virtual T* allocate(T type) = 0;
};

with a derived class with a templated function which the design intent was to override this virtual function:

class StackAllocator: public Allocator 
{
public: 
    StackAllocator(size_t size, void* stackStart = nullptr);

    template< class T>
    T* allocate(T Type);
};

My design intent was to have allocate override the allocate in Allocator. But obviously after reading up on this, i have found the code above will not work.

I found alot of solutions that involve making the class itself a template, but in this situation i can't do this as the StackAllocator itself needs to be type-agnostic at compile. And only the function should deal with the varying types.

I found a work-around that involved making an 'allocation' class that was used on a per allocation basis that dealt with the allocation itself, but this seemed wasteful and not very clear in its application so now i'm stuck with simply getting rid of the virtual function and using just the derived class templated function.

Any ideas how i could do this? or ideas for how to rework my design? (bear in mind that i will be eventually making many more derived allocators so the base is necessary.)

Thanks!

Answer 1

Imagine this code worked, how would you use it?

You'd have something that would be parameterized with the allocator, but since it returns the specific type, that thing would have to know what to do with that specific type. that means the code is either not generic (which means there's no reason to have a common base class because the code has to be specialized for the specific allocator type) or it is templated to take a matching type from the allocator, but then there's no reason to have a virtual function, since you can just create the very specific factory class (allocator) that matches the templated type of the thing using it.

You don't really want a templated allocate method - because a specific allocator subclass can't make any type. it can only make its one specific type. It sounds to me like maybe you want to use partial specialization to achieve this?

http://en.cppreference.com/w/cpp/language/partial_specialization

and use those partial specializations from something that is templated to the type that you want to create?

Answer 2

One possible way of solving this problem is to have a generic allocation function in the base class which simply allocates an array of bytes with some alignment:

virtual std::byte *allocate(size_t bytes, size_t align) = 0;

This function can be overridden in derived classes.

Then we can have a templated function in the base Allocator class which uses this non-templated function:

// Argument 'n' here can be the number of allocated instances...
// Not Necessary but might be useful
template<class T>
T *Allocator::allocate(size_t n)
{
  return (T *) allocate(sizeof(T) * n, alignof(T));
}

This way you have made it possible for derived classes to specifically implement their allocation strategy while retaining the typed-allocation API. The only caveat with this solution is that you will need to add using Allocator::allocate; somewhere in the derived class declaration (credits to Igor Tandetnik for this, explained here ) but this is a simple thing to do.

Please keep in mind that using non-aligned pointers for arbitrary types is undefined behaviour and could have various undesireable effects: What exactly is an 'aligned pointer'?