Why do container allocators need to specify the type they're allocating?

Question

I don't like that I have to repeat the contained typename if I use a custom allocator for a container:

template<typename T, size_t MyAllocatorArgument>
struct MyAllocator : public std::allocator<T>
{
    // ... Usual allocator implementation
};

typedef std::vector<int, MyAllocator<int, 42>> int_container;
typedef std::vector<int, MyAllocator<long, 12>> int_container_wrong_allocator;

The second line is undefined behaviour according to the standard, though most implementations will rebind the allocator to the correct type.

My question is, given that it's a requirement for the container and allocator to be for the same type, why is there not some standard machinery in place to enforce this (or avoid it entirely) and remove the potential for user error?

For example, the standard could mandate that rebind does get used (to effectively make the allocator template parameter redundant), or a pattern like the below could be used so the user only mentions the contained typename once:

template<size_t MyAllocatorArgument>
struct MyAllocator
{
    // This would be something every allocator is required to expose.
    template<typename T>
    struct TypedAllocator : public std::allocator<T>
    {
        // This is where the normal implementation of the allocator would go.
        // allocate, deallocate etc.
    };
};

template<typename T, typename UntypedAllocator>
struct Container
{
    // All containers would do this to get the actual allocator type they would use.
    typedef typename UntypedAllocator::template TypedAllocator<T> TypedAllocator;

    Container() : m_allocator(TypedAllocator()) {}

    void useAllocator()
    {
        m_allocator.allocate();
        // ... or whatever else containers need to do with allocators.
    }

    TypedAllocator m_allocator;
};

void allocator_test()
{
    // Allocated type name isn't mentioned at point of use of container;
    // only once for the container. The container does all the work.
    Container<int, MyAllocator<42>> c1;
}

Even if `rebind` is used, the author could still use the template parameter to provide different specializations of the allocator for different client types. — Kerrek SB, Apr 07 '14 at 09:46
@KerrekSB the question is "given that it's a requirement for the container and allocator to be for the same type, why is there not some standard machinery in place to enforce this (or avoid it entirely) and remove the potential for user error?" so you can still create a vector with allocator for double — 4pie0, Apr 07 '14 at 09:58
`allocator` can potentially be used to allocate `B`s if B derives from A. The correspondence between container and allocator types seems natural, but it's difficult (for me) to say if it is necessary. — Jonathan H, Apr 07 '14 at 10:05
[vecttor with std::allocator](http://ideone.com/gJAGC9) , never tried this — 4pie0, Apr 07 '14 at 13:47
@lizusek Is that actually valid though or is it undefined behaviour? As I say, as far as I know, most compilers will allow it without a diagnostic message, even though it's not valid. Your code snippet is slightly different to mine though, since yours passes in an instance of an allocator of a different type, whereas mine uses the default allocator of a type specified by `vector`'s template parameter. Perhaps those two cases are handled differently by the standard? — Ben Hymers, Apr 07 '14 at 13:54
The ideone link works because `std::allocator` is convertible to `std::allocator` and is 100% well-defined by the standard, but as you say is not the same as your question which is about instantiating `vector>`, which is explicitly disallowed by the standard — Jonathan Wakely, Apr 17 '14 at 23:43

Jonathan Wakely · Accepted Answer · 2014-04-18T20:32:57.820

It's a good question, and your suggestion is one possible alternative to the standard scheme. Another would have been to use template template parameters:

template<typename T>
class AnAllocator
{ ... };

template<typename T, template <typename> class Alloc = std::allocator>
class Vector
{
  typedef Alloc<T> allocator_type;
  ...
};

Vector<int, AnAllocator> v;

The allocator interface was designed before template template parameters were part of the language, so that wasn't an option.

There are lots of things that would be done differently if the allocator API were to be designed today, unfortunately we're stuck with the one we have (and the continuing complexity caused by trying to extend it in semi-compatible ways).

Oh wow, how did I not know about template template parameters? Just when you think you know a language, eh? Nice solution, and good answer in general. Thanks! — Ben Hymers, Apr 18 '14 at 18:26

Why do container allocators need to specify the type they're allocating?

1 Answers1