[allocator.traits] (original) (raw)
20 Memory management library [mem]
20.2 Memory [memory]
20.2.9 Allocator traits [allocator.traits]
20.2.9.1 General [allocator.traits.general]
The class template allocator_traits supplies a uniform interface to all allocator types.
An allocator cannot be a non-class type, however, even if allocator_traitssupplies the entire required interface.
[Note 1:
Thus, it is always possible to create a derived class from an allocator.
— _end note_]
If a program declares an explicit or partial specialization of allocator_traits, the program is ill-formed, no diagnostic required.
namespace std { template<class Alloc> struct allocator_traits { using allocator_type = Alloc;using value_type = typename Alloc::value_type;using pointer = see below;using const_pointer = see below;using void_pointer = see below;using const_void_pointer = see below;using difference_type = see below;using size_type = see below;using propagate_on_container_copy_assignment = see below;using propagate_on_container_move_assignment = see below;using propagate_on_container_swap = see below;using is_always_equal = see below;template<class T> using rebind_alloc = see below;template<class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;static constexpr pointer allocate(Alloc& a, size_type n);static constexpr pointer allocate(Alloc& a, size_type n, const_void_pointer hint);static constexpr allocation_result<pointer, size_type> allocate_at_least(Alloc& a, size_type n);static constexpr void deallocate(Alloc& a, pointer p, size_type n);template<class T, class... Args> static constexpr void construct(Alloc& a, T* p, Args&&... args);template<class T> static constexpr void destroy(Alloc& a, T* p);static constexpr size_type max_size(const Alloc& a) noexcept;static constexpr Alloc select_on_container_copy_construction(const Alloc& rhs);};}
20.2.9.2 Member types [allocator.traits.types]
using pointer = _see below_;
Type: Alloc::pointer if the qualified-id Alloc::pointer is valid and denotes a type ([temp.deduct]); otherwise, value_type*.
using const_pointer = _see below_;
Type: Alloc::const_pointer if the qualified-id Alloc::const_pointer is valid and denotes a type ([temp.deduct]); otherwise,pointer_traits<pointer>::rebind<const value_type>.
using void_pointer = _see below_;
Type: Alloc::void_pointer if the qualified-id Alloc::void_pointer is valid and denotes a type ([temp.deduct]); otherwise,pointer_traits<pointer>::rebind<void>.
using const_void_pointer = _see below_;
Type: Alloc::const_void_pointer if the qualified-id Alloc::const_void_pointer is valid and denotes a type ([temp.deduct]); otherwise,pointer_traits<pointer>::rebind<const void>.
using difference_type = _see below_;
Type: Alloc::difference_type if the qualified-id Alloc::difference_type is valid and denotes a type ([temp.deduct]); otherwise,pointer_traits<pointer>::difference_type.
using size_type = _see below_;
Type: Alloc::size_type if the qualified-id Alloc::size_type is valid and denotes a type ([temp.deduct]); otherwise,make_unsigned_t<difference_type>.
using propagate_on_container_copy_assignment = _see below_;
Type: Alloc::propagate_on_container_copy_assignment if the qualified-id Alloc::propagate_on_container_copy_assignment is valid and denotes a type ([temp.deduct]); otherwisefalse_type.
using propagate_on_container_move_assignment = _see below_;
Type: Alloc::propagate_on_container_move_assignment if the qualified-id Alloc::propagate_on_container_move_assignment is valid and denotes a type ([temp.deduct]); otherwisefalse_type.
using propagate_on_container_swap = _see below_;
Type: Alloc::propagate_on_container_swap if the qualified-id Alloc::propagate_on_container_swap is valid and denotes a type ([temp.deduct]); otherwisefalse_type.
using is_always_equal = _see below_;
Type: Alloc::is_always_equal if the qualified-id Alloc::is_always_equalis valid and denotes a type ([temp.deduct]); otherwise is_empty<Alloc>::type.
template<class T> using rebind_alloc = _see below_;
Alias template: Alloc::rebind<T>::other if the qualified-id Alloc::rebind<T>::other is valid and denotes a type ([temp.deduct]); otherwise,Alloc<T, Args> if Alloc is a class template instantiation of the form Alloc<U, Args>, where Args is zero or more type arguments; otherwise, the instantiation of rebind_alloc is ill-formed.
20.2.9.3 Static member functions [allocator.traits.members]
static constexpr pointer allocate(Alloc& a, size_type n);
static constexpr pointer allocate(Alloc& a, size_type n, const_void_pointer hint);
Returns: a.allocate(n, hint) if that expression is well-formed; otherwise, a.allocate(n).
static constexpr allocation_result<pointer, size_type> allocate_at_least(Alloc& a, size_type n);
Returns: a.allocate_at_least(n) if that expression is well-formed; otherwise, {a.allocate(n), n}.
static constexpr void deallocate(Alloc& a, pointer p, size_type n);
Effects: Calls a.deallocate(p, n).
template<class T, class... Args> static constexpr void construct(Alloc& a, T* p, Args&&... args);
Effects: Calls a.construct(p, std::forward<Args>(args)...)if that call is well-formed; otherwise, invokes construct_at(p, std::forward<Args>(args)...).
template<class T> static constexpr void destroy(Alloc& a, T* p);
Effects: Calls a.destroy(p) if that call is well-formed; otherwise, invokesdestroy_at(p).
static constexpr size_type max_size(const Alloc& a) noexcept;
Returns: a.max_size() if that expression is well-formed; otherwise,numeric_limits<size_type>::max() / sizeof(value_type).
static constexpr Alloc select_on_container_copy_construction(const Alloc& rhs);
Returns: rhs.select_on_container_copy_construction() if that expression is well-formed; otherwise, rhs.
20.2.9.4 Other [allocator.traits.other]
The class template allocation_result has the template parameters, data members, and special members specified above.
It has no base classes or members other than those specified.