C++ concepts: Allocator

Encapsulates strategies for access/addressing, allocation/deallocation and construction/destruction of objects.

Every standard library component that may need to allocate or release storage, from std::string, std::vector, and every container except std::array, to std::shared_ptr and std::function, does so through an Allocator: an object of a class type that satisfies the following requirements.

Some requirements are optional: the template std::allocator_traits supplies the default implementations for all optional requirements, and all standard library containers and other allocator-aware classes access the allocator through std::allocator_traits, not directly.

Requirements

Given.

• T, a cv-unqualified object type
• A, an Allocator type for type T
• a, an object of type A
• B, the corresponding Allocator type for some cv-unqualified object type U (as obtained by rebinding A)
• ptr, a value of type allocator_traits<A>::pointer, obtained by calling allocator_traits<A>::allocate()
• cptr, a value of type allocator_traits<A>::const_pointer, obtained by conversion from ptr
• vptr, a value of type allocator_traits<A>::void_pointer, obtained by conversion from ptr
• cvptr, a value of type allocator_traits<A>::const_void_pointer, obtained by conversion from cptr or from vptr
• xptr, a dereferencable pointer to some cv-unqualified object type X,
• r, an lvalue of type T obtained by the expression *ptr
• n, a value of type allocator_traits<A>::size_type

Notes: [1] rebind is only optional (provided by std::allocator_traits) if this allocator is a template of the form SomeAllocator<T, Args>, where Args is zero or more additional template parameters.

Fancy pointers

When the member type pointer is not a raw pointer type, it is commonly referred to as a "fancy pointer". Such pointers were introduced to support segmented memory architectures and are used today to access objects allocated in address spaces that differ from the homogeneous virtual address space that is accessed by raw pointers. An example of a fancy pointer is the mapping address-independent pointer boost::interprocess::offset_ptr, which makes it possible to allocate node-based data structures such as std::set in shared memory and memory mapped files mapped in different addresses in every process. Fancy pointers can be used independently of the allocator that provided them, through the class template std::pointer_traits.

Standard library

The following standard library components satisfy the Allocator concept:

Examples

#include <cstddef>
template <class T>
struct SimpleAllocator {
  typedef T value_type;
  SimpleAllocator(/*ctor args*/);
  template <class U> SimpleAllocator(const SimpleAllocator<U>& other);
  T* allocate(std::size_t n);
  void deallocate(T* p, std::size_t n);
};
template <class T, class U>
bool operator==(const SimpleAllocator<T>&, const SimpleAllocator<U>&);
template <class T, class U>
bool operator!=(const SimpleAllocator<T>&, const SimpleAllocator<U>&);