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

by

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.

More Related Contents:

  1. Is it possible to force c++ class instantiation on the heap?
  2. Why should C++ programmers minimize use of ‘new’?
  3. Stack, Static, and Heap in C++
  4. What is memory fragmentation?
  5. Why are the terms “automatic” and “dynamic” preferred over the terms “stack” and “heap” in C++ memory management?
  6. Calling delete on variable allocated on the stack
  7. Which is faster: Stack allocation or Heap allocation
  8. When vectors are allocated, do they use memory on the heap or the stack?
  9. Proper stack and heap usage in C++?
  10. Why are two different concepts both called “heap”? [duplicate]
  11. Is there a reason to call delete in C++ when a program is exiting anyway?
  12. Object creation on the stack/heap?
  13. What is the difference between “new” and “malloc” and “calloc” in C++? [duplicate]
  14. Why not use pointers for everything in C++?
  15. Where are temporary object stored?
  16. Are there stackless or heapless implementation of C++?
  17. g++ variable size array no warning?
  18. Critique my non-intrusive heap debugger
  19. How is heap and stack memories managed, implemented, allocated?
  20. Does this type of memory get allocated on the heap or the stack?
  21. Is accessing data in the heap faster than from the stack?
  22. Linux Allocator Does Not Release Small Chunks of Memory
  23. What happens if I increment an array variable?
  24. How to prevent an object being created on the heap?
  25. How to find if a variable is allocated in stack or heap?
  26. Class members and explicit stack/heap allocation
  27. Are global variables in C++ stored on the stack, heap or neither of them?
  28. Why do we even need the “delete[]” operator?
  29. C++ delete does not free all memory (Windows)
  30. C++ compiling on Windows and Linux: ifdef switch [duplicate]

Leave a Comment