[memory] - C++17 → C++20

Files changed (1) hide show

tmp/tmpbhtmk4qq/{from.md → to.md} +690 -517

tmp/tmpbhtmk4qq/{from.md → to.md} RENAMED Viewed

@@ -1,245 +1,453 @@
 ## Memory <a id="memory">[[memory]]</a>
 ### In general <a id="memory.general">[[memory.general]]</a>
-This subclause describes the contents of the header `<memory>` (
-[[memory.syn]]) and some of the contents of the header `<cstdlib>` (
-[[cstdlib.syn]]).
 ### Header `<memory>` synopsis <a id="memory.syn">[[memory.syn]]</a>
 The header `<memory>` defines several types and function templates that
 describe properties of pointers and pointer-like types, manage memory
 for containers and other template types, destroy objects, and construct
-multiple objects in uninitialized memory buffers ([[pointer.traits]]–
-[[specialized.algorithms]]). The header also defines the templates
-`unique_ptr`, `shared_ptr`, `weak_ptr`, and various function templates
-that operate on objects of these types ([[smartptr]]).
 ``` cpp
 namespace std {
   // [pointer.traits], pointer traits
   template<class Ptr> struct pointer_traits;
   template<class T> struct pointer_traits<T*>;
-  // [util.dynamic.safety], pointer safety
   enum class pointer_safety { relaxed, preferred, strict };
   void declare_reachable(void* p);
-  template <class T> T* undeclare_reachable(T* p);
   void declare_no_pointers(char* p, size_t n);
   void undeclare_no_pointers(char* p, size_t n);
   pointer_safety get_pointer_safety() noexcept;
-  // [ptr.align], pointer alignment function
   void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
   // [allocator.tag], allocator argument tag
   struct allocator_arg_t { explicit allocator_arg_t() = default; };
   inline constexpr allocator_arg_t allocator_arg{};
   // [allocator.uses], uses_allocator
   template<class T, class Alloc> struct uses_allocator;
   // [allocator.traits], allocator traits
   template<class Alloc> struct allocator_traits;
   // [default.allocator], the default allocator
   template<class T> class allocator;
   template<class T, class U>
-    bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
-  template <class T, class U>
-    bool operator!=(const allocator<T>&, const allocator<U>&) noexcept;
   // [specialized.algorithms], specialized algorithms
- template <class T> constexpr T* addressof(T& r) noexcept;
-  template <class T> const T* addressof(const T&&) = delete;
-  template <class ForwardIterator>
-    void uninitialized_default_construct(ForwardIterator first, ForwardIterator last);
-  template <class ExecutionPolicy, class ForwardIterator>
     void uninitialized_default_construct(ExecutionPolicy&& exec,        // see [algorithms.parallel.overloads]
- ForwardIterator first, ForwardIterator last);
-  template <class ForwardIterator, class Size>
-    ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n);
-  template <class ExecutionPolicy, class ForwardIterator, class Size>
-    ForwardIterator uninitialized_default_construct_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                                      ForwardIterator first, Size n);
-  template <class ForwardIterator>
-    void uninitialized_value_construct(ForwardIterator first, ForwardIterator last);
-  template <class ExecutionPolicy, class ForwardIterator>
     void uninitialized_value_construct(ExecutionPolicy&& exec,  // see [algorithms.parallel.overloads]
- ForwardIterator first, ForwardIterator last);
-  template <class ForwardIterator, class Size>
-    ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n);
-  template <class ExecutionPolicy, class ForwardIterator, class Size>
-    ForwardIterator uninitialized_value_construct_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                                    ForwardIterator first, Size n);
-  template <class InputIterator, class ForwardIterator>
-    ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
-                                       ForwardIterator result);
-  template <class ExecutionPolicy, class InputIterator, class ForwardIterator>
-    ForwardIterator uninitialized_copy(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
                                               InputIterator first, InputIterator last,
-                                       ForwardIterator result);
-  template <class InputIterator, class Size, class ForwardIterator>
- ForwardIterator uninitialized_copy_n(InputIterator first, Size n,
-                                         ForwardIterator result);
-  template <class ExecutionPolicy, class InputIterator, class Size, class ForwardIterator>
- ForwardIterator uninitialized_copy_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
                                                 InputIterator first, Size n,
-                                         ForwardIterator result);
-  template <class InputIterator, class ForwardIterator>
-    ForwardIterator uninitialized_move(InputIterator first, InputIterator last,
-                                       ForwardIterator result);
-  template <class ExecutionPolicy, class InputIterator, class ForwardIterator>
- ForwardIterator uninitialized_move(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
                                               InputIterator first, InputIterator last,
-                                       ForwardIterator result);
-  template <class InputIterator, class Size, class ForwardIterator>
-    pair<InputIterator, ForwardIterator>
-      uninitialized_move_n(InputIterator first, Size n, ForwardIterator result);
-  template <class ExecutionPolicy, class InputIterator, class Size, class ForwardIterator>
-    pair<InputIterator, ForwardIterator>
       uninitialized_move_n(ExecutionPolicy&& exec,              // see [algorithms.parallel.overloads]
-                           InputIterator first, Size n, ForwardIterator result);
-  template <class ForwardIterator, class T>
-    void uninitialized_fill(ForwardIterator first, ForwardIterator last,
                             const T& x);
-  template <class ExecutionPolicy, class ForwardIterator, class T>
     void uninitialized_fill(ExecutionPolicy&& exec,             // see [algorithms.parallel.overloads]
- ForwardIterator first, ForwardIterator last,
                             const T& x);
-  template <class ForwardIterator, class Size, class T>
- ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
-  template <class ExecutionPolicy, class ForwardIterator, class Size, class T>
-    ForwardIterator uninitialized_fill_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                         ForwardIterator first, Size n, const T& x);
   template<class T>
-    void destroy_at(T* location);
-  template <class ForwardIterator>
-    void destroy(ForwardIterator first, ForwardIterator last);
-  template <class ExecutionPolicy, class ForwardIterator>
     void destroy(ExecutionPolicy&& exec,                        // see [algorithms.parallel.overloads]
- ForwardIterator first, ForwardIterator last);
-  template <class ForwardIterator, class Size>
- ForwardIterator destroy_n(ForwardIterator first, Size n);
-  template <class ExecutionPolicy, class ForwardIterator, class Size>
- ForwardIterator destroy_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                              ForwardIterator first, Size n);
   // [unique.ptr], class template unique_ptr
   template<class T> struct default_delete;
   template<class T> struct default_delete<T[]>;
   template<class T, class D = default_delete<T>> class unique_ptr;
   template<class T, class D> class unique_ptr<T[], D>;
-  template <class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
-  template <class T> unique_ptr<T> make_unique(size_t n);
-  template <class T, class... Args> unspecified make_unique(Args&&...) = delete;
-  template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
   template<class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template <class T1, class D1, class T2, class D2>
-    bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
     bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-  template <class T1, class D1, class T2, class D2>
-    bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
     bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
     bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T, class D>
     bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
-  template <class T, class D>
-    bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept;
-  template <class T, class D>
-    bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept;
-  template <class T, class D>
-    bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept;
   template<class T, class D>
     bool operator<(const unique_ptr<T, D>& x, nullptr_t);
   template<class T, class D>
     bool operator<(nullptr_t, const unique_ptr<T, D>& y);
-  template <class T, class D>
-    bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
-  template <class T, class D>
-    bool operator<=(nullptr_t, const unique_ptr<T, D>& y);
   template<class T, class D>
     bool operator>(const unique_ptr<T, D>& x, nullptr_t);
   template<class T, class D>
     bool operator>(nullptr_t, const unique_ptr<T, D>& y);
   template<class T, class D>
     bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
   template<class T, class D>
     bool operator>=(nullptr_t, const unique_ptr<T, D>& y);
   // [util.smartptr.weak.bad], class bad_weak_ptr
   class bad_weak_ptr;
   // [util.smartptr.shared], class template shared_ptr
   template<class T> class shared_ptr;
   // [util.smartptr.shared.create], shared_ptr creation
   template<class T, class... Args>
-    shared_ptr<T> make_shared(Args&&... args);
   template<class T, class A, class... Args>
-    shared_ptr<T> allocate_shared(const A& a, Args&&... args);
   // [util.smartptr.shared.cmp], shared_ptr comparisons
   template<class T, class U>
     bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
   template<class T, class U>
- bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator<=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator>=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
   template<class T>
     bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
   template<class T>
- bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept;
-  template <class T>
-    bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept;
-  template <class T>
-    bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept;
-  template <class T>
-    bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept;
-  template <class T>
-    bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept;
-  template <class T>
-    bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept;
-  template <class T>
-    bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept;
-  template <class T>
-    bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;
-  template <class T>
-    bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;
-  template <class T>
-    bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;
-  template <class T>
-    bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;
   // [util.smartptr.shared.spec], shared_ptr specialized algorithms
   template<class T>
     void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
   // [util.smartptr.shared.cast], shared_ptr casts
   template<class T, class U>
     shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
   template<class T, class U>
     shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
   template<class T, class U>
     shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
   // [util.smartptr.getdeleter], shared_ptr get_deleter
   template<class D, class T>
     D* get_deleter(const shared_ptr<T>& p) noexcept;
@@ -257,52 +465,19 @@ namespace std {
   template<class T = void> struct owner_less;
   // [util.smartptr.enab], class template enable_shared_from_this
   template<class T> class enable_shared_from_this;
-  // [util.smartptr.shared.atomic], shared_ptr atomic access
-  template<class T>
-    bool atomic_is_lock_free(const shared_ptr<T>* p);
-  template<class T>
-    shared_ptr<T> atomic_load(const shared_ptr<T>* p);
-  template<class T>
-    shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo);
-  template<class T>
-    void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
-  template<class T>
-    void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
-  template<class T>
-    shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r);
-  template<class T>
-    shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
-  template<class T>
-    bool atomic_compare_exchange_weak(
-      shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
-  template<class T>
-    bool atomic_compare_exchange_strong(
-      shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
-  template<class T>
-    bool atomic_compare_exchange_weak_explicit(
-      shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
-      memory_order success, memory_order failure);
-  template<class T>
-    bool atomic_compare_exchange_strong_explicit(
-      shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
-      memory_order success, memory_order failure);
   // [util.smartptr.hash], hash support
   template<class T> struct hash;
   template<class T, class D> struct hash<unique_ptr<T, D>>;
   template<class T> struct hash<shared_ptr<T>>;
-  // [allocator.uses.trait], uses_allocator
-  template <class T, class Alloc>
-    inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
 }
 ```
 ### Pointer traits <a id="pointer.traits">[[pointer.traits]]</a>
@@ -326,61 +501,97 @@ namespace std {
     using element_type    = T;
     using difference_type = ptrdiff_t;
     template<class U> using rebind = U*;
-    static pointer pointer_to(see below r) noexcept;
   };
 }
 ```
-#### Pointer traits member types <a id="pointer.traits.types">[[pointer.traits.types]]</a>
 ``` cpp
 using element_type = see below;
 ```
 *Type:* `Ptr::element_type` if the *qualified-id* `Ptr::element_type` is
-valid and denotes a type ([[temp.deduct]]); otherwise, `T` if `Ptr` is
-a class template instantiation of the form `SomePointer<T, Args>`, where
 `Args` is zero or more type arguments; otherwise, the specialization is
 ill-formed.
 ``` cpp
 using difference_type = see below;
 ```
 *Type:* `Ptr::difference_type` if the *qualified-id*
-`Ptr::difference_type` is valid and denotes a type ([[temp.deduct]]);
 otherwise, `ptrdiff_t`.
 ``` cpp
 template<class U> using rebind = see below;
 ```
 *Alias template:* `Ptr::rebind<U>` if the *qualified-id*
-`Ptr::rebind<U>` is valid and denotes a type ([[temp.deduct]]);
-otherwise, `SomePointer<U, Args>` if `Ptr` is a class template
-instantiation of the form `SomePointer<T, Args>`, where `Args` is zero
-or more type arguments; otherwise, the instantiation of `rebind` is
-ill-formed.
-#### Pointer traits member functions <a id="pointer.traits.functions">[[pointer.traits.functions]]</a>
 ``` cpp
 static pointer pointer_traits::pointer_to(see below r);
-static pointer pointer_traits<T*>::pointer_to(see below r) noexcept;
 ```
 *Remarks:* If `element_type` is cv `void`, the type of `r` is
 unspecified; otherwise, it is `element_type&`.
-*Returns:* The first member function returns a pointer to `r` obtained
-by calling `Ptr::pointer_to(r)` through which indirection is valid; an
-instantiation of this function is ill-formed if `Ptr` does not have a
-matching `pointer_to` static member function. The second member function
-returns `addressof(r)`.
 ### Pointer safety <a id="util.dynamic.safety">[[util.dynamic.safety]]</a>
 A complete object is *declared reachable* while the number of calls to
 `declare_reachable` with an argument referencing the object exceeds the
@@ -389,30 +600,29 @@ the object.
 ``` cpp
 void declare_reachable(void* p);
 ```
-*Requires:* `p` shall be a safely-derived
-pointer ([[basic.stc.dynamic.safety]]) or a null pointer value.
 *Effects:* If `p` is not null, the complete object referenced by `p` is
-subsequently declared reachable ([[basic.stc.dynamic.safety]]).
 *Throws:* May throw `bad_alloc` if the system cannot allocate additional
 memory that may be required to track objects declared reachable.
 ``` cpp
 template<class T> T* undeclare_reachable(T* p);
 ```
-*Requires:* If `p` is not null, the complete object referenced by `p`
-shall have been previously declared reachable, and shall be
-live ([[basic.life]]) from the time of the call until the last
-`undeclare_reachable(p)` call on the object.
-*Returns:* A safely derived copy of `p` which shall compare equal to
-`p`.
 *Throws:* Nothing.
 [*Note 1*: It is expected that calls to `declare_reachable(p)` will
 consume a small amount of memory in addition to that occupied by the
@@ -422,14 +632,14 @@ matched. — *end note*]
 ``` cpp
 void declare_no_pointers(char* p, size_t n);
 ```
-*Requires:* No bytes in the specified range are currently registered
-with `declare_no_pointers()`. If the specified range is in an allocated
-object, then it must be entirely within a single allocated object. The
-object must be live until the corresponding `undeclare_no_pointers()`
 call.
 [*Note 2*: In a garbage-collecting implementation, the fact that a
 region in an object is registered with `declare_no_pointers()` should
 not prevent the object from being collected. — *end note*]
@@ -450,69 +660,92 @@ fails. — *end note*]
 ``` cpp
 void undeclare_no_pointers(char* p, size_t n);
 ```
-*Requires:* The same range must previously have been passed to
 `declare_no_pointers()`.
 *Effects:* Unregisters a range registered with `declare_no_pointers()`
-for destruction. It must be called before the lifetime of the object
 ends.
 *Throws:* Nothing.
 ``` cpp
 pointer_safety get_pointer_safety() noexcept;
 ```
 *Returns:* `pointer_safety::strict` if the implementation has strict
-pointer safety ([[basic.stc.dynamic.safety]]). It is
 *implementation-defined* whether `get_pointer_safety` returns
 `pointer_safety::relaxed` or `pointer_safety::preferred` if the
 implementation has relaxed pointer safety.[^1]
-### Align <a id="ptr.align">[[ptr.align]]</a>
 ``` cpp
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 ```
 *Effects:* If it is possible to fit `size` bytes of storage aligned by
 `alignment` into the buffer pointed to by `ptr` with length `space`, the
 function updates `ptr` to represent the first possible address of such
 storage and decreases `space` by the number of bytes used for alignment.
 Otherwise, the function does nothing.
-*Requires:*
-- `alignment` shall be a power of two
-- `ptr` shall represent the address of contiguous storage of at least
-  `space` bytes
 *Returns:* A null pointer if the requested aligned buffer would not fit
 into the available space, otherwise the adjusted value of `ptr`.
 [*Note 1*: The function updates its `ptr` and `space` arguments so that
 it can be called repeatedly with possibly different `alignment` and
 `size` arguments for the same buffer. — *end note*]
 ### Allocator argument tag <a id="allocator.tag">[[allocator.tag]]</a>
 ``` cpp
 namespace std {
   struct allocator_arg_t { explicit allocator_arg_t() = default; };
   inline constexpr allocator_arg_t allocator_arg{};
 }
 ```
-The `allocator_arg_t` struct is an empty structure type used as a unique
 type to disambiguate constructor and function overloading. Specifically,
 several types (see `tuple`  [[tuple]]) have constructors with
 `allocator_arg_t` as the first argument, immediately followed by an
-argument of a type that satisfies the `Allocator` requirements (
-[[allocator.requirements]]).
 ### `uses_allocator` <a id="allocator.uses">[[allocator.uses]]</a>
 #### `uses_allocator` trait <a id="allocator.uses.trait">[[allocator.uses.trait]]</a>
@@ -520,46 +753,199 @@ argument of a type that satisfies the `Allocator` requirements (
 template<class T, class Alloc> struct uses_allocator;
 ```
 *Remarks:* Automatically detects whether `T` has a nested
 `allocator_type` that is convertible from `Alloc`. Meets the
-`BinaryTypeTrait` requirements ([[meta.rqmts]]). The implementation
 shall provide a definition that is derived from `true_type` if the
 *qualified-id* `T::allocator_type` is valid and denotes a
-type ([[temp.deduct]]) and
 `is_convertible_v<Alloc, T::allocator_type> != false`, otherwise it
 shall be derived from `false_type`. A program may specialize this
-template to derive from `true_type` for a user-defined type `T` that
 does not have a nested `allocator_type` but nonetheless can be
 constructed with an allocator where either:
 - the first argument of a constructor has type `allocator_arg_t` and the
   second argument has type `Alloc` or
 - the last argument of a constructor has type `Alloc`.
 #### Uses-allocator construction <a id="allocator.uses.construction">[[allocator.uses.construction]]</a>
-*Uses-allocator construction* with allocator `Alloc` refers to the
-construction of an object `obj` of type `T`, using constructor arguments
-`v1, v2, ..., vN` of types `V1, V2, ..., VN`, respectively, and an
-allocator `alloc` of type `Alloc`, according to the following rules:
-- if `uses_allocator_v<T, Alloc>` is `false` and
-  `is_constructible_v<T, V1, V2, ..., VN>` is `true`, then `obj` is
-  initialized as `obj(v1, v2, ..., vN)`;
-- otherwise, if `uses_allocator_v<T, Alloc>` is `true` and
- `is_constructible_v<T, allocator_arg_t, Alloc,` `V1, V2, ..., VN>` is
-  `true`, then `obj` is initialized as `obj(allocator_arg, alloc, v1,
-  v2, ..., vN)`;
-- otherwise, if `uses_allocator_v<T, Alloc>` is `true` and
-  `is_constructible_v<T, V1, V2, ..., VN, Alloc>` is `true`, then `obj`
- is initialized as `obj(v1, v2, ..., vN, alloc)`;
-- otherwise, the request for uses-allocator construction is ill-formed.
-  \[*Note 1*: An error will result if `uses_allocator_v<T, Alloc>` is
- `true` but the specific constructor does not take an allocator. This
- definition prevents a silent failure to pass the allocator to an
-  element. — *end note*]
 ### Allocator traits <a id="allocator.traits">[[allocator.traits]]</a>
 The class template `allocator_traits` supplies a uniform interface to
 all allocator types. An allocator cannot be a non-class type, however,
@@ -589,484 +975,266 @@ namespace std {
     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 pointer allocate(Alloc& a, size_type n);
-    static pointer allocate(Alloc& a, size_type n, const_void_pointer hint);
-    static void deallocate(Alloc& a, pointer p, size_type n);
     template<class T, class... Args>
-      static void construct(Alloc& a, T* p, Args&&... args);
     template<class T>
-      static void destroy(Alloc& a, T* p);
-    static size_type max_size(const Alloc& a) noexcept;
-    static Alloc select_on_container_copy_construction(const Alloc& rhs);
   };
 }
 ```
-#### Allocator traits member types <a id="allocator.traits.types">[[allocator.traits.types]]</a>
 ``` cpp
 using pointer = see below;
 ```
 *Type:* `Alloc::pointer` if the *qualified-id* `Alloc::pointer` is valid
-and denotes a type ([[temp.deduct]]); otherwise, `value_type*`.
 ``` cpp
 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>`.
 ``` cpp
 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>`.
 ``` cpp
 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>`.
 ``` cpp
 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`.
 ``` cpp
 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>`.
 ``` cpp
 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]]); otherwise `false_type`.
 ``` cpp
 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]]); otherwise `false_type`.
 ``` cpp
 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]]); otherwise `false_type`.
 ``` cpp
 using is_always_equal = see below;
 ```
 *Type:* `Alloc::is_always_equal` if the *qualified-id*
-`Alloc::is_always_equal` is valid and denotes a type ([[temp.deduct]]);
 otherwise `is_empty<Alloc>::type`.
 ``` cpp
 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.
-#### Allocator traits static member functions <a id="allocator.traits.members">[[allocator.traits.members]]</a>
 ``` cpp
-static pointer allocate(Alloc& a, size_type n);
 ```
 *Returns:* `a.allocate(n)`.
 ``` cpp
-static 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)`.
 ``` cpp
-static void deallocate(Alloc& a, pointer p, size_type n);
 ```
 *Effects:* Calls `a.deallocate(p, n)`.
 *Throws:* Nothing.
 ``` cpp
 template<class T, class... Args>
-  static 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
-`::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)`.
 ``` cpp
 template<class T>
-  static void destroy(Alloc& a, T* p);
 ```
 *Effects:* Calls `a.destroy(p)` if that call is well-formed; otherwise,
-invokes `p->~T()`.
 ``` cpp
-static 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)`.
 ``` cpp
-static Alloc select_on_container_copy_construction(const Alloc& rhs);
 ```
 *Returns:* `rhs.select_on_container_copy_construction()` if that
 expression is well-formed; otherwise, `rhs`.
 ### The default allocator <a id="default.allocator">[[default.allocator]]</a>
-All specializations of the default allocator satisfy the allocator
-completeness requirements ([[allocator.requirements.completeness]]).
 ``` cpp
 namespace std {
   template<class T> class allocator {
    public:
     using value_type                             = T;
     using propagate_on_container_move_assignment = true_type;
     using is_always_equal                        = true_type;
-    allocator() noexcept;
-    allocator(const allocator&) noexcept;
-    template <class U> allocator(const allocator<U>&) noexcept;
-    ~allocator();
-    T* allocate(size_t n);
-    void deallocate(T* p, size_t n);
   };
 }
 ```
-#### `allocator` members <a id="allocator.members">[[allocator.members]]</a>
 Except for the destructor, member functions of the default allocator
-shall not introduce data races ([[intro.multithread]]) 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.
 ``` cpp
-T* allocate(size_t n);
 ```
-*Returns:* A pointer to the initial element of an array of storage of
-size `n` `* sizeof(T)`, aligned appropriately for objects of type `T`.
-*Remarks:* the storage is obtained by calling
-`::operator new` ([[new.delete]]), but it is unspecified when or how
-often this function is called.
-*Throws:* `bad_alloc` if the storage cannot be obtained.
 ``` cpp
-void deallocate(T* p, size_t n);
 ```
-*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`.
 *Effects:* Deallocates the storage referenced by `p` .
-*Remarks:* Uses `::operator delete` ([[new.delete]]), but it is
 unspecified when this function is called.
-#### `allocator` globals <a id="allocator.globals">[[allocator.globals]]</a>
 ``` cpp
 template<class T, class U>
-  bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
 ```
 *Returns:* `true`.
-``` cpp
-template <class T, class U>
-  bool operator!=(const allocator<T>&, const allocator<U>&) noexcept;
-```
-*Returns:* `false`.
-### Specialized algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
-Throughout this subclause, the names of template parameters are used to
-express type requirements.
-- If an algorithm’s template parameter is named `InputIterator`, the
-  template argument shall satisfy the requirements of an input
-  iterator ([[input.iterators]]).
-- If an algorithm’s template parameter is named `ForwardIterator`, the
-  template argument shall satisfy the requirements of a forward
-  iterator ([[forward.iterators]]), and is required to have the
-  property that no exceptions are thrown from increment, assignment,
-  comparison, or indirection through valid iterators.
-Unless otherwise specified, if an exception is thrown in the following
-algorithms there are no effects.
-#### `addressof` <a id="specialized.addressof">[[specialized.addressof]]</a>
 ``` cpp
 template<class T> constexpr T* addressof(T& r) noexcept;
 ```
 *Returns:* The actual address of the object or function referenced by
 `r`, even in the presence of an overloaded `operator&`.
 *Remarks:* An expression `addressof(E)` is a constant
-subexpression ([[defns.const.subexpr]]) if `E` is an lvalue constant
 subexpression.
-#### `uninitialized_default_construct` <a id="uninitialized.construct.default">[[uninitialized.construct.default]]</a>
-``` cpp
-template <class ForwardIterator>
-  void uninitialized_default_construct(ForwardIterator first, ForwardIterator last);
-```
-*Effects:* Equivalent to:
-``` cpp
-for (; first != last; ++first)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type;
-```
-``` cpp
-template <class ForwardIterator, class Size>
-  ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n);
-```
-*Effects:* Equivalent to:
-``` cpp
-for (; n>0; (void)++first, --n)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type;
-return first;
-```
-#### `uninitialized_value_construct` <a id="uninitialized.construct.value">[[uninitialized.construct.value]]</a>
-``` cpp
-template <class ForwardIterator>
-  void uninitialized_value_construct(ForwardIterator first, ForwardIterator last);
-```
-*Effects:* Equivalent to:
-``` cpp
-for (; first != last; ++first)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type();
-```
-``` cpp
-template <class ForwardIterator, class Size>
-  ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n);
-```
-*Effects:* Equivalent to:
-``` cpp
-for (; n>0; (void)++first, --n)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type();
-return first;
-```
-#### `uninitialized_copy` <a id="uninitialized.copy">[[uninitialized.copy]]</a>
-``` cpp
-template <class InputIterator, class ForwardIterator>
-  ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
-                                     ForwardIterator result);
-```
-*Effects:* As if by:
-``` cpp
-for (; first != last; ++result, (void) ++first)
-  ::new (static_cast<void*>(addressof(*result)))
-    typename iterator_traits<ForwardIterator>::value_type(*first);
-```
-*Returns:* `result`.
-``` cpp
-template <class InputIterator, class Size, class ForwardIterator>
-  ForwardIterator uninitialized_copy_n(InputIterator first, Size n,
-                                       ForwardIterator result);
-```
-*Effects:* As if by:
-``` cpp
-for ( ; n > 0; ++result, (void) ++first, --n) {
-  ::new (static_cast<void*>(addressof(*result)))
-    typename iterator_traits<ForwardIterator>::value_type(*first);
-}
-```
-*Returns:* `result`.
-#### `uninitialized_move` <a id="uninitialized.move">[[uninitialized.move]]</a>
-``` cpp
-template <class InputIterator, class ForwardIterator>
-  ForwardIterator uninitialized_move(InputIterator first, InputIterator last,
-                                     ForwardIterator result);
-```
-*Effects:* Equivalent to:
-``` cpp
-for (; first != last; (void)++result, ++first)
-  ::new (static_cast<void*>(addressof(*result)))
-    typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
-return result;
-```
-*Remarks:* If an exception is thrown, some objects in the range
-\[`first`, `last`) are left in a valid but unspecified state.
-``` cpp
-template <class InputIterator, class Size, class ForwardIterator>
-  pair<InputIterator, ForwardIterator>
-    uninitialized_move_n(InputIterator first, Size n, ForwardIterator result);
-```
-*Effects:* Equivalent to:
-``` cpp
-for (; n > 0; ++result, (void) ++first, --n)
-  ::new (static_cast<void*>(addressof(*result)))
-    typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
-return {first,result};
-```
-*Remarks:* If an exception is thrown, some objects in the range
-\[`first`, `std::next(first,n)`) are left in a valid but unspecified
-state.
-#### `uninitialized_fill` <a id="uninitialized.fill">[[uninitialized.fill]]</a>
-``` cpp
-template <class ForwardIterator, class T>
-  void uninitialized_fill(ForwardIterator first, ForwardIterator last,
-                          const T& x);
-```
-*Effects:* As if by:
-``` cpp
-for (; first != last; ++first)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type(x);
-```
-``` cpp
-template <class ForwardIterator, class Size, class T>
-  ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
-```
-*Effects:* As if by:
-``` cpp
-for (; n--; ++first)
-  ::new (static_cast<void*>(addressof(*first)))
-    typename iterator_traits<ForwardIterator>::value_type(x);
-return first;
-```
-#### `destroy` <a id="specialized.destroy">[[specialized.destroy]]</a>
-``` cpp
-template <class T>
-  void destroy_at(T* location);
-```
-*Effects:* Equivalent to:
-``` cpp
-location->~T();
-```
-``` cpp
-template <class ForwardIterator>
-  void destroy(ForwardIterator first, ForwardIterator last);
-```
-*Effects:* Equivalent to:
-``` cpp
-for (; first!=last; ++first)
-  destroy_at(addressof(*first));
-```
-``` cpp
-template <class ForwardIterator, class Size>
-  ForwardIterator destroy_n(ForwardIterator first, Size n);
-```
-*Effects:* Equivalent to:
-``` cpp
-for (; n > 0; (void)++first, --n)
-  destroy_at(addressof(*first));
-return first;
-```
 ### C library memory allocation <a id="c.malloc">[[c.malloc]]</a>
-[*Note 1*: The header `<cstdlib>` ([[cstdlib.syn]]) declares the
-functions described in this subclause. — *end note*]
 ``` cpp
 void* aligned_alloc(size_t alignment, size_t size);
 void* calloc(size_t nmemb, size_t size);
 void* malloc(size_t size);
@@ -1075,11 +1243,11 @@ void* realloc(void* ptr, size_t size);
 *Effects:* These functions have the semantics specified in the C
 standard library.
 *Remarks:* These functions do not attempt to allocate storage by calling
-`::operator new()` ([[support.dynamic]]).
 Storage allocated directly with these functions is implicitly declared
 reachable (see  [[basic.stc.dynamic.safety]]) on allocation, ceases to
 be declared reachable on deallocation, and need not cease to be declared
 reachable as the result of an `undeclare_reachable()` call.
@@ -1093,17 +1261,22 @@ implemented with a separate allocation arena, bypassing the normal
 intentionally be used as a replacement for `declare_reachable()`, and
 newly written code is strongly encouraged to treat memory allocated with
 these functions as though it were allocated with
 `operator new`. — *end note*]
 ``` cpp
 void free(void* ptr);
 ```
 *Effects:* This function has the semantics specified in the C standard
 library.
 *Remarks:* This function does not attempt to deallocate storage by
 calling `::operator delete()`.
-ISO C 7.22.3.

 ## Memory <a id="memory">[[memory]]</a>
 ### In general <a id="memory.general">[[memory.general]]</a>
+Subclause  [[memory]] describes the contents of the header `<memory>`
+and some of the contents of the header `<cstdlib>`.
 ### Header `<memory>` synopsis <a id="memory.syn">[[memory.syn]]</a>
 The header `<memory>` defines several types and function templates that
 describe properties of pointers and pointer-like types, manage memory
 for containers and other template types, destroy objects, and construct
+objects in uninitialized memory buffers ([[pointer.traits]]–
+[[specialized.addressof]] and [[specialized.algorithms]]). The header
+also defines the templates `unique_ptr`, `shared_ptr`, `weak_ptr`, and
+various function templates that operate on objects of these types
+[[smartptr]].
 ``` cpp
+#include <compare>              // see [compare.syn]
 namespace std {
   // [pointer.traits], pointer traits
   template<class Ptr> struct pointer_traits;
   template<class T> struct pointer_traits<T*>;
+  // [pointer.conversion], pointer conversion
+  template<class T>
+    constexpr T* to_address(T* p) noexcept;
+  template<class Ptr>
+    constexpr auto to_address(const Ptr& p) noexcept;
+  // [util.dynamic.safety], pointer safety%
+%
+{pointer_safety{pointer_safety{pointer_safety}
   enum class pointer_safety { relaxed, preferred, strict };
   void declare_reachable(void* p);
+  template<class T>
+    T* undeclare_reachable(T* p);
   void declare_no_pointers(char* p, size_t n);
   void undeclare_no_pointers(char* p, size_t n);
   pointer_safety get_pointer_safety() noexcept;
+  // [ptr.align], pointer alignment
   void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
+  template<size_t N, class T>
+    [[nodiscard]] constexpr T* assume_aligned(T* ptr);
   // [allocator.tag], allocator argument tag
   struct allocator_arg_t { explicit allocator_arg_t() = default; };
   inline constexpr allocator_arg_t allocator_arg{};
   // [allocator.uses], uses_allocator
   template<class T, class Alloc> struct uses_allocator;
+  // [allocator.uses.trait], uses_allocator
+  template<class T, class Alloc>
+    inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
+  // [allocator.uses.construction], uses-allocator construction
+  template<class T, class Alloc, class... Args>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                    Args&&... args) noexcept -> see below;
+  template<class T, class Alloc, class Tuple1, class Tuple2>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc, piecewise_construct_t,
+                                                    Tuple1&& x, Tuple2&& y)
+                                                    noexcept ->  see below;
+  template<class T, class Alloc>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc) noexcept -> see below;
+  template<class T, class Alloc, class U, class V>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                    U&& u, V&& v) noexcept -> see below;
+  template<class T, class Alloc, class U, class V>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                    const pair<U,V>& pr) noexcept -> see below;
+  template<class T, class Alloc, class U, class V>
+    constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                    pair<U,V>&& pr) noexcept -> see below;
+  template<class T, class Alloc, class... Args>
+    constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args);
+  template<class T, class Alloc, class... Args>
+    constexpr T* uninitialized_construct_using_allocator(T* p, const Alloc& alloc,
+                                                         Args&&... args);
   // [allocator.traits], allocator traits
   template<class Alloc> struct allocator_traits;
   // [default.allocator], the default allocator
   template<class T> class allocator;
   template<class T, class U>
+ constexpr bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
+  // [specialized.addressof], addressof
+  template<class T>
+    constexpr T* addressof(T& r) noexcept;
+  template<class T>
+    const T* addressof(const T&&) = delete;
   // [specialized.algorithms], specialized algorithms
+ // [special.mem.concepts], special memory concepts
+  template<class I>
+    concept no-throw-input-iterator = see below;    // exposition only
+  template<class I>
+    concept no-throw-forward-iterator = see below;  // exposition only
+  template<class S, class I>
+    concept no-throw-sentinel = see below;          // exposition only
+  template<class R>
+    concept no-throw-input-range = see below;       // exposition only
+  template<class R>
+    concept no-throw-forward-range = see below;     // exposition only
+  template<class NoThrowForwardIterator>
+    void uninitialized_default_construct(NoThrowForwardIterator first,
+                                         NoThrowForwardIterator last);
+  template<class ExecutionPolicy, class NoThrowForwardIterator>
     void uninitialized_default_construct(ExecutionPolicy&& exec,        // see [algorithms.parallel.overloads]
+ NoThrowForwardIterator first,
+                                         NoThrowForwardIterator last);
+  template<class NoThrowForwardIterator, class Size>
+    NoThrowForwardIterator
+ uninitialized_default_construct_n(NoThrowForwardIterator first, Size n);
+  template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
+    NoThrowForwardIterator
+      uninitialized_default_construct_n(ExecutionPolicy&& exec,         // see [algorithms.parallel.overloads]
+                                        NoThrowForwardIterator first, Size n);
+  namespace ranges {
+    template<no-throw-forward-iterator I, no-throw-sentinel<I> S>
+      requires default_initializable<iter_value_t<I>>
+        I uninitialized_default_construct(I first, S last);
+    template<no-throw-forward-range R>
+      requires default_initializable<range_value_t<R>>
+        borrowed_iterator_t<R> uninitialized_default_construct(R&& r);
+    template<no-throw-forward-iterator I>
+      requires default_initializable<iter_value_t<I>>
+        I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
+  }
+  template<class NoThrowForwardIterator>
+    void uninitialized_value_construct(NoThrowForwardIterator first,
+                                       NoThrowForwardIterator last);
+  template<class ExecutionPolicy, class NoThrowForwardIterator>
     void uninitialized_value_construct(ExecutionPolicy&& exec,  // see [algorithms.parallel.overloads]
+ NoThrowForwardIterator first,
+                                       NoThrowForwardIterator last);
+  template<class NoThrowForwardIterator, class Size>
+    NoThrowForwardIterator
+ uninitialized_value_construct_n(NoThrowForwardIterator first, Size n);
+  template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
+    NoThrowForwardIterator
+      uninitialized_value_construct_n(ExecutionPolicy&& exec,   // see [algorithms.parallel.overloads]
+                                      NoThrowForwardIterator first, Size n);
+  namespace ranges {
+    template<no-throw-forward-iterator I, no-throw-sentinel<I> S>
+      requires default_initializable<iter_value_t<I>>
+        I uninitialized_value_construct(I first, S last);
+    template<no-throw-forward-range R>
+      requires default_initializable<range_value_t<R>>
+        borrowed_iterator_t<R> uninitialized_value_construct(R&& r);
+    template<no-throw-forward-iterator I>
+      requires default_initializable<iter_value_t<I>>
+        I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
+  }
+  template<class InputIterator, class NoThrowForwardIterator>
+    NoThrowForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
+                                              NoThrowForwardIterator result);
+  template<class ExecutionPolicy, class InputIterator, class NoThrowForwardIterator>
+    NoThrowForwardIterator uninitialized_copy(ExecutionPolicy&& exec,   // see [algorithms.parallel.overloads]
                                               InputIterator first, InputIterator last,
+                                              NoThrowForwardIterator result);
+  template<class InputIterator, class Size, class NoThrowForwardIterator>
+ NoThrowForwardIterator uninitialized_copy_n(InputIterator first, Size n,
+                                                NoThrowForwardIterator result);
+  template<class ExecutionPolicy, class InputIterator, class Size, class NoThrowForwardIterator>
+ NoThrowForwardIterator uninitialized_copy_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
                                                 InputIterator first, Size n,
+                                                NoThrowForwardIterator result);
+  namespace ranges {
+    template<class I, class O>
+      using uninitialized_copy_result = in_out_result<I, O>;
+ template<input_iterator I, sentinel_for<I> S1,
+             no-throw-forward-iterator O, no-throw-sentinel<O> S2>
+      requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
+        uninitialized_copy_result<I, O>
+          uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast);
+    template<input_range IR, no-throw-forward-range OR>
+      requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
+        uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
+          uninitialized_copy(IR&& in_range, OR&& out_range);
+    template<class I, class O>
+      using uninitialized_copy_n_result = in_out_result<I, O>;
+    template<input_iterator I, no-throw-forward-iterator O, no-throw-sentinel<O> S>
+      requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
+        uninitialized_copy_n_result<I, O>
+          uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
+  }
+  template<class InputIterator, class NoThrowForwardIterator>
+    NoThrowForwardIterator uninitialized_move(InputIterator first, InputIterator last,
+                                              NoThrowForwardIterator result);
+  template<class ExecutionPolicy, class InputIterator, class NoThrowForwardIterator>
+    NoThrowForwardIterator uninitialized_move(ExecutionPolicy&& exec,   // see [algorithms.parallel.overloads]
                                               InputIterator first, InputIterator last,
+                                              NoThrowForwardIterator result);
+  template<class InputIterator, class Size, class NoThrowForwardIterator>
+    pair<InputIterator, NoThrowForwardIterator>
+      uninitialized_move_n(InputIterator first, Size n, NoThrowForwardIterator result);
+  template<class ExecutionPolicy, class InputIterator, class Size, class NoThrowForwardIterator>
+    pair<InputIterator, NoThrowForwardIterator>
       uninitialized_move_n(ExecutionPolicy&& exec,              // see [algorithms.parallel.overloads]
+                           InputIterator first, Size n, NoThrowForwardIterator result);
+  namespace ranges {
+    template<class I, class O>
+      using uninitialized_move_result = in_out_result<I, O>;
+    template<input_iterator I, sentinel_for<I> S1,
+             no-throw-forward-iterator O, no-throw-sentinel<O> S2>
+      requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
+        uninitialized_move_result<I, O>
+          uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast);
+    template<input_range IR, no-throw-forward-range OR>
+      requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>
+        uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
+          uninitialized_move(IR&& in_range, OR&& out_range);
+    template<class I, class O>
+      using uninitialized_move_n_result = in_out_result<I, O>;
+    template<input_iterator I,
+             no-throw-forward-iterator O, no-throw-sentinel<O> S>
+      requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
+        uninitialized_move_n_result<I, O>
+          uninitialized_move_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
+  }
+  template<class NoThrowForwardIterator, class T>
+    void uninitialized_fill(NoThrowForwardIterator first, NoThrowForwardIterator last,
                             const T& x);
+  template<class ExecutionPolicy, class NoThrowForwardIterator, class T>
     void uninitialized_fill(ExecutionPolicy&& exec,             // see [algorithms.parallel.overloads]
+ NoThrowForwardIterator first, NoThrowForwardIterator last,
                             const T& x);
+  template<class NoThrowForwardIterator, class Size, class T>
+ NoThrowForwardIterator
+      uninitialized_fill_n(NoThrowForwardIterator first, Size n, const T& x);
+  template<class ExecutionPolicy, class NoThrowForwardIterator, class Size, class T>
+    NoThrowForwardIterator
+      uninitialized_fill_n(ExecutionPolicy&& exec,              // see [algorithms.parallel.overloads]
+                           NoThrowForwardIterator first, Size n, const T& x);
+  namespace ranges {
+    template<no-throw-forward-iterator I, no-throw-sentinel<I> S, class T>
+      requires constructible_from<iter_value_t<I>, const T&>
+        I uninitialized_fill(I first, S last, const T& x);
+    template<no-throw-forward-range R, class T>
+      requires constructible_from<range_value_t<R>, const T&>
+        borrowed_iterator_t<R> uninitialized_fill(R&& r, const T& x);
+    template<no-throw-forward-iterator I, class T>
+      requires constructible_from<iter_value_t<I>, const T&>
+        I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
+  }
+  // [specialized.construct], construct_at
+  template<class T, class... Args>
+    constexpr T* construct_at(T* location, Args&&... args);
+  namespace ranges {
+    template<class T, class... Args>
+      constexpr T* construct_at(T* location, Args&&... args);
+  }
+  // [specialized.destroy], destroy
   template<class T>
+ constexpr void destroy_at(T* location);
+  template<class NoThrowForwardIterator>
+ constexpr void destroy(NoThrowForwardIterator first, NoThrowForwardIterator last);
+  template<class ExecutionPolicy, class NoThrowForwardIterator>
     void destroy(ExecutionPolicy&& exec,                        // see [algorithms.parallel.overloads]
+ NoThrowForwardIterator first, NoThrowForwardIterator last);
+  template<class NoThrowForwardIterator, class Size>
+ constexpr NoThrowForwardIterator destroy_n(NoThrowForwardIterator first, Size n);
+  template<class ExecutionPolicy, class NoThrowForwardIterator, class Size>
+ NoThrowForwardIterator destroy_n(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
+                                     NoThrowForwardIterator first, Size n);
+  namespace ranges {
+    template<destructible T>
+      constexpr void destroy_at(T* location) noexcept;
+    template<no-throw-input-iterator I, no-throw-sentinel<I> S>
+      requires destructible<iter_value_t<I>>
+        constexpr I destroy(I first, S last) noexcept;
+    template<no-throw-input-range R>
+      requires destructible<range_value_t<R>>
+        constexpr borrowed_iterator_t<R> destroy(R&& r) noexcept;
+    template<no-throw-input-iterator I>
+      requires destructible<iter_value_t<I>>
+        constexpr I destroy_n(I first, iter_difference_t<I> n) noexcept;
+  }
   // [unique.ptr], class template unique_ptr
   template<class T> struct default_delete;
   template<class T> struct default_delete<T[]>;
   template<class T, class D = default_delete<T>> class unique_ptr;
   template<class T, class D> class unique_ptr<T[], D>;
+  template<class T, class... Args>
+ unique_ptr<T> make_unique(Args&&... args);                                  // T is not array
+  template<class T>
+    unique_ptr<T> make_unique(size_t n);                                        // T is U[]
+  template<class T, class... Args>
+    unspecified make_unique(Args&&...) = delete;                                // T is U[N]
+  template<class T>
+    unique_ptr<T> make_unique_for_overwrite();                                  // T is not array
+  template<class T>
+    unique_ptr<T> make_unique_for_overwrite(size_t n);                          // T is U[]
+  template<class T, class... Args>
+    unspecified make_unique_for_overwrite(Args&&...) = delete;                  // T is U[N]
+  template<class T, class D>
+    void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
   template<class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
     bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
     bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+  template<class T1, class D1, class T2, class D2>
+    bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
     bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+  template<class T1, class D1, class T2, class D2>
+    requires three_way_comparable_with<typename unique_ptr<T1, D1>::pointer,
+                                       typename unique_ptr<T2, D2>::pointer>
+    compare_three_way_result_t<typename unique_ptr<T1, D1>::pointer,
+                               typename unique_ptr<T2, D2>::pointer>
+      operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T, class D>
     bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
   template<class T, class D>
     bool operator<(const unique_ptr<T, D>& x, nullptr_t);
   template<class T, class D>
     bool operator<(nullptr_t, const unique_ptr<T, D>& y);
   template<class T, class D>
     bool operator>(const unique_ptr<T, D>& x, nullptr_t);
   template<class T, class D>
     bool operator>(nullptr_t, const unique_ptr<T, D>& y);
+  template<class T, class D>
+    bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
+  template<class T, class D>
+    bool operator<=(nullptr_t, const unique_ptr<T, D>& y);
   template<class T, class D>
     bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
   template<class T, class D>
     bool operator>=(nullptr_t, const unique_ptr<T, D>& y);
+  template<class T, class D>
+    requires three_way_comparable_with<typename unique_ptr<T, D>::pointer, nullptr_t>
+    compare_three_way_result_t<typename unique_ptr<T, D>::pointer, nullptr_t>
+      operator<=>(const unique_ptr<T, D>& x, nullptr_t);
+  template<class E, class T, class Y, class D>
+    basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const unique_ptr<Y, D>& p);
   // [util.smartptr.weak.bad], class bad_weak_ptr
   class bad_weak_ptr;
   // [util.smartptr.shared], class template shared_ptr
   template<class T> class shared_ptr;
   // [util.smartptr.shared.create], shared_ptr creation
   template<class T, class... Args>
+    shared_ptr<T> make_shared(Args&&... args);                                  // T is not array
   template<class T, class A, class... Args>
+    shared_ptr<T> allocate_shared(const A& a, Args&&... args);                  // T is not array
+  template<class T>
+    shared_ptr<T> make_shared(size_t N);                                        // T is U[]
+  template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a, size_t N);                        // T is U[]
+  template<class T>
+    shared_ptr<T> make_shared();                                                // T is U[N]
+  template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a);                                  // T is U[N]
+  template<class T>
+    shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u);           // T is U[]
+  template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a, size_t N,
+                                  const remove_extent_t<T>& u);                 // T is U[]
+  template<class T>
+    shared_ptr<T> make_shared(const remove_extent_t<T>& u);                     // T is U[N]
+  template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u);     // T is U[N]
+  template<class T>
+    shared_ptr<T> make_shared_for_overwrite();                                  // T is not U[]
+  template<class T, class A>
+    shared_ptr<T> allocate_shared_for_overwrite(const A& a);                    // T is not U[]
+  template<class T>
+    shared_ptr<T> make_shared_for_overwrite(size_t N);                          // T is U[]
+  template<class T, class A>
+    shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N);          // T is U[]
   // [util.smartptr.shared.cmp], shared_ptr comparisons
   template<class T, class U>
     bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
   template<class T, class U>
+ strong_ordering operator<=>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
   template<class T>
     bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
   template<class T>
+ strong_ordering operator<=>(const shared_ptr<T>& x, nullptr_t) noexcept;
   // [util.smartptr.shared.spec], shared_ptr specialized algorithms
   template<class T>
     void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
   // [util.smartptr.shared.cast], shared_ptr casts
   template<class T, class U>
     shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
+  template<class T, class U>
+    shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r) noexcept;
   template<class T, class U>
     shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
+  template<class T, class U>
+    shared_ptr<T> dynamic_pointer_cast(shared_ptr<U>&& r) noexcept;
   template<class T, class U>
     shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
+  template<class T, class U>
+    shared_ptr<T> const_pointer_cast(shared_ptr<U>&& r) noexcept;
+  template<class T, class U>
+    shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
+  template<class T, class U>
+    shared_ptr<T> reinterpret_pointer_cast(shared_ptr<U>&& r) noexcept;
   // [util.smartptr.getdeleter], shared_ptr get_deleter
   template<class D, class T>
     D* get_deleter(const shared_ptr<T>& p) noexcept;
   template<class T = void> struct owner_less;
   // [util.smartptr.enab], class template enable_shared_from_this
   template<class T> class enable_shared_from_this;
   // [util.smartptr.hash], hash support
   template<class T> struct hash;
   template<class T, class D> struct hash<unique_ptr<T, D>>;
   template<class T> struct hash<shared_ptr<T>>;
+  // [util.smartptr.atomic], atomic smart pointers
+  template<class T> struct atomic;
+  template<class T> struct atomic<shared_ptr<T>>;
+  template<class T> struct atomic<weak_ptr<T>>;
 }
 ```
 ### Pointer traits <a id="pointer.traits">[[pointer.traits]]</a>
     using element_type    = T;
     using difference_type = ptrdiff_t;
     template<class U> using rebind = U*;
+    static constexpr pointer pointer_to(see below r) noexcept;
   };
 }
 ```
+#### Member types <a id="pointer.traits.types">[[pointer.traits.types]]</a>
 ``` cpp
 using element_type = see below;
 ```
 *Type:* `Ptr::element_type` if the *qualified-id* `Ptr::element_type` is
+valid and denotes a type [[temp.deduct]]; otherwise, `T` if `Ptr` is a
+class template instantiation of the form `SomePointer<T, Args>`, where
 `Args` is zero or more type arguments; otherwise, the specialization is
 ill-formed.
 ``` cpp
 using difference_type = see below;
 ```
 *Type:* `Ptr::difference_type` if the *qualified-id*
+`Ptr::difference_type` is valid and denotes a type [[temp.deduct]];
 otherwise, `ptrdiff_t`.
 ``` cpp
 template<class U> using rebind = see below;
 ```
 *Alias template:* `Ptr::rebind<U>` if the *qualified-id*
+`Ptr::rebind<U>` is valid and denotes a type [[temp.deduct]]; otherwise,
+`SomePointer<U, Args>` if `Ptr` is a class template instantiation of the
+form `SomePointer<T, Args>`, where `Args` is zero or more type
+arguments; otherwise, the instantiation of `rebind` is ill-formed.
+#### Member functions <a id="pointer.traits.functions">[[pointer.traits.functions]]</a>
 ``` cpp
 static pointer pointer_traits::pointer_to(see below r);
+static constexpr pointer pointer_traits<T*>::pointer_to(see below r) noexcept;
 ```
+*Mandates:* For the first member function, `Ptr::pointer_to(r)` is
+well-formed.
+*Preconditions:* For the first member function, `Ptr::pointer_to(r)`
+returns a pointer to `r` through which indirection is valid.
+*Returns:* The first member function returns `Ptr::pointer_to(r)`. The
+second member function returns `addressof(r)`.
 *Remarks:* If `element_type` is cv `void`, the type of `r` is
 unspecified; otherwise, it is `element_type&`.
+#### Optional members <a id="pointer.traits.optmem">[[pointer.traits.optmem]]</a>
+Specializations of `pointer_traits` may define the member declared in
+this subclause to customize the behavior of the standard library.
+``` cpp
+static element_type* to_address(pointer p) noexcept;
+```
+*Returns:* A pointer of type `element_type*` that references the same
+location as the argument `p`.
+[*Note 1*: This function should be the inverse of `pointer_to`. If
+defined, it customizes the behavior of the non-member function
+`to_address` [[pointer.conversion]]. — *end note*]
+### Pointer conversion <a id="pointer.conversion">[[pointer.conversion]]</a>
+``` cpp
+template<class T> constexpr T* to_address(T* p) noexcept;
+```
+*Mandates:* `T` is not a function type.
+*Returns:* `p`.
+``` cpp
+template<class Ptr> constexpr auto to_address(const Ptr& p) noexcept;
+```
+*Returns:* `pointer_traits<Ptr>::to_address(p)` if that expression is
+well-formed (see [[pointer.traits.optmem]]), otherwise
+`to_address(p.operator->())`.
 ### Pointer safety <a id="util.dynamic.safety">[[util.dynamic.safety]]</a>
 A complete object is *declared reachable* while the number of calls to
 `declare_reachable` with an argument referencing the object exceeds the
 ``` cpp
 void declare_reachable(void* p);
 ```
+*Preconditions:* `p` is a safely-derived
+pointer [[basic.stc.dynamic.safety]] or a null pointer value.
 *Effects:* If `p` is not null, the complete object referenced by `p` is
+subsequently declared reachable [[basic.stc.dynamic.safety]].
 *Throws:* May throw `bad_alloc` if the system cannot allocate additional
 memory that may be required to track objects declared reachable.
 ``` cpp
 template<class T> T* undeclare_reachable(T* p);
 ```
+*Preconditions:* If `p` is not null, the complete object referenced by
+`p` has been previously declared reachable, and is live [[basic.life]]
+from the time of the call until the last `undeclare_reachable(p)` call
+on the object.
+*Returns:* A safely derived copy of `p` which compares equal to `p`.
 *Throws:* Nothing.
 [*Note 1*: It is expected that calls to `declare_reachable(p)` will
 consume a small amount of memory in addition to that occupied by the
 ``` cpp
 void declare_no_pointers(char* p, size_t n);
 ```
+*Preconditions:* No bytes in the specified range are currently
+registered with `declare_no_pointers()`. If the specified range is in an
+allocated object, then it is entirely within a single allocated object.
+The object is live until the corresponding `undeclare_no_pointers()`
 call.
 [*Note 2*: In a garbage-collecting implementation, the fact that a
 region in an object is registered with `declare_no_pointers()` should
 not prevent the object from being collected. — *end note*]
 ``` cpp
 void undeclare_no_pointers(char* p, size_t n);
 ```
+*Preconditions:* The same range has previously been passed to
 `declare_no_pointers()`.
 *Effects:* Unregisters a range registered with `declare_no_pointers()`
+for destruction. It shall be called before the lifetime of the object
 ends.
 *Throws:* Nothing.
 ``` cpp
 pointer_safety get_pointer_safety() noexcept;
 ```
 *Returns:* `pointer_safety::strict` if the implementation has strict
+pointer safety [[basic.stc.dynamic.safety]]. It is
 *implementation-defined* whether `get_pointer_safety` returns
 `pointer_safety::relaxed` or `pointer_safety::preferred` if the
 implementation has relaxed pointer safety.[^1]
+### Pointer alignment <a id="ptr.align">[[ptr.align]]</a>
 ``` cpp
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 ```
+*Preconditions:*
+- `alignment` is a power of two
+- `ptr` represents the address of contiguous storage of at least `space`
+  bytes
 *Effects:* If it is possible to fit `size` bytes of storage aligned by
 `alignment` into the buffer pointed to by `ptr` with length `space`, the
 function updates `ptr` to represent the first possible address of such
 storage and decreases `space` by the number of bytes used for alignment.
 Otherwise, the function does nothing.
 *Returns:* A null pointer if the requested aligned buffer would not fit
 into the available space, otherwise the adjusted value of `ptr`.
 [*Note 1*: The function updates its `ptr` and `space` arguments so that
 it can be called repeatedly with possibly different `alignment` and
 `size` arguments for the same buffer. — *end note*]
+``` cpp
+template<size_t N, class T>
+  [[nodiscard]] constexpr T* assume_aligned(T* ptr);
+```
+*Mandates:* `N` is a power of two.
+*Preconditions:* `ptr` points to an object `X` of a type
+similar [[conv.qual]] to `T`, where `X` has alignment `N`
+[[basic.align]].
+*Returns:* `ptr`.
+*Throws:* Nothing.
+[*Note 2*: The alignment assumption on an object `X` expressed by a
+call to `assume_aligned` may result in generation of more efficient
+code. It is up to the program to ensure that the assumption actually
+holds. The call does not cause the compiler to verify or enforce this.
+An implementation might only make the assumption for those operations on
+`X` that access `X` through the pointer returned by
+`assume_aligned`. — *end note*]
 ### Allocator argument tag <a id="allocator.tag">[[allocator.tag]]</a>
 ``` cpp
 namespace std {
   struct allocator_arg_t { explicit allocator_arg_t() = default; };
   inline constexpr allocator_arg_t allocator_arg{};
 }
 ```
+The `allocator_arg_t` struct is an empty class type used as a unique
 type to disambiguate constructor and function overloading. Specifically,
 several types (see `tuple`  [[tuple]]) have constructors with
 `allocator_arg_t` as the first argument, immediately followed by an
+argument of a type that meets the *Cpp17Allocator* requirements (
+[[cpp17.allocator]]).
 ### `uses_allocator` <a id="allocator.uses">[[allocator.uses]]</a>
 #### `uses_allocator` trait <a id="allocator.uses.trait">[[allocator.uses.trait]]</a>
 template<class T, class Alloc> struct uses_allocator;
 ```
 *Remarks:* Automatically detects whether `T` has a nested
 `allocator_type` that is convertible from `Alloc`. Meets the
+*Cpp17BinaryTypeTrait* requirements [[meta.rqmts]]. The implementation
 shall provide a definition that is derived from `true_type` if the
 *qualified-id* `T::allocator_type` is valid and denotes a
+type [[temp.deduct]] and
 `is_convertible_v<Alloc, T::allocator_type> != false`, otherwise it
 shall be derived from `false_type`. A program may specialize this
+template to derive from `true_type` for a program-defined type `T` that
 does not have a nested `allocator_type` but nonetheless can be
 constructed with an allocator where either:
 - the first argument of a constructor has type `allocator_arg_t` and the
   second argument has type `Alloc` or
 - the last argument of a constructor has type `Alloc`.
 #### Uses-allocator construction <a id="allocator.uses.construction">[[allocator.uses.construction]]</a>
+*Uses-allocator construction* with allocator `alloc` and constructor
+arguments `args...` refers to the construction of an object of type `T`
+such that `alloc` is passed to the constructor of `T` if `T` uses an
+allocator type compatible with `alloc`. When applied to the construction
+of an object of type `T`, it is equivalent to initializing it with the
+value of the expression `make_obj_using_allocator<T>(alloc, args...)`,
+described below.
+The following utility functions support three conventions for passing
+`alloc` to a constructor:
+- If `T` does not use an allocator compatible with `alloc`, then `alloc`
+ is ignored.
+- Otherwise, if `T` has a constructor invocable as
+  `T(allocator_arg, alloc, args...)` (leading-allocator convention),
+  then uses-allocator construction chooses this constructor form.
+- Otherwise, if `T` has a constructor invocable as `T(args..., alloc)`
+ (trailing-allocator convention), then uses-allocator construction
+ chooses this constructor form.
+The `uses_allocator_construction_args` function template takes an
+allocator and argument list and produces (as a tuple) a new argument
+list matching one of the above conventions. Additionally, overloads are
+provided that treat specializations of `pair` such that uses-allocator
+construction is applied individually to the `first` and `second` data
+members. The `make_obj_using_allocator` and
+`uninitialized_construct_using_allocator` function templates apply the
+modified constructor arguments to construct an object of type `T` as a
+return value or in-place, respectively.
+[*Note 1*: For `uses_allocator_construction_args` and
+`make_obj_using_allocator`, type `T` is not deduced and must therefore
+be specified explicitly by the caller. — *end note*]
+``` cpp
+template<class T, class Alloc, class... Args>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                  Args&&... args) noexcept -> see below;
+```
+*Constraints:* `T` is not a specialization of `pair`.
+*Returns:* A `tuple` value determined as follows:
+- If `uses_allocator_v<T, Alloc>` is `false` and
+  `is_constructible_v<T, Args...>` is `true`, return
+  `forward_as_tuple(std::forward<Args>(args)...)`.
+- Otherwise, if `uses_allocator_v<T, Alloc>` is `true` and
+  `is_constructible_v<T, allocator_arg_t, const Alloc&, Args...>` is
+  `true`, return
+  ``` cpp
+  tuple<allocator_arg_t, const Alloc&, Args&&...>(
+    allocator_arg, alloc, std::forward<Args>(args)...)
+  ```
+- Otherwise, if `uses_allocator_v<T, Alloc>` is `true` and
+  `is_constructible_v<T, Args..., const Alloc&>` is `true`, return
+  `forward_as_tuple(std::forward<Args>(args)..., alloc)`.
+- Otherwise, the program is ill-formed.
+[*Note 1*: This definition prevents a silent failure to pass the
+allocator to a constructor of a type for which
+`uses_allocator_v<T, Alloc>` is `true`. — *end note*]
+``` cpp
+template<class T, class Alloc, class Tuple1, class Tuple2>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc, piecewise_construct_t,
+                                                  Tuple1&& x, Tuple2&& y)
+                                                  noexcept -> see below;
+```
+*Constraints:* `T` is a specialization of `pair`.
+*Effects:* For `T` specified as `pair<T1, T2>`, equivalent to:
+``` cpp
+return make_tuple(
+  piecewise_construct,
+  apply([&alloc](auto&&... args1) {
+          return uses_allocator_construction_args<T1>(
+            alloc, std::forward<decltype(args1)>(args1)...);
+        }, std::forward<Tuple1>(x)),
+  apply([&alloc](auto&&... args2) {
+          return uses_allocator_construction_args<T2>(
+            alloc, std::forward<decltype(args2)>(args2)...);
+        }, std::forward<Tuple2>(y)));
+```
+``` cpp
+template<class T, class Alloc>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc) noexcept -> see below;
+```
+*Constraints:* `T` is a specialization of `pair`.
+*Effects:* Equivalent to:
+``` cpp
+return uses_allocator_construction_args<T>(alloc, piecewise_construct,
+                                           tuple<>{}, tuple<>{});
+```
+``` cpp
+template<class T, class Alloc, class U, class V>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                  U&& u, V&& v) noexcept -> see below;
+```
+*Constraints:* `T` is a specialization of `pair`.
+*Effects:* Equivalent to:
+``` cpp
+return uses_allocator_construction_args<T>(alloc, piecewise_construct,
+                                           forward_as_tuple(std::forward<U>(u)),
+                                           forward_as_tuple(std::forward<V>(v)));
+```
+``` cpp
+template<class T, class Alloc, class U, class V>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                  const pair<U,V>& pr) noexcept -> see below;
+```
+*Constraints:* `T` is a specialization of `pair`.
+*Effects:* Equivalent to:
+``` cpp
+return uses_allocator_construction_args<T>(alloc, piecewise_construct,
+                                           forward_as_tuple(pr.first),
+                                           forward_as_tuple(pr.second));
+```
+``` cpp
+template<class T, class Alloc, class U, class V>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,
+                                                  pair<U,V>&& pr) noexcept -> see below;
+```
+*Constraints:* `T` is a specialization of `pair`.
+*Effects:* Equivalent to:
+``` cpp
+return uses_allocator_construction_args<T>(alloc, piecewise_construct,
+                                           forward_as_tuple(std::move(pr).first),
+                                           forward_as_tuple(std::move(pr).second));
+```
+``` cpp
+template<class T, class Alloc, class... Args>
+  constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+return make_from_tuple<T>(uses_allocator_construction_args<T>(
+                            alloc, std::forward<Args>(args)...));
+```
+``` cpp
+template<class T, class Alloc, class... Args>
+  constexpr T* uninitialized_construct_using_allocator(T* p, const Alloc& alloc, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+return apply([&]<class... U>(U&&... xs) {
+       return construct_at(p, std::forward<U>(xs)...);
+     }, uses_allocator_construction_args<T>(alloc, std::forward<Args>(args)...));
+```
 ### Allocator traits <a id="allocator.traits">[[allocator.traits]]</a>
 The class template `allocator_traits` supplies a uniform interface to
 all allocator types. An allocator cannot be a non-class type, however,
     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>>;
+ [[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n);
+ [[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n,
+                                                    const_void_pointer hint);
+    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);
   };
 }
 ```
+#### Member types <a id="allocator.traits.types">[[allocator.traits.types]]</a>
 ``` cpp
 using pointer = see below;
 ```
 *Type:* `Alloc::pointer` if the *qualified-id* `Alloc::pointer` is valid
+and denotes a type [[temp.deduct]]; otherwise, `value_type*`.
 ``` cpp
 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>`.
 ``` cpp
 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>`.
 ``` cpp
 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>`.
 ``` cpp
 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`.
 ``` cpp
 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>`.
 ``` cpp
 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]]; otherwise `false_type`.
 ``` cpp
 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]]; otherwise `false_type`.
 ``` cpp
 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]]; otherwise `false_type`.
 ``` cpp
 using is_always_equal = see below;
 ```
 *Type:* `Alloc::is_always_equal` if the *qualified-id*
+`Alloc::is_always_equal` is valid and denotes a type [[temp.deduct]];
 otherwise `is_empty<Alloc>::type`.
 ``` cpp
 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.
+#### Static member functions <a id="allocator.traits.members">[[allocator.traits.members]]</a>
 ``` cpp
+[[nodiscard]] static constexpr pointer allocate(Alloc& a, size_type n);
 ```
 *Returns:* `a.allocate(n)`.
 ``` cpp
+[[nodiscard]] 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)`.
 ``` cpp
+static constexpr void deallocate(Alloc& a, pointer p, size_type n);
 ```
 *Effects:* Calls `a.deallocate(p, n)`.
 *Throws:* Nothing.
 ``` cpp
 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)...)`.
 ``` cpp
 template<class T>
+  static constexpr void destroy(Alloc& a, T* p);
 ```
 *Effects:* Calls `a.destroy(p)` if that call is well-formed; otherwise,
+invokes `destroy_at(p)`.
 ``` cpp
+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)`.
 ``` cpp
+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`.
 ### The default allocator <a id="default.allocator">[[default.allocator]]</a>
+All specializations of the default allocator meet the allocator
+completeness requirements [[allocator.requirements.completeness]].
 ``` cpp
 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;
+ constexpr ~allocator();
+    constexpr allocator& operator=(const allocator&) = default;
+ [[nodiscard]] constexpr T* allocate(size_t n);
+ constexpr void deallocate(T* p, size_t n);
   };
 }
 ```
+#### Members <a id="allocator.members">[[allocator.members]]</a>
 Except for the destructor, member functions of the default allocator
+shall not introduce data races [[intro.multithread]] 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.
 ``` cpp
+[[nodiscard]] constexpr T* allocate(size_t n);
 ```
+*Mandates:* `T` is not an incomplete type [[basic.types]].
+*Returns:* A pointer to the initial element of an array of `n` `T`.
+*Remarks:* The storage for the array is obtained by calling
+`::operator new` [[new.delete]], but it is unspecified when or how often
+this function is called. This function starts the lifetime of the array
+object, but not that of any of the array elements.
+*Throws:* `bad_array_new_length` if
+`numeric_limits<size_t>::max() / sizeof(T) < n`, or `bad_alloc` if the
+storage cannot be obtained.
 ``` cpp
+constexpr void deallocate(T* p, size_t n);
 ```
+*Preconditions:* `p` is a pointer value obtained from `allocate()`. `n`
+equals the value passed as the first argument to the invocation of
 allocate which returned `p`.
 *Effects:* Deallocates the storage referenced by `p` .
+*Remarks:* Uses `::operator delete` [[new.delete]], but it is
 unspecified when this function is called.
+#### Operators <a id="allocator.globals">[[allocator.globals]]</a>
 ``` cpp
 template<class T, class U>
+ constexpr bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
 ```
 *Returns:* `true`.
+### `addressof` <a id="specialized.addressof">[[specialized.addressof]]</a>
 ``` cpp
 template<class T> constexpr T* addressof(T& r) noexcept;
 ```
 *Returns:* The actual address of the object or function referenced by
 `r`, even in the presence of an overloaded `operator&`.
 *Remarks:* An expression `addressof(E)` is a constant
+subexpression [[defns.const.subexpr]] if `E` is an lvalue constant
 subexpression.
 ### C library memory allocation <a id="c.malloc">[[c.malloc]]</a>
+[*Note 1*: The header `<cstdlib>` declares the functions described in
+this subclause. — *end note*]
 ``` cpp
 void* aligned_alloc(size_t alignment, size_t size);
 void* calloc(size_t nmemb, size_t size);
 void* malloc(size_t size);
 *Effects:* These functions have the semantics specified in the C
 standard library.
 *Remarks:* These functions do not attempt to allocate storage by calling
+`::operator new()` [[new.delete]].
 Storage allocated directly with these functions is implicitly declared
 reachable (see  [[basic.stc.dynamic.safety]]) on allocation, ceases to
 be declared reachable on deallocation, and need not cease to be declared
 reachable as the result of an `undeclare_reachable()` call.
 intentionally be used as a replacement for `declare_reachable()`, and
 newly written code is strongly encouraged to treat memory allocated with
 these functions as though it were allocated with
 `operator new`. — *end note*]
+These functions implicitly create objects [[intro.object]] in the
+returned region of storage and return a pointer to a suitable created
+object. In the case of `calloc` and `realloc`, the objects are created
+before the storage is zeroed or copied, respectively.
 ``` cpp
 void free(void* ptr);
 ```
 *Effects:* This function has the semantics specified in the C standard
 library.
 *Remarks:* This function does not attempt to deallocate storage by
 calling `::operator delete()`.
+See also: ISO C 7.22.3

Diff to HTML by rtfpessoa