What's the advantage of using std::allocator instead of new in C++?

Question

I\'ve just read about std::allocator. In my opinion, it is more complicated to use it instead of using new and delete.

With <

Answer 1

In my opinion, it is more complicated to use it instead of using new and delete.

Yes, but it is not meant to replace new and delete, it serves a different purpose.

With allocator we must explicitly allocate heap memory, construct it, destroy it, and then finally deallocate the memory.

So why was it created?

Because sometimes you want to separate allocation and construction into two steps (and similarly to separate destruction and deallocation into two steps). If you don't want to do that, don't use an allocator, use new instead.

In which cases can it be used and when should it be used instead of new and delete?

When you need the behaviour of an allocator, not the behaviour of new and delete, obviously! The typical case is when implementing a container.

Consider the following code:

std::vector<X> v;
v.reserve(4);        // (1)
v.push_back( X{} );  // (2)
v.push_back( X{} );  // (3)
v.clear();           // (4)

Here line (1) must allocate enough memory for four objects, but not construct them yet. Then lines (2) and (3) must construct objects into the allocated memory. Then line (4) must destroy those objects, but not deallocate the memory. Finally, in the vector's destructor, all the memory can be deallocated.

So the vector cannot just use new X() or delete &m_data[1] to create and destroy the objects, it must perform allocation/deallocation separately from construction/destruction. A container's allocator template argument defines the policy that should be used for (de)allocating memory and constructing/destructing objects, allowing the container's use of memory to be customised. The default policy is the std::allocator type.

So you use an allocator when an allocator is required (such as when using a container) and you use std::allocator when you don't want to provide a custom allocator and just want the standard one.

You don't use an allocator as a replacement for new and delete.

Answer 2

Allocators are a very important concept in the STL. Every container is capable to take an allocator as argument. Then allocations will be performed using this allocator, and not the standard one.

This is useful e.g. for allocating objects of the same size in a pool, to improve performance, or might be necessary if there's a special area of memory where your objects need to live.

The steps of allocating and constructing are separate because e.g. for vector (std::vector::reserve) it's important to be able to allocate memory for future use, but not (yet) create objects therein.

As an example you could write an allocator as a class, containing an fixed size array, and use that array to provide memory for some standard container. Then you can have an instance of that class on the stack and thus completely avoid heap allocations for some part of your programm.

See more examples here in this SO post.

[...] when should it be used [...]

When you have specific needs, and most important when writing own generic containers.