19 General utilities library [utilities]

19.10 Memory [memory]

19.10.10 The default allocator [default.allocator]

1
#
All specializations of the default allocator satisfy the allocator completeness requirements ([allocator.requirements.completeness]).
namespace std {
  template<class T> class allocator {
   public:
    using value_type      = T;
    using size_type       = size_t;
    using difference_type = ptrdiff_t;
    using propagate_on_container_move_assignment = true_type;
    using is_always_equal = true_type;

    constexpr allocator() noexcept;
    constexpr allocator(const allocator&) noexcept;
    template<class U> constexpr allocator(const allocator<U>&) noexcept;
    ~allocator();
    allocator& operator=(const allocator&) = default;

    [[nodiscard]] T* allocate(size_t n);
    void deallocate(T* p, size_t n);
  };
}

19.10.10.1 allocator members [allocator.members]

1
#
Except for the destructor, member functions of the default allocator shall not introduce data races as a result of concurrent calls to those member functions from different threads.
Calls to these functions that allocate or deallocate a particular unit of storage shall occur in a single total order, and each such deallocation call shall happen before the next allocation (if any) in this order.
🔗
[[nodiscard]] T* allocate(size_t n);
2
#
Returns: A pointer to the initial element of an array of storage of size n * sizeof(T), aligned appropriately for objects of type T.
3
#
Remarks: the storage is obtained by calling ​::​operator new, but it is unspecified when or how often this function is called.
4
#
Throws: bad_­alloc if the storage cannot be obtained.
🔗
void deallocate(T* p, size_t n);
5
#
Requires: p shall be a pointer value obtained from allocate().
n shall equal the value passed as the first argument to the invocation of allocate which returned p.
6
#
Effects: Deallocates the storage referenced by p .
7
#
Remarks: Uses ​::​operator delete, but it is unspecified when this function is called.

19.10.10.2 allocator globals [allocator.globals]

🔗
template<class T, class U> bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
1
#
Returns: true.
🔗
template<class T, class U> bool operator!=(const allocator<T>&, const allocator<U>&) noexcept;
2
#
Returns: false.