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

Files changed (1) hide show

tmp/tmpl58frcar/{from.md → to.md} +466 -386

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

@@ -1,19 +1,19 @@
 ## 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 C headers `<cstdlib>`
-and `<cstring>` ([[c.malloc]]).
 ### 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, 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
@@ -29,55 +29,106 @@ namespace std {
   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(std::size_t alignment, std::size_t size,
-    void*& ptr, std::size_t& space);
   // [allocator.tag], allocator argument tag
-  struct allocator_arg_t { };
-  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 allocator<void>;
   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;
-  // [storage.iterator], raw storage iterator:
-  template <class OutputIterator, class T> class raw_storage_iterator;
- // [temporary.buffer], temporary buffers:
-  template <class T>
-    pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept;
-  template <class T>
-    void return_temporary_buffer(T* p);
-  // [specialized.algorithms], specialized algorithms:
-  template <class T> T* addressof(T& r) noexcept;
   template <class InputIterator, class ForwardIterator>
     ForwardIterator uninitialized_copy(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 ForwardIterator, class T>
     void uninitialized_fill(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);
-  // [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>;
@@ -123,34 +174,35 @@ namespace std {
   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.weakptr], 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==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
   template<class T, class U>
-    bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
   template<class T, class U>
-    bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
   template<class T, class U>
-    bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
   template<class T, class U>
-    bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
   template<class T, class U>
-    bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& 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;
@@ -173,41 +225,43 @@ namespace std {
   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(shared_ptr<U> const& r) noexcept;
   template<class T, class U>
-    shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r) noexcept;
   template<class T, class U>
-    shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r) noexcept;
-  // [util.smartptr.getdeleter], shared_ptr get_deleter:
-  template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept;
-  // [util.smartptr.shared.io], shared_ptr I/O:
   template<class E, class T, class Y>
-    basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p);
-  // [util.smartptr.weak], class template weak_ptr:
   template<class T> class weak_ptr;
-  // [util.smartptr.weak.spec], weak_ptr specialized algorithms:
   template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
-  // [util.smartptr.ownerless], class template owner_less:
-  template<class T> class 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);
@@ -220,12 +274,11 @@ namespace std {
     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>
@@ -238,17 +291,18 @@ namespace std {
   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>>;
-  // [depr.auto.ptr], auto_ptr (deprecated)
-  template <class X> class auto_ptr;
 }
 ```
 ### Pointer traits <a id="pointer.traits">[[pointer.traits]]</a>
@@ -256,23 +310,23 @@ The class template `pointer_traits` supplies a uniform interface to
 certain attributes of pointer-like types.
 ``` cpp
 namespace std {
   template <class Ptr> struct pointer_traits {
- typedef Ptr       pointer;
- typedef see below element_type;
- typedef see below difference_type;
     template <class U> using rebind = see below;
     static pointer pointer_to(see below r);
   };
   template <class T> struct pointer_traits<T*> {
- typedef T*        pointer;
- typedef T         element_type;
- typedef ptrdiff_t difference_type;
     template <class U> using rebind = U*;
     static pointer pointer_to(see below r) noexcept;
   };
@@ -280,49 +334,53 @@ namespace std {
 ```
 #### Pointer traits member types <a id="pointer.traits.types">[[pointer.traits.types]]</a>
 ``` cpp
-typedef see below element_type;
 ```
-*Type:* `Ptr::element_type` if such a type exists; 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
-typedef see below difference_type;
 ```
-*Type:* `Ptr::difference_type` if such a type exists; otherwise,
-`std::ptrdiff_t`.
 ``` cpp
 template <class U> using rebind = see below;
 ```
-*Alias template:* `Ptr::rebind<U>` if such a type exists; 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;
 ```
-If `element_type` is (possibly cv-qualified) `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 `std::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
@@ -337,13 +395,12 @@ void declare_reachable(void* p);
 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 `std::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);
 ```
@@ -355,38 +412,43 @@ live ([[basic.life]]) from the time of the call until the last
 *Returns:* A safely derived copy of `p` which shall compare equal to
 `p`.
 *Throws:* Nothing.
-It is expected that calls to `declare_reachable(p)` will consume a small
-amount of memory in addition to that occupied by the referenced object
-until the matching call to `undeclare_reachable(p)` is encountered. Long
-running programs should arrange that calls are matched.
 ``` 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. 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.
 *Effects:* The `n` bytes starting at `p` no longer contain traceable
 pointer locations, independent of their type. Hence indirection through
 a pointer located there is undefined if the object it points to was
 created by global `operator new` and not previously declared reachable.
-This may be used to inform a garbage collector or leak detector that
-this region of memory need not be traced.
 *Throws:* Nothing.
-Under some conditions implementations may need to allocate memory.
-However, the request can be ignored if memory allocation fails.
 ``` cpp
 void undeclare_no_pointers(char* p, size_t n);
 ```
@@ -402,47 +464,46 @@ ends.
 ``` 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(std::size_t alignment, std::size_t size,
-    void*& ptr, std::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 point to 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 fundamental alignment value or an extended
-  alignment value supported by the implementation in this context
-- `ptr` shall point to 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`.
-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.
 ### Allocator argument tag <a id="allocator.tag">[[allocator.tag]]</a>
 ``` cpp
 namespace std {
-  struct allocator_arg_t { };
-  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,
@@ -457,74 +518,77 @@ argument of a type that satisfies the `Allocator` requirements (
 ``` cpp
 template <class T, class Alloc> struct uses_allocator;
 ```
-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 a type
-`T::allocator_type` exists and
-`is_convertible<Alloc, T::allocator_type>::value != 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<T, Alloc>::value` is `false` and
-  `is_constructible<T, V1, V2, ..., VN>::value` is `true`, then `obj` is
   initialized as `obj(v1, v2, ..., vN)`;
-- otherwise, if `uses_allocator<T, Alloc>::value` is `true` and
-  `is_constructible<T, allocator_arg_t, Alloc,`
-  `V1, V2, ..., VN>::value` is `true`, then `obj` is initialized as
-  `obj(allocator_arg, alloc, v1,
   v2, ..., vN)`;
-- otherwise, if `uses_allocator<T, Alloc>::value` is `true` and
-  `is_constructible<T, V1, V2, ..., VN, Alloc>::value` is `true`, then
- `obj` is initialized as `obj(v1, v2, ..., vN, alloc)`;
 - otherwise, the request for uses-allocator construction is ill-formed.
-  An error will result if `uses_allocator<T, Alloc>::value` is `true`
-  but the specific constructor does not take an allocator. This
   definition prevents a silent failure to pass the allocator to an
-  element.
 ### 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,
-even if `allocator_traits` supplies the entire required interface. Thus,
-it is always possible to create a derived class from an allocator.
 ``` cpp
 namespace std {
   template <class Alloc> struct allocator_traits {
- typedef Alloc allocator_type;
- typedef typename Alloc::value_type value_type;
- typedef see below pointer;
- typedef see below const_pointer;
- typedef see below void_pointer;
- typedef see below const_void_pointer;
- typedef see below difference_type;
- typedef see below size_type;
- typedef see below propagate_on_container_copy_assignment;
- typedef see below propagate_on_container_move_assignment;
- typedef see below propagate_on_container_swap;
     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);
@@ -546,80 +610,99 @@ namespace std {
 ```
 #### Allocator traits member types <a id="allocator.traits.types">[[allocator.traits.types]]</a>
 ``` cpp
-typedef see below pointer;
 ```
-*Type:* `Alloc::pointer` if such a type exists; otherwise,
-`value_type*`.
 ``` cpp
-typedef see below const_pointer;
 ```
-*Type:* `Alloc::const_pointer` if such a type exists; otherwise,
-`pointer_traits<pointer>::rebind<const value_type>`.
 ``` cpp
-typedef see below void_pointer;
 ```
-*Type:* `Alloc::void_pointer` if such a type exists; otherwise,
-`pointer_traits<pointer>::rebind<void>`.
 ``` cpp
-typedef see below const_void_pointer;
 ```
-*Type:* `Alloc::const_void_pointer` if such a type exists; otherwise,
 `pointer_traits<pointer>::rebind<const void>`.
 ``` cpp
-typedef see below difference_type;
 ```
-*Type:* `Alloc::difference_type` if such a type exists; otherwise,
-`pointer_traits<pointer>::difference_type`.
 ``` cpp
-typedef see below size_type;
 ```
-*Type:* `Alloc::size_type` if such a type exists; otherwise,
 `make_unsigned_t<difference_type>`.
 ``` cpp
-typedef see below propagate_on_container_copy_assignment;
 ```
-*Type:* `Alloc::propagate_on_container_copy_assignment` if such a type
-exists, otherwise `false_type`.
 ``` cpp
-typedef see below propagate_on_container_move_assignment;
 ```
-*Type:* `Alloc::propagate_on_container_move_assignment` if such a type
-exists, otherwise `false_type`.
 ``` cpp
-typedef see below propagate_on_container_swap;
 ```
-*Type:* `Alloc::propagate_on_container_swap` if such a type exists,
-otherwise `false_type`.
 ``` cpp
 template <class T> using rebind_alloc = see below;
 ```
-*Alias template:* `Alloc::rebind<T>::other` if such a type exists;
-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);
@@ -636,90 +719,65 @@ 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()`.
 ``` 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>
 ``` cpp
 namespace std {
-  template <class T> class allocator;
-  // specialize for void:
-  template <> class allocator<void> {
-  public:
-    typedef void*   pointer;
-    typedef const void* const_pointer;
-    // reference-to-void members are impossible.
-    typedef void  value_type;
-    template <class U> struct rebind { typedef allocator<U> other; };
-  };
   template <class T> class allocator {
    public:
- typedef size_t    size_type;
- typedef ptrdiff_t difference_type;
- typedef T*        pointer;
-    typedef const T*  const_pointer;
-    typedef T&        reference;
-    typedef const T&  const_reference;
-    typedef T         value_type;
-    template <class U> struct rebind { typedef allocator<U> other; };
-    typedef true_type propagate_on_container_move_assignment;
     allocator() noexcept;
     allocator(const allocator&) noexcept;
     template <class U> allocator(const allocator<U>&) noexcept;
     ~allocator();
- pointer address(reference x) const noexcept;
- const_pointer address(const_reference x) const noexcept;
-    pointer allocate(
-      size_type, allocator<void>::const_pointer hint = 0);
-    void deallocate(pointer p, size_type n);
-    size_type max_size() const noexcept;
-    template<class U, class... Args>
-      void construct(U* p, Args&&... args);
-    template <class U>
-      void destroy(U* p);
   };
 }
 ```
 #### `allocator` members <a id="allocator.members">[[allocator.members]]</a>
@@ -730,300 +788,322 @@ 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
-pointer address(reference x) const noexcept;
 ```
-*Returns:* The actual address of the object referenced by `x`, even in
-the presence of an overloaded operator&.
-``` cpp
-const_pointer address(const_reference x) const noexcept;
-```
-*Returns:* The actual address of the object referenced by `x`, even in
-the presence of an overloaded operator&.
-``` cpp
-pointer allocate(size_type n, allocator<void>::const_pointer hint = 0);
-```
-In a container member function, the address of an adjacent element is
-often a good choice to pass for the `hint` argument.
 *Returns:* A pointer to the initial element of an array of storage of
 size `n` `* sizeof(T)`, aligned appropriately for objects of type `T`.
-It is *implementation-defined* whether over-aligned types are
-supported ([[basic.align]]).
-the storage is obtained by calling
-`::operator new(std::size_t)` ([[new.delete]]), but it is unspecified
-when or how often this function is called. The use of `hint` is
-unspecified, but intended as an aid to locality if an implementation so
-desires.
 *Throws:* `bad_alloc` if the storage cannot be obtained.
 ``` cpp
-void deallocate(pointer p, size_type 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(void*, std::size_t)` ([[new.delete]]), but it is
 unspecified when this function is called.
-``` cpp
-size_type max_size() const noexcept;
-```
-*Returns:* The largest value *N* for which the call `allocate(N,0)`
-might succeed.
-``` cpp
-template <class U, class... Args>
-  void construct(U* p, Args&&... args);
-```
-*Effects:* `::new((void *)p) U(std::forward<Args>(args)...)`
-``` cpp
-template <class U>
-  void destroy(U* p);
-```
-*Effects:* `p->~U()`
 #### `allocator` globals <a id="allocator.globals">[[allocator.globals]]</a>
 ``` cpp
-template <class T1, class T2>
-  bool operator==(const allocator<T1>&, const allocator<T2>&) noexcept;
 ```
 *Returns:* `true`.
 ``` cpp
-template <class T1, class T2>
-  bool operator!=(const allocator<T1>&, const allocator<T2>&) noexcept;
 ```
 *Returns:* `false`.
-### Raw storage iterator <a id="storage.iterator">[[storage.iterator]]</a>
-`raw_storage_iterator` is provided to enable algorithms to store their
-results into uninitialized memory. The template parameter
-`OutputIterator` is required to have its `operator*` return an object
-for which `operator&` is defined and returns a pointer to `T`, and is
-also required to satisfy the requirements of an output iterator (
-[[output.iterators]]).
-``` cpp
-namespace std {
-  template <class OutputIterator, class T>
-  class raw_storage_iterator
-    : public iterator<output_iterator_tag,void,void,void,void> {
-  public:
-    explicit raw_storage_iterator(OutputIterator x);
-    raw_storage_iterator& operator*();
-    raw_storage_iterator& operator=(const T& element);
-    raw_storage_iterator& operator++();
-    raw_storage_iterator  operator++(int);
-  };
-}
-```
-``` cpp
-explicit raw_storage_iterator(OutputIterator x);
-```
-*Effects:* Initializes the iterator to point to the same value to which
-`x` points.
-``` cpp
-raw_storage_iterator& operator*();
-```
-*Returns:* `*this`
-``` cpp
-raw_storage_iterator& operator=(const T& element);
-```
-*Effects:* Constructs a value from `element` at the location to which
-the iterator points.
-*Returns:* A reference to the iterator.
-``` cpp
-raw_storage_iterator& operator++();
-```
-*Effects:* Pre-increment: advances the iterator and returns a reference
-to the updated iterator.
-``` cpp
-raw_storage_iterator operator++(int);
-```
-*Effects:* Post-increment: advances the iterator and returns the old
-value of the iterator.
-### Temporary buffers <a id="temporary.buffer">[[temporary.buffer]]</a>
-``` cpp
-template <class T>
-  pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept;
-```
-*Effects:* Obtains a pointer to storage sufficient to store up to `n`
-adjacent `T` objects. It is *implementation-defined* whether
-over-aligned types are supported ([[basic.align]]).
-*Returns:* A `pair` containing the buffer’s address and capacity (in the
-units of `sizeof(T)`), or a pair of 0 values if no storage can be
-obtained or if `n <= 0`.
-``` cpp
-template <class T> void return_temporary_buffer(T* p);
-```
-*Effects:* Deallocates the buffer to which `p` points.
-*Requires:* The buffer shall have been previously allocated by
-`get_temporary_buffer`.
 ### Specialized algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
-All the iterators that are used as template parameters in the following
-algorithms are required to have their `operator*` return an object for
-which `operator&` is defined and returns a pointer to `T`. In the
-algorithm `uninitialized_copy`, the template parameter `InputIterator`
-is required to satisfy the requirements of an input iterator (
-[[input.iterators]]). In all of the following algorithms, the template
-parameter `ForwardIterator` is required to 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. In the following
-algorithms, if an exception is thrown there are no effects.
 #### `addressof` <a id="specialized.addressof">[[specialized.addressof]]</a>
 ``` cpp
-template <class T> 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&`.
 #### `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:*
 ``` cpp
-for (; first != last; ++result, ++first)
-  ::new (static_cast<void*>(&*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:*
 ``` cpp
-for ( ; n > 0; ++result, ++first, --n) {
-  ::new (static_cast<void*>(&*result))
     typename iterator_traits<ForwardIterator>::value_type(*first);
 }
 ```
-*Returns:* `result`
 #### `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:*
 ``` cpp
 for (; first != last; ++first)
-  ::new (static_cast<void*>(&*first))
     typename iterator_traits<ForwardIterator>::value_type(x);
 ```
-#### `uninitialized_fill_n` <a id="uninitialized.fill.n">[[uninitialized.fill.n]]</a>
 ``` cpp
 template <class ForwardIterator, class Size, class T>
   ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
 ```
-*Effects:*
 ``` cpp
 for (; n--; ++first)
-  ::new (static_cast<void*>(&*first))
     typename iterator_traits<ForwardIterator>::value_type(x);
 return first;
 ```
-### C library <a id="c.malloc">[[c.malloc]]</a>
-Table  [[tab:util.hdr.cstdlib]] describes the header `<cstdlib>`.
-The contents are the same as the Standard C library header `<stdlib.h>,`
-with the following changes:
-The functions `calloc()`, `malloc()`, and `realloc()` do not attempt to
-allocate storage by calling `::operator new()` ([[support.dynamic]]).
-The function `free()` does not attempt to deallocate storage by calling
-`::operator delete()`.
-ISO C Clause 7.11.2.
-Storage allocated directly with `malloc()`, `calloc()`, or `realloc()`
-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. This allows existing C libraries to remain
-unaffected by restrictions on pointers that are not safely derived, at
-the expense of providing far fewer garbage collection and leak detection
-options for `malloc()`-allocated objects. It also allows `malloc()` to
-be implemented with a separate allocation arena, bypassing the normal
 `declare_reachable()` implementation. The above functions should never
 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`.
-Table  [[tab:util.hdr.cstring]] describes the header `<cstring>`.
-The contents are the same as the Standard C library header `<string.h>`,
-with the change to `memchr()` specified in  [[c.strings]].
-ISO C Clause 7.11.2.

 ## 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
   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 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;
+  // [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;
+  // [util.smartptr.shared.io], shared_ptr I/O
   template<class E, class T, class Y>
+    basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, const shared_ptr<Y>& p);
+  // [util.smartptr.weak], class template weak_ptr
   template<class T> class weak_ptr;
+  // [util.smartptr.weak.spec], weak_ptr specialized algorithms
   template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
+  // [util.smartptr.ownerless], class template owner_less
+  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);
     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>
   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>
 certain attributes of pointer-like types.
 ``` cpp
 namespace std {
   template <class Ptr> struct pointer_traits {
+ using pointer         = Ptr;
+ using element_type    = see below;
+ using difference_type = see below;
     template <class U> using rebind = see below;
     static pointer pointer_to(see below r);
   };
   template <class T> struct pointer_traits<T*> {
+ using pointer         = T*;
+ 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
 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);
 ```
 *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
+referenced object until the matching call to `undeclare_reachable(p)` is
+encountered. Long running programs should arrange that calls are
+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*]
 *Effects:* The `n` bytes starting at `p` no longer contain traceable
 pointer locations, independent of their type. Hence indirection through
 a pointer located there is undefined if the object it points to was
 created by global `operator new` and not previously declared reachable.
+[*Note 3*: This may be used to inform a garbage collector or leak
+detector that this region of memory need not be traced. — *end note*]
 *Throws:* Nothing.
+[*Note 4*: Under some conditions implementations may need to allocate
+memory. However, the request can be ignored if memory allocation
+fails. — *end note*]
 ``` cpp
 void undeclare_no_pointers(char* p, size_t n);
 ```
 ``` 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,
 ``` cpp
 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,
+even if `allocator_traits` supplies the entire required interface.
+[*Note 1*: Thus, it is always possible to create a derived class from
+an allocator. — *end note*]
 ``` cpp
 namespace std {
   template <class Alloc> struct allocator_traits {
+ using allocator_type     = Alloc;
+ using value_type         = typename Alloc::value_type;
+ using pointer            = see below;
+ using const_pointer      = see below;
+ using void_pointer       = see below;
+ using const_void_pointer = see below;
+ using difference_type    = see below;
+ using size_type          = see below;
+ using propagate_on_container_copy_assignment = see below;
+ using propagate_on_container_move_assignment = see below;
+ using propagate_on_container_swap            = see below;
+    using is_always_equal                        = see below;
     template <class T> using rebind_alloc = see below;
     template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
     static pointer allocate(Alloc& a, size_type n);
 ```
 #### 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);
 ``` 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>
 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);
+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.
+[*Note 1*: This allows existing C libraries to remain unaffected by
+restrictions on pointers that are not safely derived, at the expense of
+providing far fewer garbage collection and leak detection options for
+`malloc()`-allocated objects. It also allows `malloc()` to be
+implemented with a separate allocation arena, bypassing the normal
 `declare_reachable()` implementation. The above functions should never
 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.

Diff to HTML by rtfpessoa