[library] (original) (raw)

X::pointer is convertible to X::const_pointer

pointer_traits<X::pointer>::rebind<const T>

X::void_pointer
Y::void_pointer

X::pointer is convertible to X::void_pointer.

X::void_pointer and Y::void_pointer are the same type.

pointer_traits<X::pointer>::rebind<void>

X::const_void_pointer
Y::const_void_pointer

X::pointer, X::const_pointer, and X::void_pointer are convertible to X::const_void_pointer.

X::const_void_pointer and Y::const_void_pointer are the same type.

pointer_traits<X::pointer>::rebind<const void>

a type that can represent the size of the largest object in the allocation model

make_unsigned_t<X::difference_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

For all U (including T), Y::template rebind<T>::other is X.

*q refers to the same object as *p.

Preconditions: (*p).m is well-defined.

Preconditions: (*q).m is well-defined.

static_cast<X::pointer>(w)

static_cast<X::pointer>(w) == p

static_cast<X::const_pointer>(x)

static_cast< X::const_pointer>(x) == q

pointer_traits<X::pointer>::pointer_to(r)

Memory is allocated for an array of n Tand such an object is created but array elements are not constructed.

[Example 1:

When reusing storage denoted by some pointer value p,launder(reinterpret_cast<T*>(new (p) byte[n * sizeof(T)]))can be used to implicitly create a suitable array object and obtain a pointer to it.

— _end example_]

allocate may throw an appropriate exception.176

[Note 1:

If n == 0, the return value is unspecified.

— _end note_]

Same as a.allocate(n).

The use of y is unspecified, but it is intended as an aid to locality.

Preconditions: p is a value returned by an earlier call to allocate that has not been invalidated by an intervening call to deallocate.

n matches the value passed to allocate to obtain this memory.

the largest value that can meaningfully be passed to X::allocate()

numeric_limits<size_type>::max() / sizeof(value_type)

Returns true only if storage allocated from each can be deallocated via the other.

operator== shall be reflexive, symmetric, and transitive, and shall not exit via an exception.

same as a == Y::rebind<T>::other(b)

Shall not exit via an exception.

Postconditions: Y(u) == b, u == X(b)

X u(std::move(a));
X u = std::move(a);

Shall not exit via an exception.

Postconditions: The value of a is unchanged and is equal to u.

Shall not exit via an exception.

Postconditions: u is equal to the prior value of X(b).

Effects: Constructs an object of type C atc.

construct_at(c, std::forward<Args>(args)...)

Effects: Destroys the object at c

a.select_on_container_copy_construction()

Typically returns either a or X().

X::propagate_on_container_copy_assignment

Identical to or derived from true_type or false_type

true_type only if an allocator of type X should be copied when the client container is copy-assigned.

See Note B, below.

X::propagate_on_container_move_assignment

Identical to or derived from true_type or false_type

true_type only if an allocator of type X should be moved when the client container is move-assigned.

See Note B, below.

X::propagate_on_- container_swap

Identical to or derived from true_type or false_type

true_type only if an allocator of type X should be swapped when the client container is swapped.

See Note B, below.

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) valuesa1, a2 of type X.