Variable | Definition | |
T, U, C | any cv-unqualified object type ([basic.types]) | |
X | an allocator class for type T | |
Y | the corresponding allocator class for type U | |
XX | the type allocator_traits<X> | |
YY | the type allocator_traits<Y> | |
a, a1, a2 | lvalues of type X | |
u | the name of a variable being declared | |
b | a value of type Y | |
c | a pointer of type C* through which indirection is valid | |
p | a value of type XX::pointer, obtained
by calling a1.allocate, where a1 == a | |
q | a value of type XX::const_pointer
obtained by conversion from a value p | |
r | a value of type T&
obtained by the expression *p | |
w | a value of type XX::void_pointer obtained by
conversion from a value p | |
x | a value of type XX::const_void_pointer obtained by
conversion from a value q or a value w | |
y | a value of type XX::const_void_pointer obtained by
conversion from a result value of YY::allocate, or else a value of
type (possibly const) std::nullptr_t | |
n | a value of type XX::size_type | |
Args | a template parameter pack | |
args | a function parameter pack with the pattern Args&& |
Expression | Return type | Assertion/note | Default | |
pre-/post-condition | ||||
X::pointer | T* | |||
X::const_pointer | X::pointer is convertible to X::const_pointer | pointer_traits<X::pointer>::rebind<const T> | ||
X::void_pointer Y::void_pointer | pointer_traits<X::pointer>::rebind<void> | |||
X::const_void_pointer Y::const_void_pointer | pointer_traits<X::pointer>::rebind<const void> | |||
X::value_type | Identical to T | |||
X::size_type | unsigned integer type | a type that can represent the size of the largest object in the allocation model | make_unsigned_t<X::difference_type> | |
X::difference_type | signed integer type | a type that can represent the difference between any two pointers
in the allocation model | pointer_traits<X::pointer>::difference_type | |
typename X::template rebind<U>::other | Y | See Note A, below. | ||
*p | T& | |||
*q | const T& | |||
p->m | type of T::m | Preconditions: (*p).m is well-defined. equivalent to (*p).m | ||
q->m | type of T::m | Preconditions: (*q).m is well-defined. equivalent to (*q).m | ||
static_cast<X::pointer>(w) | X::pointer | static_cast<X::pointer>(w) == p | ||
static_cast<X::const_pointer>(x) | X::const_pointer | static_cast< X::const_pointer>(x) == q | ||
pointer_traits<X::pointer>::pointer_to(r) | X::pointer | same as p | ||
a.allocate(n) | X::pointer | Memory is allocated for an array of n T
and such an object is created
but array elements are not constructed. | ||
a.allocate(n, y) | X::pointer | a.allocate(n) | ||
a.deallocate(p,n) | (not used) | |||
a.max_size() | X::size_type | the largest value that can meaningfully be passed to X::allocate() | numeric_limits<size_type>::max() / sizeof(value_type) | |
a1 == a2 | bool | |||
a1 != a2 | bool | same as !(a1 == a2) | ||
a == b | bool | same as a == Y::rebind<T>::other(b) | ||
a != b | bool | same as !(a == b) | ||
X u(a); X u = a; | Shall not exit via an exception. Postconditions: u == a | |||
X u(b); | Shall not exit via an exception. Postconditions: Y(u) == b, u == X(b) | |||
X u(std::move(a)); X u = std::move(a); | ||||
X u(std::move(b)); | ||||
a.construct(c, args) | (not used) | construct_at(c, std::forward<Args>(args)...) | ||
a.destroy(c) | (not used) | Effects: Destroys the object at c | destroy_at(c) | |
a.select_on_container_copy_construction() | X | return a; | ||
X::propagate_on_container_copy_assignment | Identical to or derived from true_type or false_type | false_type | ||
X::propagate_on_container_move_assignment | Identical to or derived from true_type or false_type | false_type | ||
X::propagate_on_- container_swap | Identical to or derived from true_type or false_type | false_type | ||
X::is_always_equal | Identical to or derived from true_type or false_type | true_type only if the expression a1 == a2 is guaranteed
to be true for any two (possibly const) values
a1, a2 of type X. | is_empty<X>::type |