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

Files changed (1) hide show

tmp/tmplc3wn656/{from.md → to.md} +728 -757

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

@@ -4,105 +4,35 @@
 A *unique pointer* is an object that owns another object and manages
 that other object through a pointer. More precisely, a unique pointer is
 an object *u* that stores a pointer to a second object *p* and will
 dispose of *p* when *u* is itself destroyed (e.g., when leaving block
-scope ([[stmt.dcl]])). In this context, *u* is said to *own* `p`.
 The mechanism by which *u* disposes of *p* is known as *p*’s associated
 *deleter*, a function object whose correct invocation results in *p*’s
 appropriate disposition (typically its deletion).
 Let the notation *u.p* denote the pointer stored by *u*, and let *u.d*
 denote the associated deleter. Upon request, *u* can *reset* (replace)
-*u.p* and *u.d* with another pointer and deleter, but must properly
-dispose of its owned object via the associated deleter before such
-replacement is considered completed.
-Additionally, *u* can, upon request, *transfer ownership* to another
-unique pointer *u2*. Upon completion of such a transfer, the following
-postconditions hold:
-- *u2.p* is equal to the pre-transfer *u.p*,
-- *u.p* is equal to `nullptr`, and
-- if the pre-transfer *u.d* maintained state, such state has been
-  transferred to *u2.d*.
-As in the case of a reset, *u2* must properly dispose of its
-pre-transfer owned object via the pre-transfer associated deleter before
-the ownership transfer is considered complete.
-[*Note 1*: A deleter’s state need never be copied, only moved or
-swapped as ownership is transferred. — *end note*]
 Each object of a type `U` instantiated from the `unique_ptr` template
 specified in this subclause has the strict ownership semantics,
 specified above, of a unique pointer. In partial satisfaction of these
-semantics, each such `U` is `MoveConstructible` and `MoveAssignable`,
-but is not `CopyConstructible` nor `CopyAssignable`. The template
-parameter `T` of `unique_ptr` may be an incomplete type.
-[*Note 2*: The uses of `unique_ptr` include providing exception safety
 for dynamically allocated memory, passing ownership of dynamically
 allocated memory to a function, and returning dynamically allocated
 memory from a function. — *end note*]
-``` cpp
-namespace std {
-  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);
-}
-```
 #### Default deleters <a id="unique.ptr.dltr">[[unique.ptr.dltr]]</a>
 ##### In general <a id="unique.ptr.dltr.general">[[unique.ptr.dltr.general]]</a>
 The class template `default_delete` serves as the default deleter
@@ -125,24 +55,23 @@ namespace std {
 ``` cpp
 template<class U> default_delete(const default_delete<U>& other) noexcept;
 ```
 *Effects:* Constructs a `default_delete` object from another
 `default_delete<U>` object.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `U*` is implicitly convertible to `T*`.
 ``` cpp
 void operator()(T* ptr) const;
 ```
 *Effects:* Calls `delete` on `ptr`.
-*Remarks:* If `T` is an incomplete type, the program is ill-formed.
 ##### `default_delete<T[]>` <a id="unique.ptr.dltr.dflt1">[[unique.ptr.dltr.dflt1]]</a>
 ``` cpp
 namespace std {
   template<class T> struct default_delete<T[]> {
@@ -155,26 +84,25 @@ namespace std {
 ``` cpp
 template<class U> default_delete(const default_delete<U[]>& other) noexcept;
 ```
-*Effects:* constructs a `default_delete` object from another
 `default_delete<U[]>` object.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `U(*)[]` is convertible to `T(*)[]`.
 ``` cpp
 template<class U> void operator()(U* ptr) const;
 ```
 *Effects:* Calls `delete[]` on `ptr`.
-*Remarks:* If `U` is an incomplete type, the program is ill-formed. This
-function shall not participate in overload resolution unless `U(*)[]` is
-convertible to `T(*)[]`.
 #### `unique_ptr` for single objects <a id="unique.ptr.single">[[unique.ptr.single]]</a>
 ``` cpp
 namespace std {
   template<class T, class D = default_delete<T>> class unique_ptr {
@@ -196,11 +124,12 @@ namespace std {
     // [unique.ptr.single.dtor], destructor
     ~unique_ptr();
     // [unique.ptr.single.asgn], assignment
     unique_ptr& operator=(unique_ptr&& u) noexcept;
-    template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
     unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.single.observers], observers
     add_lvalue_reference_t<T> operator*() const;
     pointer operator->() const noexcept;
@@ -220,126 +149,107 @@ namespace std {
   };
 }
 ```
 The default type for the template parameter `D` is `default_delete`. A
-client-supplied template argument `D` shall be a function object type (
-[[function.objects]]), lvalue reference to function, or lvalue reference
 to function object type for which, given a value `d` of type `D` and a
 value `ptr` of type `unique_ptr<T, D>::pointer`, the expression `d(ptr)`
 is valid and has the effect of disposing of the pointer as appropriate
 for that deleter.
-If the deleter’s type `D` is not a reference type, `D` shall satisfy the
-requirements of `Destructible` (Table  [[tab:destructible]]).
 If the *qualified-id* `remove_reference_t<D>::pointer` is valid and
-denotes a type ([[temp.deduct]]), then `unique_ptr<T,
 D>::pointer` shall be a synonym for `remove_reference_t<D>::pointer`.
 Otherwise `unique_ptr<T, D>::pointer` shall be a synonym for
 `element_type*`. The type `unique_ptr<T,
-D>::pointer` shall satisfy the requirements of `NullablePointer` (
-[[nullablepointer.requirements]]).
-[*Example 1*: Given an allocator type `X` ([[allocator.requirements]])
-and letting `A` be a synonym for `allocator_traits<X>`, the types
 `A::pointer`, `A::const_pointer`, `A::void_pointer`, and
 `A::const_void_pointer` may be used as
 `unique_ptr<T, D>::pointer`. — *end example*]
-##### `unique_ptr` constructors <a id="unique.ptr.single.ctor">[[unique.ptr.single.ctor]]</a>
 ``` cpp
 constexpr unique_ptr() noexcept;
 constexpr unique_ptr(nullptr_t) noexcept;
 ```
-*Requires:* `D` shall satisfy the requirements of `DefaultConstructible`
-(Table  [[tab:defaultconstructible]]), and that construction shall not
-throw an exception.
 *Effects:* Constructs a `unique_ptr` object that owns nothing,
 value-initializing the stored pointer and the stored deleter.
-*Postconditions:* `get() == nullptr`. `get_deleter()` returns a
-reference to the stored deleter.
-*Remarks:* If `is_pointer_v<deleter_type>` is `true` or
-`is_default_constructible_v<deleter_type>` is `false`, this constructor
-shall not participate in overload resolution.
 ``` cpp
 explicit unique_ptr(pointer p) noexcept;
 ```
-*Requires:* `D` shall satisfy the requirements of `DefaultConstructible`
-(Table  [[tab:defaultconstructible]]), and that construction shall not
-throw an exception.
 *Effects:* Constructs a `unique_ptr` which owns `p`, initializing the
 stored pointer with `p` and value-initializing the stored deleter.
-*Postconditions:* `get() == p`. `get_deleter()` returns a reference to
-the stored deleter.
-*Remarks:* If `is_pointer_v<deleter_type>` is `true` or
-`is_default_constructible_v<deleter_type>` is `false`, this constructor
-shall not participate in overload resolution. If class template argument
-deduction ([[over.match.class.deduct]]) would select the function
-template corresponding to this constructor, then the program is
-ill-formed.
-``` cpp
-unique_ptr(pointer p, see below d1) noexcept;
-unique_ptr(pointer p, see below d2) noexcept;
-```
-The signature of these constructors depends upon whether `D` is a
-reference type. If `D` is a non-reference type `A`, then the signatures
-are:
 ``` cpp
-unique_ptr(pointer p, const A& d) noexcept;
-unique_ptr(pointer p, A&& d) noexcept;
 ```
-If `D` is an lvalue reference type `A&`, then the signatures are:
-``` cpp
-unique_ptr(pointer p, A& d) noexcept;
-unique_ptr(pointer p, A&& d) = delete;
-```
-If `D` is an lvalue reference type `const A&`, then the signatures are:
-``` cpp
-unique_ptr(pointer p, const A& d) noexcept;
-unique_ptr(pointer p, const A&& d) = delete;
-```
 *Effects:* Constructs a `unique_ptr` object which owns `p`, initializing
 the stored pointer with `p` and initializing the deleter from
 `std::forward<decltype(d)>(d)`.
-*Remarks:* These constructors shall not participate in overload
-resolution unless `is_constructible_v<D, decltype(d)>` is `true`.
-*Postconditions:* `get() == p`. `get_deleter()` returns a reference to
-the stored deleter. If `D` is a reference type then `get_deleter()`
-returns a reference to the lvalue `d`.
-*Remarks:* If class template argument
-deduction ([[over.match.class.deduct]]) would select a function
-template corresponding to either of these constructors, then the program
-is ill-formed.
 [*Example 1*:
 ``` cpp
 D d;
-unique_ptr<int, D> p1(new int, D());        // D must be MoveConstructible
-unique_ptr<int, D> p2(new int, d);          // D must be CopyConstructible
 unique_ptr<int, D&> p3(new int, d);         // p3 holds a reference to d
 unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object combined
                                             // with reference deleter type
 ```
@@ -347,142 +257,144 @@ unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object comb
 ``` cpp
 unique_ptr(unique_ptr&& u) noexcept;
 ```
-*Requires:* If `D` is not a reference type, `D` shall satisfy the
-requirements of `MoveConstructible` (Table  [[tab:moveconstructible]]).
-Construction of the deleter from an rvalue of type `D` shall not throw
-an exception.
-*Effects:* Constructs a `unique_ptr` by transferring ownership from `u`
-to `*this`. If `D` is a reference type, this deleter is copy constructed
-from `u`’s deleter; otherwise, this deleter is move constructed from
-`u`’s deleter.
-[*Note 1*: The deleter constructor can be implemented with
 `std::forward<D>`. — *end note*]
-*Postconditions:* `get()` yields the value `u.get()` yielded before the
-construction. `get_deleter()` returns a reference to the stored deleter
-that was constructed from `u.get_deleter()`. If `D` is a reference type
-then `get_deleter()` and `u.get_deleter()` both reference the same
-lvalue deleter.
 ``` cpp
 template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
-*Requires:* If `E` is not a reference type, construction of the deleter
-from an rvalue of type `E` shall be well formed and shall not throw an
 exception. Otherwise, `E` is a reference type and construction of the
-deleter from an lvalue of type `E` shall be well formed and shall not
-throw an exception.
-*Remarks:* This constructor shall not participate in overload resolution
-unless:
-- `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
-- `U` is not an array type, and
-- either `D` is a reference type and `E` is the same type as `D`, or `D`
-  is not a reference type and `E` is implicitly convertible to `D`.
-*Effects:* Constructs a `unique_ptr` by transferring ownership from `u`
-to `*this`. If `E` is a reference type, this deleter is copy constructed
-from `u`’s deleter; otherwise, this deleter is move constructed from
-`u`’s deleter.
 [*Note 2*: The deleter constructor can be implemented with
 `std::forward<E>`. — *end note*]
-*Postconditions:* `get()` yields the value `u.get()` yielded before the
-construction. `get_deleter()` returns a reference to the stored deleter
-that was constructed from `u.get_deleter()`.
-##### `unique_ptr` destructor <a id="unique.ptr.single.dtor">[[unique.ptr.single.dtor]]</a>
 ``` cpp
 ~unique_ptr();
 ```
-*Requires:* The expression `get_deleter()(get())` shall be well formed,
-shall have well-defined behavior, and shall not throw exceptions.
 [*Note 3*: The use of `default_delete` requires `T` to be a complete
 type. — *end note*]
 *Effects:* If `get() == nullptr` there are no effects. Otherwise
 `get_deleter()(get())`.
-##### `unique_ptr` assignment <a id="unique.ptr.single.asgn">[[unique.ptr.single.asgn]]</a>
 ``` cpp
 unique_ptr& operator=(unique_ptr&& u) noexcept;
 ```
-*Requires:* If `D` is not a reference type, `D` shall satisfy the
-requirements of `MoveAssignable` (Table  [[tab:moveassignable]]) and
-assignment of the deleter from an rvalue of type `D` shall not throw an
 exception. Otherwise, `D` is a reference type; `remove_reference_t<D>`
-shall satisfy the `CopyAssignable` requirements and assignment of the
-deleter from an lvalue of type `D` shall not throw an exception.
-*Effects:* Transfers ownership from `u` to `*this` as if by calling
-`reset(u.release())` followed by
 `get_deleter() = std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 template<class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 ```
-*Requires:* If `E` is not a reference type, assignment of the deleter
-from an rvalue of type `E` shall be well-formed and shall not throw an
-exception. Otherwise, `E` is a reference type and assignment of the
-deleter from an lvalue of type `E` shall be well-formed and shall not
-throw an exception.
-*Remarks:* This operator shall not participate in overload resolution
-unless:
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
   and
 - `U` is not an array type, and
 - `is_assignable_v<D&, E&&>` is `true`.
-*Effects:* Transfers ownership from `u` to `*this` as if by calling
-`reset(u.release())` followed by
 `get_deleter() = std::forward<E>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 ```
 *Effects:* As if by `reset()`.
-*Postconditions:* `get() == nullptr`.
 *Returns:* `*this`.
-##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
 add_lvalue_reference_t<T> operator*() const;
 ```
-*Requires:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
 pointer operator->() const noexcept;
 ```
-*Requires:* `get() != nullptr`.
 *Returns:* `get()`.
 [*Note 4*: The use of this function typically requires that `T` be a
 complete type. — *end note*]
@@ -504,47 +416,46 @@ const deleter_type& get_deleter() const noexcept;
 explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
-##### `unique_ptr` modifiers <a id="unique.ptr.single.modifiers">[[unique.ptr.single.modifiers]]</a>
 ``` cpp
 pointer release() noexcept;
 ```
-*Postconditions:* `get() == nullptr`.
 *Returns:* The value `get()` had at the start of the call to `release`.
 ``` cpp
 void reset(pointer p = pointer()) noexcept;
 ```
-*Requires:* The expression `get_deleter()(get())` shall be well formed,
-shall have well-defined behavior, and shall not throw exceptions.
 *Effects:* Assigns `p` to the stored pointer, and then if and only if
 the old value of the stored pointer, `old_p`, was not equal to
 `nullptr`, calls `get_deleter()(old_p)`.
 [*Note 5*: The order of these operations is significant because the
 call to `get_deleter()` may destroy `*this`. — *end note*]
-*Postconditions:* `get() == p`.
 [*Note 6*: The postcondition does not hold if the call to
 `get_deleter()` destroys `*this` since `this->get()` is no longer a
 valid expression. — *end note*]
 ``` cpp
 void swap(unique_ptr& u) noexcept;
 ```
-*Requires:* `get_deleter()` shall be
-swappable ([[swappable.requirements]]) and shall not throw an exception
-under `swap`.
 *Effects:* Invokes `swap` on the stored pointers and on the stored
 deleters of `*this` and `u`.
 #### `unique_ptr` for array objects with a runtime length <a id="unique.ptr.runtime">[[unique.ptr.runtime]]</a>
@@ -612,19 +523,20 @@ interface.
 Descriptions are provided below only for members that differ from the
 primary template.
 The template argument `T` shall be a complete type.
-##### `unique_ptr` constructors <a id="unique.ptr.runtime.ctor">[[unique.ptr.runtime.ctor]]</a>
 ``` cpp
 template<class U> explicit unique_ptr(U p) noexcept;
 ```
 This constructor behaves the same as the constructor in the primary
-template that takes a single parameter of type `pointer` except that it
-additionally shall not participate in overload resolution unless
 - `U` is the same type as `pointer`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
@@ -632,70 +544,68 @@ additionally shall not participate in overload resolution unless
 template<class U> unique_ptr(U p, see below d) noexcept;
 template<class U> unique_ptr(U p, see below d) noexcept;
 ```
 These constructors behave the same as the constructors in the primary
-template that take a parameter of type `pointer` and a second parameter
-except that they shall not participate in overload resolution unless
-either
 - `U` is the same type as `pointer`,
 - `U` is `nullptr_t`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 ``` cpp
-template <class U, class E>
-  unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
-This constructor behaves the same as in the primary template, except
-that it shall not participate in overload resolution unless all of the
-following conditions hold, where `UP` is `unique_ptr<U, E>`:
 - `U` is an array type, and
 - `pointer` is the same type as `element_type*`, and
 - `UP::pointer` is the same type as `UP::element_type*`, and
 - `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
 - either `D` is a reference type and `E` is the same type as `D`, or `D`
   is not a reference type and `E` is implicitly convertible to `D`.
-[*Note 1*: This replaces the overload-resolution specification of the
-primary template — *end note*]
-##### `unique_ptr` assignment <a id="unique.ptr.runtime.asgn">[[unique.ptr.runtime.asgn]]</a>
 ``` cpp
-template <class U, class E>
-  unique_ptr& operator=(unique_ptr<U, E>&& u)noexcept;
 ```
-This operator behaves the same as in the primary template, except that
-it shall not participate in overload resolution unless all of the
-following conditions hold, where `UP` is `unique_ptr<U, E>`:
 - `U` is an array type, and
 - `pointer` is the same type as `element_type*`, and
 - `UP::pointer` is the same type as `UP::element_type*`, and
 - `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
 - `is_assignable_v<D&, E&&>` is `true`.
-[*Note 2*: This replaces the overload-resolution specification of the
-primary template — *end note*]
-##### `unique_ptr` observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
 T& operator[](size_t i) const;
 ```
-*Requires:* `i <` the number of elements in the array to which the
 stored pointer points.
 *Returns:* `get()[i]`.
-##### `unique_ptr` modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
 void reset(nullptr_t p = nullptr) noexcept;
 ```
@@ -704,145 +614,165 @@ void reset(nullptr_t p = nullptr) noexcept;
 ``` cpp
 template<class U> void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
-template, except that it shall not participate in overload resolution
-unless either
 - `U` is the same type as `pointer`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
-#### `unique_ptr` creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
 template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `T` is not an array.
 *Returns:* `unique_ptr<T>(new T(std::forward<Args>(args)...))`.
 ``` cpp
 template<class T> unique_ptr<T> make_unique(size_t n);
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `T` is an array of unknown bound.
 *Returns:* `unique_ptr<T>(new remove_extent_t<T>[n]())`.
 ``` cpp
 template<class T, class... Args> unspecified make_unique(Args&&...) = delete;
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `T` is an array of known bound.
-#### `unique_ptr` specialized algorithms <a id="unique.ptr.special">[[unique.ptr.special]]</a>
 ``` cpp
 template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_swappable_v<D>` is `true`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `x.get() == y.get()`.
-``` cpp
-template <class T1, class D1, class T2, class D2>
-  bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-```
-*Returns:* `x.get() != y.get()`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
-*Requires:* Let *`CT`* denote
 ``` cpp
 common_type_t<typename unique_ptr<T1, D1>::pointer,
               typename unique_ptr<T2, D2>::pointer>
 ```
-Then the specialization `less<`*`CT`*`>` shall be a function object
-type ([[function.objects]]) that induces a strict weak
-ordering ([[alg.sorting]]) on the pointer values.
-*Returns:* `less<`*`CT`*`>()(x.get(), y.get())`.
-*Remarks:* If `unique_ptr<T1, D1>::pointer` is not implicitly
-convertible to *`CT`* or `unique_ptr<T2, D2>::pointer` is not implicitly
-convertible to *`CT`*, the program is ill-formed.
-``` cpp
-template <class T1, class D1, class T2, class D2>
-  bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
-```
-*Returns:* `!(y < x)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `y < x`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `!(x < y)`.
 ``` cpp
 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>& x) noexcept;
 ```
 *Returns:* `!x`.
-``` cpp
-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>& x) noexcept;
-```
-*Returns:* `(bool)x`.
 ``` cpp
 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>& x);
 ```
-*Requires:* The specialization `less<unique_ptr<T, D>::pointer>` shall
-be a function object type ([[function.objects]]) that induces a strict
-weak ordering ([[alg.sorting]]) on the pointer values.
 *Returns:* The first function template returns
-`less<unique_ptr<T, D>::pointer>()(x.get(),`
-`nullptr)`. The second function template returns
-`less<unique_ptr<T, D>::pointer>()(nullptr, x.get())`.
 ``` cpp
 template<class T, class D>
   bool operator>(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
@@ -870,33 +800,54 @@ template <class T, class D>
 ```
 *Returns:* The first function template returns `!(x < nullptr)`. The
 second function template returns `!(nullptr < x)`.
-### Shared-ownership pointers <a id="util.smartptr">[[util.smartptr]]</a>
-#### Class `bad_weak_ptr` <a id="util.smartptr.weak.bad">[[util.smartptr.weak.bad]]</a>
 ``` cpp
 namespace std {
   class bad_weak_ptr : public exception {
   public:
- bad_weak_ptr() noexcept;
   };
 }
 ```
 An exception of type `bad_weak_ptr` is thrown by the `shared_ptr`
 constructor taking a `weak_ptr`.
 ``` cpp
-bad_weak_ptr() noexcept;
 ```
-*Postconditions:* `what()` returns an *implementation-defined* NTBS.
-#### Class template `shared_ptr` <a id="util.smartptr.shared">[[util.smartptr.shared]]</a>
 The `shared_ptr` class template stores a pointer, usually obtained via
 `new`. `shared_ptr` implements semantics of shared ownership; the last
 remaining owner of the pointer is responsible for destroying the object,
 or otherwise releasing the resources associated with the stored pointer.
@@ -909,130 +860,88 @@ namespace std {
     using element_type = remove_extent_t<T>;
     using weak_type    = weak_ptr<T>;
     // [util.smartptr.shared.const], constructors
     constexpr shared_ptr() noexcept;
-    template<class Y> explicit shared_ptr(Y* p);
-    template<class Y, class D> shared_ptr(Y* p, D d);
-    template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
-    template <class D> shared_ptr(nullptr_t p, D d);
-    template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
-    template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
-    shared_ptr(const shared_ptr& r) noexcept;
-    template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
-    shared_ptr(shared_ptr&& r) noexcept;
-    template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
-    template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
-    template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
     constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
     // [util.smartptr.shared.dest], destructor
     ~shared_ptr();
     // [util.smartptr.shared.assign], assignment
     shared_ptr& operator=(const shared_ptr& r) noexcept;
-    template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
     shared_ptr& operator=(shared_ptr&& r) noexcept;
-    template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
-    template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.mod], modifiers
     void swap(shared_ptr& r) noexcept;
     void reset() noexcept;
-    template<class Y> void reset(Y* p);
-    template<class Y, class D> void reset(Y* p, D d);
-    template<class Y, class D, class A> void reset(Y* p, D d, A a);
     // [util.smartptr.shared.obs], observers
     element_type* get() const noexcept;
     T& operator*() const noexcept;
     T* operator->() const noexcept;
     element_type& operator[](ptrdiff_t i) const;
     long use_count() const noexcept;
     explicit operator bool() const noexcept;
-    template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
-    template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
   };
-  template<class T> shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
-  template<class T, class D> shared_ptr(unique_ptr<T, D>) -> shared_ptr<T>;
-  // [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>& a, nullptr_t) noexcept;
-  template <class T>
- bool operator==(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator!=(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator!=(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator<(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator<(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator<=(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator<=(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator>(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator>(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator>=(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator>=(nullptr_t, const shared_ptr<T>& b) 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;
-  template<class T, class U>
-    shared_ptr<T> reinterpret_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);
 }
 ```
-Specializations of `shared_ptr` shall be `CopyConstructible`,
-`CopyAssignable`, and `LessThanComparable`, allowing their use in
-standard containers. Specializations of `shared_ptr` shall be
 contextually convertible to `bool`, allowing their use in boolean
-expressions and declarations in conditions. The template parameter `T`
-of `shared_ptr` may be an incomplete type.
 [*Example 1*:
 ``` cpp
 if (shared_ptr<X> px = dynamic_pointer_cast<X>(py)) {
@@ -1046,173 +955,168 @@ For purposes of determining the presence of a data race, member
 functions shall access and modify only the `shared_ptr` and `weak_ptr`
 objects themselves and not objects they refer to. Changes in
 `use_count()` do not reflect modifications that can introduce data
 races.
-For the purposes of subclause [[util.smartptr]], a pointer type `Y*` is
-said to be *compatible with* a pointer type `T*` when either `Y*` is
 convertible to `T*` or `Y` is `U[N]` and `T` is cv `U[]`.
-##### `shared_ptr` constructors <a id="util.smartptr.shared.const">[[util.smartptr.shared.const]]</a>
 In the constructor definitions below, enables `shared_from_this` with
 `p`, for a pointer `p` of type `Y*`, means that if `Y` has an
 unambiguous and accessible base class that is a specialization of
-`enable_shared_from_this` ([[util.smartptr.enab]]), then
-`remove_cv_t<Y>*` shall be implicitly convertible to `T*` and the
-constructor evaluates the statement:
 ``` cpp
 if (p != nullptr && p->weak_this.expired())
   p->weak_this = shared_ptr<remove_cv_t<Y>>(*this, const_cast<remove_cv_t<Y>*>(p));
 ```
 The assignment to the `weak_this` member is not atomic and conflicts
-with any potentially concurrent access to the same object (
-[[intro.multithread]]).
 ``` cpp
 constexpr shared_ptr() noexcept;
 ```
-*Effects:* Constructs an empty `shared_ptr` object.
-*Postconditions:* `use_count() == 0 && get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(Y* p);
 ```
-*Requires:* `Y` shall be a complete type. The expression `delete[] p`,
-when `T` is an array type, or `delete p`, when `T` is not an array type,
-shall have well-defined behavior, and shall not throw exceptions.
 *Effects:* When `T` is not an array type, constructs a `shared_ptr`
 object that owns the pointer `p`. Otherwise, constructs a `shared_ptr`
 that owns `p` and a deleter of an unspecified type that calls
 `delete[] p`. When `T` is not an array type, enables `shared_from_this`
 with `p`. If an exception is thrown, `delete p` is called when `T` is
 not an array type, `delete[] p` otherwise.
-*Postconditions:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
-*Remarks:* When `T` is an array type, this constructor shall not
-participate in overload resolution unless the expression `delete[] p` is
-well-formed and either `T` is `U[N]` and `Y(*)[N]` is convertible to
-`T*`, or `T` is `U[]` and `Y(*)[]` is convertible to `T*`. When `T` is
-not an array type, this constructor shall not participate in overload
-resolution unless the expression `delete p` is well-formed and `Y*` is
-convertible to `T*`.
 ``` cpp
 template<class Y, class D> shared_ptr(Y* p, D d);
 template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
 template<class D> shared_ptr(nullptr_t p, D d);
 template<class D, class A> shared_ptr(nullptr_t p, D d, A a);
 ```
-*Requires:* Construction of `d` and a deleter of type `D` initialized
-with `std::move(d)` shall not throw exceptions. The expression `d(p)`
-shall have well-defined behavior and shall not throw exceptions. `A`
-shall be an allocator ([[allocator.requirements]]).
 *Effects:* Constructs a `shared_ptr` object that owns the object `p` and
 the deleter `d`. When `T` is not an array type, the first and second
 constructors enable `shared_from_this` with `p`. The second and fourth
 constructors shall use a copy of `a` to allocate memory for internal
 use. If an exception is thrown, `d(p)` is called.
-*Postconditions:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
-*Remarks:* When `T` is an array type, this constructor shall not
-participate in overload resolution unless `is_move_constructible_v<D>`
-is `true`, the expression `d(p)` is well-formed, and either `T` is
-`U[N]` and `Y(*)[N]` is convertible to `T*`, or `T` is `U[]` and
-`Y(*)[]` is convertible to `T*`. When `T` is not an array type, this
-constructor shall not participate in overload resolution unless
-`is_move_constructible_v<D>` is `true`, the expression `d(p)` is
-well-formed, and `Y*` is convertible to `T*`.
 ``` cpp
 template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
 ```
 *Effects:* Constructs a `shared_ptr` instance that stores `p` and shares
-ownership with `r`.
-*Postconditions:* `get() == p && use_count() == r.use_count()`.
 [*Note 1*: To avoid the possibility of a dangling pointer, the user of
-this constructor must ensure that `p` remains valid at least until the
 ownership group of `r` is destroyed. — *end note*]
 [*Note 2*: This constructor allows creation of an empty `shared_ptr`
 instance with a non-null stored pointer. — *end note*]
 ``` cpp
 shared_ptr(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
 ```
-*Remarks:* The second constructor shall not participate in overload
-resolution unless `Y*` is compatible with `T*`.
 *Effects:* If `r` is empty, constructs an empty `shared_ptr` object;
 otherwise, constructs a `shared_ptr` object that shares ownership with
 `r`.
-*Postconditions:* `get() == r.get() && use_count() == r.use_count()`.
 ``` cpp
 shared_ptr(shared_ptr&& r) noexcept;
 template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
 ```
-*Remarks:* The second constructor shall not participate in overload
-resolution unless `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `shared_ptr` instance from `r`.
-*Postconditions:* `*this` shall contain the old value of `r`. `r` shall
-be empty. `r.get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
 ```
 *Effects:* Constructs a `shared_ptr` object that shares ownership with
 `r` and stores a copy of the pointer stored in `r`. If an exception is
 thrown, the constructor has no effect.
-*Postconditions:* `use_count() == r.use_count()`.
 *Throws:* `bad_weak_ptr` when `r.expired()`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `Y*` is compatible with `T*`.
 ``` cpp
 template<class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
 ```
-*Remarks:* This constructor shall not participate in overload resolution
-unless `Y*` is compatible with `T*` and `unique_ptr<Y, D>::pointer` is
-convertible to `element_type*`.
 *Effects:* If `r.get() == nullptr`, equivalent to `shared_ptr()`.
 Otherwise, if `D` is not a reference type, equivalent to
 `shared_ptr(r.release(), r.get_deleter())`. Otherwise, equivalent to
 `shared_ptr(r.release(), ref(r.get_deleter()))`. If an exception is
 thrown, the constructor has no effect.
-##### `shared_ptr` destructor <a id="util.smartptr.shared.dest">[[util.smartptr.shared.dest]]</a>
 ``` cpp
 ~shared_ptr();
 ```
@@ -1228,22 +1132,22 @@ thrown, the constructor has no effect.
 instances that share ownership with `*this` by one, after `*this` has
 been destroyed all `shared_ptr` instances that shared ownership with
 `*this` will report a `use_count()` that is one less than its previous
 value. — *end note*]
-##### `shared_ptr` assignment <a id="util.smartptr.shared.assign">[[util.smartptr.shared.assign]]</a>
 ``` cpp
 shared_ptr& operator=(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(r).swap(*this)`.
 *Returns:* `*this`.
-[*Note 3*:
 The use count updates caused by the temporary object construction and
 destruction are not observable side effects, so the implementation may
 meet the effects (and the implied guarantees) via different means,
 without creating a temporary. In particular, in the example:
@@ -1274,11 +1178,11 @@ template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
 *Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
-##### `shared_ptr` modifiers <a id="util.smartptr.shared.mod">[[util.smartptr.shared.mod]]</a>
 ``` cpp
 void swap(shared_ptr& r) noexcept;
 ```
@@ -1306,11 +1210,11 @@ template<class Y, class D> void reset(Y* p, D d);
 template<class Y, class D, class A> void reset(Y* p, D d, A a);
 ```
 *Effects:* Equivalent to `shared_ptr(p, d, a).swap(*this)`.
-##### `shared_ptr` observers <a id="util.smartptr.shared.obs">[[util.smartptr.shared.obs]]</a>
 ``` cpp
 element_type* get() const noexcept;
 ```
@@ -1318,45 +1222,45 @@ element_type* get() const noexcept;
 ``` cpp
 T& operator*() const noexcept;
 ```
-*Requires:* `get() != 0`.
 *Returns:* `*get()`.
 *Remarks:* When `T` is an array type or cv `void`, it is unspecified
 whether this member function is declared. If it is declared, it is
 unspecified what its return type is, except that the declaration
-(although not necessarily the definition) of the function shall be well
-formed.
 ``` cpp
 T* operator->() const noexcept;
 ```
-*Requires:* `get() != 0`.
 *Returns:* `get()`.
 *Remarks:* When `T` is an array type, it is unspecified whether this
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
-necessarily the definition) of the function shall be well formed.
 ``` cpp
 element_type& operator[](ptrdiff_t i) const;
 ```
-*Requires:* `get() != 0 && i >= 0`. If `T` is `U[N]`, `i < N`.
 *Returns:* `get()[i]`.
 *Remarks:* When `T` is not an array type, it is unspecified whether this
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
-necessarily the definition) of the function shall be well formed.
 *Throws:* Nothing.
 ``` cpp
 long use_count() const noexcept;
@@ -1365,17 +1269,17 @@ long use_count() const noexcept;
 *Returns:* The number of `shared_ptr` objects, `*this` included, that
 share ownership with `*this`, or `0` when `*this` is empty.
 *Synchronization:* None.
-[*Note 4*: `get() == nullptr` does not imply a specific return value of
 `use_count()`. — *end note*]
-[*Note 5*: `weak_ptr<T>::lock()` can affect the return value of
 `use_count()`. — *end note*]
-[*Note 6*: When multiple threads can affect the return value of
 `use_count()`, the result should be treated as approximate. In
 particular, `use_count() == 1` does not imply that accesses through a
 previously destroyed `shared_ptr` have in any sense
 completed. — *end note*]
@@ -1397,217 +1301,425 @@ template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
 - under the equivalence relation defined by `owner_before`,
   `!a.owner_before(b) && !b.owner_before(a)`, two `shared_ptr` or
   `weak_ptr` instances are equivalent if and only if they share
   ownership or are both empty.
-##### `shared_ptr` creation <a id="util.smartptr.shared.create">[[util.smartptr.shared.create]]</a>
 ``` cpp
-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);
 ```
-*Requires:* The expression `::new (pv) T(std::forward<Args>(args)...)`,
-where `pv` has type `void*` and points to storage suitable to hold an
-object of type `T`, shall be well formed. `A` shall be an
-allocator ([[allocator.requirements]]). The copy constructor and
-destructor of `A` shall not throw exceptions.
-*Effects:* Allocates memory suitable for an object of type `T` and
-constructs an object in that memory via the placement *new-expression*
-`::new (pv) T(std::forward<Args>(args)...)`. The template
-`allocate_shared` uses a copy of `a` to allocate memory. If an exception
-is thrown, the functions have no effect.
 *Returns:* A `shared_ptr` instance that stores and owns the address of
-the newly constructed object of type `T`.
-*Postconditions:* `get() != 0 && use_count() == 1`.
-*Throws:* `bad_alloc`, or an exception thrown from `A::allocate` or from
-the constructor of `T`.
-*Remarks:* The `shared_ptr` constructor called by this function enables
-`shared_from_this` with the address of the newly constructed object of
-type `T`. Implementations should perform no more than one memory
-allocation.
-[*Note 7*: This provides efficiency equivalent to an intrusive smart
   pointer. — *end note*]
-[*Note 8*: These functions will typically allocate more memory than
-`sizeof(T)` to allow for internal bookkeeping structures such as the
 reference counts. — *end note*]
-##### `shared_ptr` comparison <a id="util.smartptr.shared.cmp">[[util.smartptr.shared.cmp]]</a>
 ``` cpp
 template<class T, class U>
   bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `a.get() == b.get()`.
-``` cpp
-template<class T, class U>
-  bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-```
-*Returns:* `less<>()(a.get(), b.get())`.
-[*Note 9*: Defining a comparison function allows `shared_ptr` objects
-to be used as keys in associative containers. — *end note*]
 ``` cpp
 template<class T>
   bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator==(nullptr_t, const shared_ptr<T>& a) noexcept;
 ```
 *Returns:* `!a`.
 ``` cpp
-template <class T>
- bool operator!=(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator!=(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* `(bool)a`.
-``` cpp
-template <class T>
-  bool operator<(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator<(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* The first function template returns
-`less<shared_ptr<T>::element_type*>()(a.get(), nullptr)`. The second
-function template returns
-`less<shared_ptr<T>::element_type*>()(nullptr, a.get())`.
-``` cpp
-template <class T>
-  bool operator>(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator>(nullptr_t, const shared_ptr<T>& a) noexcept;
 ```
-*Returns:* The first function template returns `nullptr < a`. The second
-function template returns `a < nullptr`.
-``` cpp
-template <class T>
-  bool operator<=(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator<=(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* The first function template returns `!(nullptr < a)`. The
-second function template returns `!(a < nullptr)`.
 ``` cpp
 template<class T>
- bool operator>=(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator>=(nullptr_t, const shared_ptr<T>& a) noexcept;
 ```
-*Returns:* The first function template returns `!(a < nullptr)`. The
-second function template returns `!(nullptr < a)`.
-##### `shared_ptr` specialized algorithms <a id="util.smartptr.shared.spec">[[util.smartptr.shared.spec]]</a>
 ``` cpp
 template<class T>
   void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
-##### `shared_ptr` casts <a id="util.smartptr.shared.cast">[[util.smartptr.shared.cast]]</a>
 ``` cpp
 template<class T, class U>
   shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
 ```
-*Requires:* The expression `static_cast<T*>((U*)0)` shall be well
-formed.
 *Returns:*
 ``` cpp
-shared_ptr<T>(r, static_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
-[*Note 10*: The seemingly equivalent expression
 `shared_ptr<T>(static_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
 ```
-*Requires:* The expression `dynamic_cast<T*>((U*)0)` shall be well
-formed and shall have well defined behavior.
 *Returns:*
 - When `dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())`
-  returns a nonzero value `p`, `shared_ptr<T>(r, p)`.
 - Otherwise, `shared_ptr<T>()`.
-[*Note 11*: The seemingly equivalent expression
 `shared_ptr<T>(dynamic_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
 ```
-*Requires:* The expression `const_cast<T*>((U*)0)` shall be well formed.
 *Returns:*
 ``` cpp
-shared_ptr<T>(r, const_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
-[*Note 12*: The seemingly equivalent expression
 `shared_ptr<T>(const_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
 ```
-*Requires:* The expression `reinterpret_cast<T*>((U*)0)` shall be well
-formed.
 *Returns:*
 ``` cpp
-shared_ptr<T>(r, reinterpret_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
-[*Note 13*: The seemingly equivalent expression
 `shared_ptr<T>(reinterpret_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
-##### `get_deleter` <a id="util.smartptr.getdeleter">[[util.smartptr.getdeleter]]</a>
 ``` cpp
 template<class D, class T>
   D* get_deleter(const shared_ptr<T>& p) noexcept;
 ```
@@ -1615,139 +1727,147 @@ template<class D, class T>
 *Returns:* If `p` owns a deleter `d` of type cv-unqualified `D`, returns
 `addressof(d)`; otherwise returns `nullptr`. The returned pointer
 remains valid as long as there exists a `shared_ptr` instance that owns
 `d`.
-[*Note 14*: It is unspecified whether the pointer remains valid longer
 than that. This can happen if the implementation doesn’t destroy the
 deleter until all `weak_ptr` instances that share ownership with `p`
 have been destroyed. — *end note*]
-##### `shared_ptr` I/O <a id="util.smartptr.shared.io">[[util.smartptr.shared.io]]</a>
 ``` cpp
 template<class E, class T, class Y>
   basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);
 ```
 *Effects:* As if by: `os << p.get();`
 *Returns:* `os`.
-#### Class template `weak_ptr` <a id="util.smartptr.weak">[[util.smartptr.weak]]</a>
 The `weak_ptr` class template stores a weak reference to an object that
 is already managed by a `shared_ptr`. To access the object, a `weak_ptr`
 can be converted to a `shared_ptr` using the member function `lock`.
 ``` cpp
 namespace std {
   template<class T> class weak_ptr {
   public:
-    using element_type = T;
     // [util.smartptr.weak.const], constructors
     constexpr weak_ptr() noexcept;
-    template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
     weak_ptr(const weak_ptr& r) noexcept;
-    template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
     weak_ptr(weak_ptr&& r) noexcept;
-    template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.dest], destructor
     ~weak_ptr();
     // [util.smartptr.weak.assign], assignment
     weak_ptr& operator=(const weak_ptr& r) noexcept;
-    template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
-    template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
     weak_ptr& operator=(weak_ptr&& r) noexcept;
-    template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.mod], modifiers
     void swap(weak_ptr& r) noexcept;
     void reset() noexcept;
     // [util.smartptr.weak.obs], observers
     long use_count() const noexcept;
     bool expired() const noexcept;
     shared_ptr<T> lock() const noexcept;
-    template<class U> bool owner_before(const shared_ptr<U>& b) const;
-    template<class U> bool owner_before(const weak_ptr<U>& b) const;
   };
-  template<class T> weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
   // [util.smartptr.weak.spec], specialized algorithms
-  template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 }
 ```
-Specializations of `weak_ptr` shall be `CopyConstructible` and
-`CopyAssignable`, allowing their use in standard containers. The
 template parameter `T` of `weak_ptr` may be an incomplete type.
-##### `weak_ptr` constructors <a id="util.smartptr.weak.const">[[util.smartptr.weak.const]]</a>
 ``` cpp
 constexpr weak_ptr() noexcept;
 ```
 *Effects:* Constructs an empty `weak_ptr` object.
-*Postconditions:* `use_count() == 0`.
 ``` cpp
 weak_ptr(const weak_ptr& r) noexcept;
 template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
 template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
 ```
-*Remarks:* The second and third constructors shall not participate in
-overload resolution unless `Y*` is compatible with `T*`.
 *Effects:* If `r` is empty, constructs an empty `weak_ptr` object;
 otherwise, constructs a `weak_ptr` object that shares ownership with `r`
 and stores a copy of the pointer stored in `r`.
-*Postconditions:* `use_count() == r.use_count()`.
 ``` cpp
 weak_ptr(weak_ptr&& r) noexcept;
 template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
 ```
-*Remarks:* The second constructor shall not participate in overload
-resolution unless `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `weak_ptr` instance from `r`.
-*Postconditions:* `*this` shall contain the old value of `r`. `r` shall
-be empty. `r.use_count() == 0`.
-##### `weak_ptr` destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
 ``` cpp
 ~weak_ptr();
 ```
 *Effects:* Destroys this `weak_ptr` object but has no effect on the
 object its stored pointer points to.
-##### `weak_ptr` assignment <a id="util.smartptr.weak.assign">[[util.smartptr.weak.assign]]</a>
 ``` cpp
 weak_ptr& operator=(const weak_ptr& r) noexcept;
 template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
 template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr(r).swap(*this)`.
 *Remarks:* The implementation may meet the effects (and the implied
-guarantees) via different means, without creating a temporary.
 *Returns:* `*this`.
 ``` cpp
 weak_ptr& operator=(weak_ptr&& r) noexcept;
@@ -1756,11 +1876,11 @@ template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
 *Effects:* Equivalent to `weak_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
-##### `weak_ptr` modifiers <a id="util.smartptr.weak.mod">[[util.smartptr.weak.mod]]</a>
 ``` cpp
 void swap(weak_ptr& r) noexcept;
 ```
@@ -1770,11 +1890,11 @@ void swap(weak_ptr& r) noexcept;
 void reset() noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr().swap(*this)`.
-##### `weak_ptr` observers <a id="util.smartptr.weak.obs">[[util.smartptr.weak.obs]]</a>
 ``` cpp
 long use_count() const noexcept;
 ```
@@ -1793,12 +1913,12 @@ shared_ptr<T> lock() const noexcept;
 *Returns:* `expired() ? shared_ptr<T>() : shared_ptr<T>(*this)`,
 executed atomically.
 ``` cpp
-template<class U> bool owner_before(const shared_ptr<U>& b) const;
-template<class U> bool owner_before(const weak_ptr<U>& b) const;
 ```
 *Returns:* An unspecified value such that
 - `x.owner_before(y)` defines a strict weak ordering as defined
@@ -1806,20 +1926,20 @@ template<class U> bool owner_before(const weak_ptr<U>& b) const;
 - under the equivalence relation defined by `owner_before`,
   `!a.owner_before(b) && !b.owner_before(a)`, two `shared_ptr` or
   `weak_ptr` instances are equivalent if and only if they share
   ownership or are both empty.
-##### `weak_ptr` specialized algorithms <a id="util.smartptr.weak.spec">[[util.smartptr.weak.spec]]</a>
 ``` cpp
 template<class T>
   void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
-#### Class template `owner_less` <a id="util.smartptr.ownerless">[[util.smartptr.ownerless]]</a>
 The class template `owner_less` allows ownership-based mixed comparisons
 of shared and weak pointers.
 ``` cpp
@@ -1851,11 +1971,11 @@ namespace std {
     using is_transparent = unspecified;
   };
 }
 ```
-`operator()(x, y)` shall return `x.owner_before(y)`.
 [*Note 1*:
 Note that
@@ -1866,11 +1986,11 @@ Note that
   `weak_ptr` instances are equivalent if and only if they share
   ownership or are both empty.
 — *end note*]
-#### Class template `enable_shared_from_this` <a id="util.smartptr.enab">[[util.smartptr.enab]]</a>
 A class `T` can inherit from `enable_shared_from_this<T>` to inherit the
 `shared_from_this` member functions that obtain a `shared_ptr` instance
 pointing to `*this`.
@@ -1895,15 +2015,17 @@ namespace std {
   protected:
     constexpr enable_shared_from_this() noexcept;
     enable_shared_from_this(const enable_shared_from_this&) noexcept;
     enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept;
     ~enable_shared_from_this();
   public:
     shared_ptr<T> shared_from_this();
     shared_ptr<T const> shared_from_this() const;
     weak_ptr<T> weak_from_this() noexcept;
     weak_ptr<T const> weak_from_this() const noexcept;
   private:
     mutable weak_ptr<T> weak_this;  // exposition only
   };
 }
 ```
@@ -1938,176 +2060,25 @@ weak_ptr<T>       weak_from_this() noexcept;
 weak_ptr<T const> weak_from_this() const noexcept;
 ```
 *Returns:* `weak_this`.
-#### `shared_ptr` atomic access <a id="util.smartptr.shared.atomic">[[util.smartptr.shared.atomic]]</a>
-Concurrent access to a `shared_ptr` object from multiple threads does
-not introduce a data race if the access is done exclusively via the
-functions in this section and the instance is passed as their first
-argument.
-The meaning of the arguments of type `memory_order` is explained in
-[[atomics.order]].
-``` cpp
-template<class T>
-  bool atomic_is_lock_free(const shared_ptr<T>* p);
-```
-*Requires:* `p` shall not be null.
-*Returns:* `true` if atomic access to `*p` is lock-free, `false`
-otherwise.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  shared_ptr<T> atomic_load(const shared_ptr<T>* p);
-```
-*Requires:* `p` shall not be null.
-*Returns:* `atomic_load_explicit(p, memory_order_seq_cst)`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo);
-```
-*Requires:* `p` shall not be null.
-*Requires:* `mo` shall not be `memory_order_release` or
-`memory_order_acq_rel`.
-*Returns:* `*p`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
-```
-*Requires:* `p` shall not be null.
-*Effects:* As if by `atomic_store_explicit(p, r, memory_order_seq_cst)`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
-```
-*Requires:* `p` shall not be null.
-*Requires:* `mo` shall not be `memory_order_acquire` or
-`memory_order_acq_rel`.
-*Effects:* As if by `p->swap(r)`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r);
-```
-*Requires:* `p` shall not be null.
-*Returns:* `atomic_exchange_explicit(p, r, memory_order_seq_cst)`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
-```
-*Requires:* `p` shall not be null.
-*Effects:* As if by `p->swap(r)`.
-*Returns:* The previous value of `*p`.
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  bool atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
-```
-*Requires:* `p` shall not be null and `v` shall not be null.
-*Returns:*
-``` cpp
-atomic_compare_exchange_weak_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)
-```
-*Throws:* Nothing.
-``` cpp
-template<class T>
-  bool atomic_compare_exchange_strong(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
-```
-*Returns:*
-``` cpp
-atomic_compare_exchange_strong_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)
-```
-``` cpp
-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);
-```
-*Requires:* `p` shall not be null and `v` shall not be null. The
-`failure` argument shall not be `memory_order_release` nor
-`memory_order_acq_rel`.
-*Effects:* If `*p` is equivalent to `*v`, assigns `w` to `*p` and has
-synchronization semantics corresponding to the value of `success`,
-otherwise assigns `*p` to `*v` and has synchronization semantics
-corresponding to the value of `failure`.
-*Returns:* `true` if `*p` was equivalent to `*v`, `false` otherwise.
-*Throws:* Nothing.
-*Remarks:* Two `shared_ptr` objects are equivalent if they store the
-same pointer value and share ownership. The weak form may fail
-spuriously. See  [[atomics.types.operations]].
-#### Smart pointer hash support <a id="util.smartptr.hash">[[util.smartptr.hash]]</a>
 ``` cpp
 template<class T, class D> struct hash<unique_ptr<T, D>>;
 ```
 Letting `UP` be `unique_ptr<T,D>`, the specialization `hash<UP>` is
-enabled ([[unord.hash]]) if and only if `hash<typename UP::pointer>` is
 enabled. When enabled, for an object `p` of type `UP`, `hash<UP>()(p)`
-shall evaluate to the same value as
-`hash<typename UP::pointer>()(p.get())`. The member functions are not
-guaranteed to be `noexcept`.
 ``` cpp
 template<class T> struct hash<shared_ptr<T>>;
 ```
 For an object `p` of type `shared_ptr<T>`, `hash<shared_ptr<T>>()(p)`
-shall evaluate to the same value as
 `hash<typename shared_ptr<T>::element_type*>()(p.get())`.

 A *unique pointer* is an object that owns another object and manages
 that other object through a pointer. More precisely, a unique pointer is
 an object *u* that stores a pointer to a second object *p* and will
 dispose of *p* when *u* is itself destroyed (e.g., when leaving block
+scope [[stmt.dcl]]). In this context, *u* is said to *own* `p`.
 The mechanism by which *u* disposes of *p* is known as *p*’s associated
 *deleter*, a function object whose correct invocation results in *p*’s
 appropriate disposition (typically its deletion).
 Let the notation *u.p* denote the pointer stored by *u*, and let *u.d*
 denote the associated deleter. Upon request, *u* can *reset* (replace)
+*u.p* and *u.d* with another pointer and deleter, but properly disposes
+of its owned object via the associated deleter before such replacement
+is considered completed.
 Each object of a type `U` instantiated from the `unique_ptr` template
 specified in this subclause has the strict ownership semantics,
 specified above, of a unique pointer. In partial satisfaction of these
+semantics, each such `U` is *Cpp17MoveConstructible* and
+*Cpp17MoveAssignable*, but is not *Cpp17CopyConstructible* nor
+*Cpp17CopyAssignable*. The template parameter `T` of `unique_ptr` may be
+an incomplete type.
+[*Note 1*: The uses of `unique_ptr` include providing exception safety
 for dynamically allocated memory, passing ownership of dynamically
 allocated memory to a function, and returning dynamically allocated
 memory from a function. — *end note*]
 #### Default deleters <a id="unique.ptr.dltr">[[unique.ptr.dltr]]</a>
 ##### In general <a id="unique.ptr.dltr.general">[[unique.ptr.dltr.general]]</a>
 The class template `default_delete` serves as the default deleter
 ``` cpp
 template<class U> default_delete(const default_delete<U>& other) noexcept;
 ```
+*Constraints:* `U*` is implicitly convertible to `T*`.
 *Effects:* Constructs a `default_delete` object from another
 `default_delete<U>` object.
 ``` cpp
 void operator()(T* ptr) const;
 ```
+*Mandates:* `T` is a complete type.
 *Effects:* Calls `delete` on `ptr`.
 ##### `default_delete<T[]>` <a id="unique.ptr.dltr.dflt1">[[unique.ptr.dltr.dflt1]]</a>
 ``` cpp
 namespace std {
   template<class T> struct default_delete<T[]> {
 ``` cpp
 template<class U> default_delete(const default_delete<U[]>& other) noexcept;
 ```
+*Constraints:* `U(*)[]` is convertible to `T(*)[]`.
+*Effects:* Constructs a `default_delete` object from another
 `default_delete<U[]>` object.
 ``` cpp
 template<class U> void operator()(U* ptr) const;
 ```
+*Mandates:* `U` is a complete type.
+*Constraints:* `U(*)[]` is convertible to `T(*)[]`.
 *Effects:* Calls `delete[]` on `ptr`.
 #### `unique_ptr` for single objects <a id="unique.ptr.single">[[unique.ptr.single]]</a>
 ``` cpp
 namespace std {
   template<class T, class D = default_delete<T>> class unique_ptr {
     // [unique.ptr.single.dtor], destructor
     ~unique_ptr();
     // [unique.ptr.single.asgn], assignment
     unique_ptr& operator=(unique_ptr&& u) noexcept;
+    template<class U, class E>
+      unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
     unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.single.observers], observers
     add_lvalue_reference_t<T> operator*() const;
     pointer operator->() const noexcept;
   };
 }
 ```
 The default type for the template parameter `D` is `default_delete`. A
+client-supplied template argument `D` shall be a function object type
+[[function.objects]], lvalue reference to function, or lvalue reference
 to function object type for which, given a value `d` of type `D` and a
 value `ptr` of type `unique_ptr<T, D>::pointer`, the expression `d(ptr)`
 is valid and has the effect of disposing of the pointer as appropriate
 for that deleter.
+If the deleter’s type `D` is not a reference type, `D` shall meet the
+*Cpp17Destructible* requirements ([[cpp17.destructible]]).
 If the *qualified-id* `remove_reference_t<D>::pointer` is valid and
+denotes a type [[temp.deduct]], then `unique_ptr<T,
 D>::pointer` shall be a synonym for `remove_reference_t<D>::pointer`.
 Otherwise `unique_ptr<T, D>::pointer` shall be a synonym for
 `element_type*`. The type `unique_ptr<T,
+D>::pointer` shall meet the *Cpp17NullablePointer* requirements (
+[[cpp17.nullablepointer]]).
+[*Example 1*: Given an allocator type `X` ([[cpp17.allocator]]) and
+letting `A` be a synonym for `allocator_traits<X>`, the types
 `A::pointer`, `A::const_pointer`, `A::void_pointer`, and
 `A::const_void_pointer` may be used as
 `unique_ptr<T, D>::pointer`. — *end example*]
+##### Constructors <a id="unique.ptr.single.ctor">[[unique.ptr.single.ctor]]</a>
 ``` cpp
 constexpr unique_ptr() noexcept;
 constexpr unique_ptr(nullptr_t) noexcept;
 ```
+*Preconditions:* `D` meets the *Cpp17DefaultConstructible* requirements
+([[cpp17.defaultconstructible]]), and that construction does not throw
+an exception.
+*Constraints:* `is_pointer_v<deleter_type>` is `false` and
+`is_default_constructible_v<deleter_type>` is `true`.
 *Effects:* Constructs a `unique_ptr` object that owns nothing,
 value-initializing the stored pointer and the stored deleter.
+*Ensures:* `get() == nullptr`. `get_deleter()` returns a reference to
+the stored deleter.
 ``` cpp
 explicit unique_ptr(pointer p) noexcept;
 ```
+*Constraints:* `is_pointer_v<deleter_type>` is `false` and
+`is_default_constructible_v<deleter_type>` is `true`.
+*Mandates:* This constructor is not selected by class template argument
+deduction [[over.match.class.deduct]].
+*Preconditions:* `D` meets the *Cpp17DefaultConstructible* requirements
+([[cpp17.defaultconstructible]]), and that construction does not throw
+an exception.
 *Effects:* Constructs a `unique_ptr` which owns `p`, initializing the
 stored pointer with `p` and value-initializing the stored deleter.
+*Ensures:* `get() == p`. `get_deleter()` returns a reference to the
+stored deleter.
 ``` cpp
+unique_ptr(pointer p, const D& d) noexcept;
+unique_ptr(pointer p, remove_reference_t<D>&& d) noexcept;
 ```
+*Constraints:* `is_constructible_v<D, decltype(d)>` is `true`.
+*Mandates:* These constructors are not selected by class template
+argument deduction [[over.match.class.deduct]].
+*Preconditions:* For the first constructor, if `D` is not a reference
+type, `D` meets the *Cpp17CopyConstructible* requirements and such
+construction does not exit via an exception. For the second constructor,
+if `D` is not a reference type, `D` meets the *Cpp17MoveConstructible*
+requirements and such construction does not exit via an exception.
 *Effects:* Constructs a `unique_ptr` object which owns `p`, initializing
 the stored pointer with `p` and initializing the deleter from
 `std::forward<decltype(d)>(d)`.
+*Ensures:* `get() == p`. `get_deleter()` returns a reference to the
+stored deleter. If `D` is a reference type then `get_deleter()` returns
+a reference to the lvalue `d`.
+*Remarks:* If `D` is a reference type, the second constructor is defined
+as deleted.
 [*Example 1*:
 ``` cpp
 D d;
+unique_ptr<int, D> p1(new int, D());        // D must be Cpp17MoveConstructible
+unique_ptr<int, D> p2(new int, d);          // D must be Cpp17CopyConstructible
 unique_ptr<int, D&> p3(new int, d);         // p3 holds a reference to d
 unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object combined
                                             // with reference deleter type
 ```
 ``` cpp
 unique_ptr(unique_ptr&& u) noexcept;
 ```
+*Constraints:* `is_move_constructible_v<D>` is `true`.
+*Preconditions:* If `D` is not a reference type, `D` meets the
+*Cpp17MoveConstructible* requirements ([[cpp17.moveconstructible]]).
+Construction of the deleter from an rvalue of type `D` does not throw an
+exception.
+*Effects:* Constructs a `unique_ptr` from `u`. If `D` is a reference
+type, this deleter is copy constructed from `u`’s deleter; otherwise,
+this deleter is move constructed from `u`’s deleter.
+[*Note 1*: The construction of the deleter can be implemented with
 `std::forward<D>`. — *end note*]
+*Ensures:* `get()` yields the value `u.get()` yielded before the
+construction. `u.get() == nullptr`. `get_deleter()` returns a reference
+to the stored deleter that was constructed from `u.get_deleter()`. If
+`D` is a reference type then `get_deleter()` and `u.get_deleter()` both
+reference the same lvalue deleter.
 ``` cpp
 template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
+*Constraints:*
+- `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
+- `U` is not an array type, and
+- either `D` is a reference type and `E` is the same type as `D`, or `D`
+  is not a reference type and `E` is implicitly convertible to `D`.
+*Preconditions:* If `E` is not a reference type, construction of the
+deleter from an rvalue of type `E` is well-formed and does not throw an
 exception. Otherwise, `E` is a reference type and construction of the
+deleter from an lvalue of type `E` is well-formed and does not throw an
+exception.
+*Effects:* Constructs a `unique_ptr` from `u`. If `E` is a reference
+type, this deleter is copy constructed from `u`’s deleter; otherwise,
+this deleter is move constructed from `u`’s deleter.
 [*Note 2*: The deleter constructor can be implemented with
 `std::forward<E>`. — *end note*]
+*Ensures:* `get()` yields the value `u.get()` yielded before the
+construction. `u.get() == nullptr`. `get_deleter()` returns a reference
+to the stored deleter that was constructed from `u.get_deleter()`.
+##### Destructor <a id="unique.ptr.single.dtor">[[unique.ptr.single.dtor]]</a>
 ``` cpp
 ~unique_ptr();
 ```
+*Preconditions:* The expression `get_deleter()(get())` is well-formed,
+has well-defined behavior, and does not throw exceptions.
 [*Note 3*: The use of `default_delete` requires `T` to be a complete
 type. — *end note*]
 *Effects:* If `get() == nullptr` there are no effects. Otherwise
 `get_deleter()(get())`.
+##### Assignment <a id="unique.ptr.single.asgn">[[unique.ptr.single.asgn]]</a>
 ``` cpp
 unique_ptr& operator=(unique_ptr&& u) noexcept;
 ```
+*Constraints:* `is_move_assignable_v<D>` is `true`.
+*Preconditions:* If `D` is not a reference type, `D` meets the
+*Cpp17MoveAssignable* requirements ([[cpp17.moveassignable]]) and
+assignment of the deleter from an rvalue of type `D` does not throw an
 exception. Otherwise, `D` is a reference type; `remove_reference_t<D>`
+meets the *Cpp17CopyAssignable* requirements and assignment of the
+deleter from an lvalue of type `D` does not throw an exception.
+*Effects:* Calls `reset(u.release())` followed by
 `get_deleter() = std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
+*Ensures:* `u.get() == nullptr`.
 ``` cpp
 template<class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 ```
+*Constraints:*
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
   and
 - `U` is not an array type, and
 - `is_assignable_v<D&, E&&>` is `true`.
+*Preconditions:* If `E` is not a reference type, assignment of the
+deleter from an rvalue of type `E` is well-formed and does not throw an
+exception. Otherwise, `E` is a reference type and assignment of the
+deleter from an lvalue of type `E` is well-formed and does not throw an
+exception.
+*Effects:* Calls `reset(u.release())` followed by
 `get_deleter() = std::forward<E>(u.get_deleter())`.
 *Returns:* `*this`.
+*Ensures:* `u.get() == nullptr`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 ```
 *Effects:* As if by `reset()`.
+*Ensures:* `get() == nullptr`.
 *Returns:* `*this`.
+##### Observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
 add_lvalue_reference_t<T> operator*() const;
 ```
+*Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
 pointer operator->() const noexcept;
 ```
+*Preconditions:* `get() != nullptr`.
 *Returns:* `get()`.
 [*Note 4*: The use of this function typically requires that `T` be a
 complete type. — *end note*]
 explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
+##### Modifiers <a id="unique.ptr.single.modifiers">[[unique.ptr.single.modifiers]]</a>
 ``` cpp
 pointer release() noexcept;
 ```
+*Ensures:* `get() == nullptr`.
 *Returns:* The value `get()` had at the start of the call to `release`.
 ``` cpp
 void reset(pointer p = pointer()) noexcept;
 ```
+*Preconditions:* The expression `get_deleter()(get())` is well-formed,
+has well-defined behavior, and does not throw exceptions.
 *Effects:* Assigns `p` to the stored pointer, and then if and only if
 the old value of the stored pointer, `old_p`, was not equal to
 `nullptr`, calls `get_deleter()(old_p)`.
 [*Note 5*: The order of these operations is significant because the
 call to `get_deleter()` may destroy `*this`. — *end note*]
+*Ensures:* `get() == p`.
 [*Note 6*: The postcondition does not hold if the call to
 `get_deleter()` destroys `*this` since `this->get()` is no longer a
 valid expression. — *end note*]
 ``` cpp
 void swap(unique_ptr& u) noexcept;
 ```
+*Preconditions:* `get_deleter()` is swappable [[swappable.requirements]]
+and does not throw an exception under `swap`.
 *Effects:* Invokes `swap` on the stored pointers and on the stored
 deleters of `*this` and `u`.
 #### `unique_ptr` for array objects with a runtime length <a id="unique.ptr.runtime">[[unique.ptr.runtime]]</a>
 Descriptions are provided below only for members that differ from the
 primary template.
 The template argument `T` shall be a complete type.
+##### Constructors <a id="unique.ptr.runtime.ctor">[[unique.ptr.runtime.ctor]]</a>
 ``` cpp
 template<class U> explicit unique_ptr(U p) noexcept;
 ```
 This constructor behaves the same as the constructor in the primary
+template that takes a single parameter of type `pointer`.
+*Constraints:*
 - `U` is the same type as `pointer`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 template<class U> unique_ptr(U p, see below d) noexcept;
 template<class U> unique_ptr(U p, see below d) noexcept;
 ```
 These constructors behave the same as the constructors in the primary
+template that take a parameter of type `pointer` and a second parameter.
+*Constraints:*
 - `U` is the same type as `pointer`,
 - `U` is `nullptr_t`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 ``` cpp
+template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
+This constructor behaves the same as in the primary template.
+*Constraints:* Where `UP` is `unique_ptr<U, E>`:
 - `U` is an array type, and
 - `pointer` is the same type as `element_type*`, and
 - `UP::pointer` is the same type as `UP::element_type*`, and
 - `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
 - either `D` is a reference type and `E` is the same type as `D`, or `D`
   is not a reference type and `E` is implicitly convertible to `D`.
+[*Note 1*: This replaces the *Constraints:* specification of the
+primary template. — *end note*]
+##### Assignment <a id="unique.ptr.runtime.asgn">[[unique.ptr.runtime.asgn]]</a>
 ``` cpp
+template<class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u)noexcept;
 ```
+This operator behaves the same as in the primary template.
+*Constraints:* Where `UP` is `unique_ptr<U, E>`:
 - `U` is an array type, and
 - `pointer` is the same type as `element_type*`, and
 - `UP::pointer` is the same type as `UP::element_type*`, and
 - `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
 - `is_assignable_v<D&, E&&>` is `true`.
+[*Note 2*: This replaces the *Constraints:* specification of the
+primary template. — *end note*]
+##### Observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
 T& operator[](size_t i) const;
 ```
+*Preconditions:* `i` < the number of elements in the array to which the
 stored pointer points.
 *Returns:* `get()[i]`.
+##### Modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
 void reset(nullptr_t p = nullptr) noexcept;
 ```
 ``` cpp
 template<class U> void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
+template.
+*Constraints:*
 - `U` is the same type as `pointer`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
+#### Creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
 template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
 ```
+*Constraints:* `T` is not an array type.
 *Returns:* `unique_ptr<T>(new T(std::forward<Args>(args)...))`.
 ``` cpp
 template<class T> unique_ptr<T> make_unique(size_t n);
 ```
+*Constraints:* `T` is an array of unknown bound.
 *Returns:* `unique_ptr<T>(new remove_extent_t<T>[n]())`.
 ``` cpp
 template<class T, class... Args> unspecified make_unique(Args&&...) = delete;
 ```
+*Constraints:* `T` is an array of known bound.
+``` cpp
+template<class T> unique_ptr<T> make_unique_for_overwrite();
+```
+*Constraints:* `T` is not an array type.
+*Returns:* `unique_ptr<T>(new T)`.
+``` cpp
+template<class T> unique_ptr<T> make_unique_for_overwrite(size_t n);
+```
+*Constraints:* `T` is an array of unknown bound.
+*Returns:* `unique_ptr<T>(new remove_extent_t<T>[n])`.
+``` cpp
+template<class T, class... Args> unspecified make_unique_for_overwrite(Args&&...) = delete;
+```
+*Constraints:* `T` is an array of known bound.
+#### Specialized algorithms <a id="unique.ptr.special">[[unique.ptr.special]]</a>
 ``` cpp
 template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 ```
+*Constraints:* `is_swappable_v<D>` is `true`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `x.get() == y.get()`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
+Let `CT` denote
 ``` cpp
 common_type_t<typename unique_ptr<T1, D1>::pointer,
               typename unique_ptr<T2, D2>::pointer>
 ```
+*Mandates:*
+- `unique_ptr<T1, D1>::pointer` is implicitly convertible to `CT` and
+- `unique_ptr<T2, D2>::pointer` is implicitly convertible to `CT`.
+*Preconditions:* The specialization `less<CT>` is a function object
+type [[function.objects]] that induces a strict weak
+ordering [[alg.sorting]] on the pointer values.
+*Returns:* `less<CT>()(x.get(), y.get())`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `y < x`.
+``` cpp
+template<class T1, class D1, class T2, class D2>
+  bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+```
+*Returns:* `!(y < x)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `!(x < y)`.
+``` cpp
+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);
+```
+*Returns:* `compare_three_way()(x.get(), y.get())`.
 ``` cpp
 template<class T, class D>
   bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
 ```
 *Returns:* `!x`.
 ``` cpp
 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>& x);
 ```
+*Preconditions:* The specialization `less<unique_ptr<T, D>::pointer>` is
+a function object type [[function.objects]] that induces a strict weak
+ordering [[alg.sorting]] on the pointer values.
 *Returns:* The first function template returns
+``` cpp
+less<unique_ptr<T, D>::pointer>()(x.get(), nullptr)
+```
+The second function template returns
+``` cpp
+less<unique_ptr<T, D>::pointer>()(nullptr, x.get())
+```
 ``` cpp
 template<class T, class D>
   bool operator>(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
 ```
 *Returns:* The first function template returns `!(x < nullptr)`. The
 second function template returns `!(nullptr < x)`.
+``` cpp
+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);
+```
+*Returns:* `compare_three_way()(x.get(), nullptr)`.
+#### I/O <a id="unique.ptr.io">[[unique.ptr.io]]</a>
+``` cpp
+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);
+```
+*Constraints:* `os << p.get()` is a valid expression.
+*Effects:* Equivalent to: `os << p.get();`
+*Returns:* `os`.
+### Class `bad_weak_ptr` <a id="util.smartptr.weak.bad">[[util.smartptr.weak.bad]]</a>
 ``` cpp
 namespace std {
   class bad_weak_ptr : public exception {
   public:
+ // see [exception] for the specification of the special member functions
+    const char* what() const noexcept override;
   };
 }
 ```
 An exception of type `bad_weak_ptr` is thrown by the `shared_ptr`
 constructor taking a `weak_ptr`.
 ``` cpp
+const char* what() const noexcept override;
 ```
+*Returns:* An *implementation-defined* NTBS.
+### Class template `shared_ptr` <a id="util.smartptr.shared">[[util.smartptr.shared]]</a>
 The `shared_ptr` class template stores a pointer, usually obtained via
 `new`. `shared_ptr` implements semantics of shared ownership; the last
 remaining owner of the pointer is responsible for destroying the object,
 or otherwise releasing the resources associated with the stored pointer.
     using element_type = remove_extent_t<T>;
     using weak_type    = weak_ptr<T>;
     // [util.smartptr.shared.const], constructors
     constexpr shared_ptr() noexcept;
     constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
+    template<class Y>
+      explicit shared_ptr(Y* p);
+    template<class Y, class D>
+      shared_ptr(Y* p, D d);
+    template<class Y, class D, class A>
+      shared_ptr(Y* p, D d, A a);
+    template<class D>
+      shared_ptr(nullptr_t p, D d);
+    template<class D, class A>
+      shared_ptr(nullptr_t p, D d, A a);
+    template<class Y>
+      shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
+    template<class Y>
+      shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
+    shared_ptr(const shared_ptr& r) noexcept;
+    template<class Y>
+      shared_ptr(const shared_ptr<Y>& r) noexcept;
+    shared_ptr(shared_ptr&& r) noexcept;
+    template<class Y>
+      shared_ptr(shared_ptr<Y>&& r) noexcept;
+    template<class Y>
+      explicit shared_ptr(const weak_ptr<Y>& r);
+    template<class Y, class D>
+      shared_ptr(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.dest], destructor
     ~shared_ptr();
     // [util.smartptr.shared.assign], assignment
     shared_ptr& operator=(const shared_ptr& r) noexcept;
+    template<class Y>
+      shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
     shared_ptr& operator=(shared_ptr&& r) noexcept;
+    template<class Y>
+ shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
+    template<class Y, class D>
+      shared_ptr& operator=(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.mod], modifiers
     void swap(shared_ptr& r) noexcept;
     void reset() noexcept;
+    template<class Y>
+ void reset(Y* p);
+    template<class Y, class D>
+      void reset(Y* p, D d);
+    template<class Y, class D, class A>
+      void reset(Y* p, D d, A a);
     // [util.smartptr.shared.obs], observers
     element_type* get() const noexcept;
     T& operator*() const noexcept;
     T* operator->() const noexcept;
     element_type& operator[](ptrdiff_t i) const;
     long use_count() const noexcept;
     explicit operator bool() const noexcept;
+    template<class U>
+ bool owner_before(const shared_ptr<U>& b) const noexcept;
+    template<class U>
+      bool owner_before(const weak_ptr<U>& b) const noexcept;
   };
   template<class T>
+    shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
+  template<class T, class D>
+ shared_ptr(unique_ptr<T, D>) -> shared_ptr<T>;
 }
 ```
+Specializations of `shared_ptr` shall be *Cpp17CopyConstructible*,
+*Cpp17CopyAssignable*, and *Cpp17LessThanComparable*, allowing their use
+in standard containers. Specializations of `shared_ptr` shall be
 contextually convertible to `bool`, allowing their use in boolean
+expressions and declarations in conditions.
+The template parameter `T` of `shared_ptr` may be an incomplete type.
+[*Note 1*: `T` may be a function type. — *end note*]
 [*Example 1*:
 ``` cpp
 if (shared_ptr<X> px = dynamic_pointer_cast<X>(py)) {
 functions shall access and modify only the `shared_ptr` and `weak_ptr`
 objects themselves and not objects they refer to. Changes in
 `use_count()` do not reflect modifications that can introduce data
 races.
+For the purposes of subclause [[smartptr]], a pointer type `Y*` is said
+to be *compatible with* a pointer type `T*` when either `Y*` is
 convertible to `T*` or `Y` is `U[N]` and `T` is cv `U[]`.
+#### Constructors <a id="util.smartptr.shared.const">[[util.smartptr.shared.const]]</a>
 In the constructor definitions below, enables `shared_from_this` with
 `p`, for a pointer `p` of type `Y*`, means that if `Y` has an
 unambiguous and accessible base class that is a specialization of
+`enable_shared_from_this` [[util.smartptr.enab]], then `remove_cv_t<Y>*`
+shall be implicitly convertible to `T*` and the constructor evaluates
+the statement:
 ``` cpp
 if (p != nullptr && p->weak_this.expired())
   p->weak_this = shared_ptr<remove_cv_t<Y>>(*this, const_cast<remove_cv_t<Y>*>(p));
 ```
 The assignment to the `weak_this` member is not atomic and conflicts
+with any potentially concurrent access to the same object
+[[intro.multithread]].
 ``` cpp
 constexpr shared_ptr() noexcept;
 ```
+*Ensures:* `use_count() == 0 && get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(Y* p);
 ```
+*Mandates:* `Y` is a complete type.
+*Constraints:* When `T` is an array type, the expression `delete[] p` is
+well-formed and either `T` is `U[N]` and `Y(*)[N]` is convertible to
+`T*`, or `T` is `U[]` and `Y(*)[]` is convertible to `T*`. When `T` is
+not an array type, the expression `delete p` is well-formed and `Y*` is
+convertible to `T*`.
+*Preconditions:* The expression `delete[] p`, when `T` is an array type,
+or `delete p`, when `T` is not an array type, has well-defined behavior,
+and does not throw exceptions.
 *Effects:* When `T` is not an array type, constructs a `shared_ptr`
 object that owns the pointer `p`. Otherwise, constructs a `shared_ptr`
 that owns `p` and a deleter of an unspecified type that calls
 `delete[] p`. When `T` is not an array type, enables `shared_from_this`
 with `p`. If an exception is thrown, `delete p` is called when `T` is
 not an array type, `delete[] p` otherwise.
+*Ensures:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
 ``` cpp
 template<class Y, class D> shared_ptr(Y* p, D d);
 template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
 template<class D> shared_ptr(nullptr_t p, D d);
 template<class D, class A> shared_ptr(nullptr_t p, D d, A a);
 ```
+*Constraints:* `is_move_constructible_v<D>` is `true`, and `d(p)` is a
+well-formed expression. For the first two overloads:
+- If `T` is an array type, then either `T` is `U[N]` and `Y(*)[N]` is
+  convertible to `T*`, or `T` is `U[]` and `Y(*)[]` is convertible to
+  `T*`.
+- If `T` is not an array type, then `Y*` is convertible to `T*`.
+*Preconditions:* Construction of `d` and a deleter of type `D`
+initialized with `std::move(d)` do not throw exceptions. The expression
+`d(p)` has well-defined behavior and does not throw exceptions. `A`
+meets the *Cpp17Allocator* requirements ([[cpp17.allocator]]).
 *Effects:* Constructs a `shared_ptr` object that owns the object `p` and
 the deleter `d`. When `T` is not an array type, the first and second
 constructors enable `shared_from_this` with `p`. The second and fourth
 constructors shall use a copy of `a` to allocate memory for internal
 use. If an exception is thrown, `d(p)` is called.
+*Ensures:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
 ``` cpp
 template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
+template<class Y> shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
 ```
 *Effects:* Constructs a `shared_ptr` instance that stores `p` and shares
+ownership with the initial value of `r`.
+*Ensures:* `get() == p`. For the second overload, `r` is empty and
+`r.get() == nullptr`.
 [*Note 1*: To avoid the possibility of a dangling pointer, the user of
+this constructor should ensure that `p` remains valid at least until the
 ownership group of `r` is destroyed. — *end note*]
 [*Note 2*: This constructor allows creation of an empty `shared_ptr`
 instance with a non-null stored pointer. — *end note*]
 ``` cpp
 shared_ptr(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
 ```
+*Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* If `r` is empty, constructs an empty `shared_ptr` object;
 otherwise, constructs a `shared_ptr` object that shares ownership with
 `r`.
+*Ensures:* `get() == r.get() && use_count() == r.use_count()`.
 ``` cpp
 shared_ptr(shared_ptr&& r) noexcept;
 template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
 ```
+*Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `shared_ptr` instance from `r`.
+*Ensures:* `*this` shall contain the old value of `r`. `r` shall be
+empty. `r.get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
 ```
+*Constraints:* `Y*` is compatible with `T*`.
 *Effects:* Constructs a `shared_ptr` object that shares ownership with
 `r` and stores a copy of the pointer stored in `r`. If an exception is
 thrown, the constructor has no effect.
+*Ensures:* `use_count() == r.use_count()`.
 *Throws:* `bad_weak_ptr` when `r.expired()`.
 ``` cpp
 template<class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
 ```
+*Constraints:* `Y*` is compatible with `T*` and
+`unique_ptr<Y, D>::pointer` is convertible to `element_type*`.
 *Effects:* If `r.get() == nullptr`, equivalent to `shared_ptr()`.
 Otherwise, if `D` is not a reference type, equivalent to
 `shared_ptr(r.release(), r.get_deleter())`. Otherwise, equivalent to
 `shared_ptr(r.release(), ref(r.get_deleter()))`. If an exception is
 thrown, the constructor has no effect.
+#### Destructor <a id="util.smartptr.shared.dest">[[util.smartptr.shared.dest]]</a>
 ``` cpp
 ~shared_ptr();
 ```
 instances that share ownership with `*this` by one, after `*this` has
 been destroyed all `shared_ptr` instances that shared ownership with
 `*this` will report a `use_count()` that is one less than its previous
 value. — *end note*]
+#### Assignment <a id="util.smartptr.shared.assign">[[util.smartptr.shared.assign]]</a>
 ``` cpp
 shared_ptr& operator=(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(r).swap(*this)`.
 *Returns:* `*this`.
+[*Note 1*:
 The use count updates caused by the temporary object construction and
 destruction are not observable side effects, so the implementation may
 meet the effects (and the implied guarantees) via different means,
 without creating a temporary. In particular, in the example:
 *Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
+#### Modifiers <a id="util.smartptr.shared.mod">[[util.smartptr.shared.mod]]</a>
 ``` cpp
 void swap(shared_ptr& r) noexcept;
 ```
 template<class Y, class D, class A> void reset(Y* p, D d, A a);
 ```
 *Effects:* Equivalent to `shared_ptr(p, d, a).swap(*this)`.
+#### Observers <a id="util.smartptr.shared.obs">[[util.smartptr.shared.obs]]</a>
 ``` cpp
 element_type* get() const noexcept;
 ```
 ``` cpp
 T& operator*() const noexcept;
 ```
+*Preconditions:* `get() != 0`.
 *Returns:* `*get()`.
 *Remarks:* When `T` is an array type or cv `void`, it is unspecified
 whether this member function is declared. If it is declared, it is
 unspecified what its return type is, except that the declaration
+(although not necessarily the definition) of the function shall be
+well-formed.
 ``` cpp
 T* operator->() const noexcept;
 ```
+*Preconditions:* `get() != 0`.
 *Returns:* `get()`.
 *Remarks:* When `T` is an array type, it is unspecified whether this
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
+necessarily the definition) of the function shall be well-formed.
 ``` cpp
 element_type& operator[](ptrdiff_t i) const;
 ```
+*Preconditions:* `get() != 0 && i >= 0`. If `T` is `U[N]`, `i < N`.
 *Returns:* `get()[i]`.
 *Remarks:* When `T` is not an array type, it is unspecified whether this
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
+necessarily the definition) of the function shall be well-formed.
 *Throws:* Nothing.
 ``` cpp
 long use_count() const noexcept;
 *Returns:* The number of `shared_ptr` objects, `*this` included, that
 share ownership with `*this`, or `0` when `*this` is empty.
 *Synchronization:* None.
+[*Note 1*: `get() == nullptr` does not imply a specific return value of
 `use_count()`. — *end note*]
+[*Note 2*: `weak_ptr<T>::lock()` can affect the return value of
 `use_count()`. — *end note*]
+[*Note 3*: When multiple threads can affect the return value of
 `use_count()`, the result should be treated as approximate. In
 particular, `use_count() == 1` does not imply that accesses through a
 previously destroyed `shared_ptr` have in any sense
 completed. — *end note*]
 - under the equivalence relation defined by `owner_before`,
   `!a.owner_before(b) && !b.owner_before(a)`, two `shared_ptr` or
   `weak_ptr` instances are equivalent if and only if they share
   ownership or are both empty.
+#### Creation <a id="util.smartptr.shared.create">[[util.smartptr.shared.create]]</a>
+The common requirements that apply to all `make_shared`,
+`allocate_shared`, `make_shared_for_overwrite`, and
+`allocate_shared_for_overwrite` overloads, unless specified otherwise,
+are described below.
 ``` cpp
+template<class T, ...>
+  shared_ptr<T> make_shared(args);
+template<class T, class A, ...>
+  shared_ptr<T> allocate_shared(const A& a, args);
+template<class T, ...>
+  shared_ptr<T> make_shared_for_overwrite(args);
+template<class T, class A, ...>
+  shared_ptr<T> allocate_shared_for_overwrite(const A& a, args);
 ```
+*Preconditions:* `A` meets the *Cpp17Allocator* requirements
+([[cpp17.allocator]]).
+*Effects:* Allocates memory for an object of type `T` (or `U[N]` when
+`T` is `U[]`, where `N` is determined from *args* as specified by the
+concrete overload). The object is initialized from *args* as specified
+by the concrete overload. The `allocate_shared` and
+`allocate_shared_for_overwrite` templates use a copy of `a` (rebound for
+an unspecified `value_type`) to allocate memory. If an exception is
+thrown, the functions have no effect.
 *Returns:* A `shared_ptr` instance that stores and owns the address of
+the newly constructed object.
+*Ensures:* `r.get() != 0 && r.use_count() == 1`, where `r` is the return
+value.
+*Throws:* `bad_alloc`, or an exception thrown from `allocate` or from
+the initialization of the object.
+*Remarks:*
+- Implementations should perform no more than one memory allocation.
+  \[*Note 1*: This provides efficiency equivalent to an intrusive smart
   pointer. — *end note*]
+- When an object of an array type `U` is specified to have an initial
+  value of `u` (of the same type), this shall be interpreted to mean
+  that each array element of the object has as its initial value the
+  corresponding element from `u`.
+- When an object of an array type is specified to have a default initial
+  value, this shall be interpreted to mean that each array element of
+  the object has a default initial value.
+- When a (sub)object of a non-array type `U` is specified to have an
+  initial value of `v`, or `U(l...)`, where `l...` is a list of
+  constructor arguments, `make_shared` shall initialize this (sub)object
+  via the expression `::new(pv) U(v)` or `::new(pv) U(l...)`
+  respectively, where `pv` has type `void*` and points to storage
+  suitable to hold an object of type `U`.
+- When a (sub)object of a non-array type `U` is specified to have an
+  initial value of `v`, or `U(l...)`, where `l...` is a list of
+  constructor arguments, `allocate_shared` shall initialize this
+  (sub)object via the expression
+  - `allocator_traits<A2>::construct(a2, pv, v)` or
+  - `allocator_traits<A2>::construct(a2, pv, l...)`
+  respectively, where `pv` points to storage suitable to hold an object
+  of type `U` and `a2` of type `A2` is a rebound copy of the allocator
+  `a` passed to `allocate_shared` such that its `value_type` is
+  `remove_cv_t<U>`.
+- When a (sub)object of non-array type `U` is specified to have a
+  default initial value, `make_shared` shall initialize this (sub)object
+  via the expression `::new(pv) U()`, where `pv` has type `void*` and
+  points to storage suitable to hold an object of type `U`.
+- When a (sub)object of non-array type `U` is specified to have a
+  default initial value, `allocate_shared` shall initialize this
+  (sub)object via the expression
+  `allocator_traits<A2>::construct(a2, pv)`, where `pv` points to
+  storage suitable to hold an object of type `U` and `a2` of type `A2`
+  is a rebound copy of the allocator `a` passed to `allocate_shared`
+  such that its `value_type` is `remove_cv_t<U>`.
+- When a (sub)object of non-array type `U` is initialized by
+  `make_shared_for_overwrite` or `allocate_shared_for_overwrite`, it is
+  initialized via the expression `::new(pv) U`, where `pv` has type
+  `void*` and points to storage suitable to hold an object of type `U`.
+- Array elements are initialized in ascending order of their addresses.
+- When the lifetime of the object managed by the return value ends, or
+  when the initialization of an array element throws an exception, the
+  initialized elements are destroyed in the reverse order of their
+  original construction.
+- When a (sub)object of non-array type `U` that was initialized by
+  `make_shared` is to be destroyed, it is destroyed via the expression
+  `pv->~U()` where `pv` points to that object of type `U`.
+- When a (sub)object of non-array type `U` that was initialized by
+  `allocate_shared` is to be destroyed, it is destroyed via the
+  expression `allocator_traits<A2>::destroy(a2, pv)` where `pv` points
+  to that object of type `remove_cv_t<U>` and `a2` of type `A2` is a
+  rebound copy of the allocator `a` passed to `allocate_shared` such
+  that its `value_type` is `remove_cv_t<U>`.
+[*Note 1*: These functions will typically allocate more memory than
+`sizeof(T)` to allow for internal bookkeeping structures such as
 reference counts. — *end note*]
+``` cpp
+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
+```
+*Constraints:* `T` is not an array type.
+*Returns:* A `shared_ptr` to an object of type `T` with an initial value
+`T(forward<Args>(args)...)`.
+*Remarks:* The `shared_ptr` constructors called by these functions
+enable `shared_from_this` with the address of the newly constructed
+object of type `T`.
+[*Example 1*:
+``` cpp
+shared_ptr<int> p = make_shared<int>(); // shared_ptr to int()
+shared_ptr<vector<int>> q = make_shared<vector<int>>(16, 1);
+  // shared_ptr to vector of 16 elements with value 1
+```
+— *end example*]
+``` cpp
+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[]
+```
+*Constraints:* `T` is of the form `U[]`.
+*Returns:* A `shared_ptr` to an object of type `U[N]` with a default
+initial value, where `U` is `remove_extent_t<T>`.
+[*Example 2*:
+``` cpp
+shared_ptr<double[]> p = make_shared<double[]>(1024);
+  // shared_ptr to a value-initialized double[1024]
+shared_ptr<double[][2][2]> q = make_shared<double[][2][2]>(6);
+  // shared_ptr to a value-initialized double[6][2][2]
+```
+— *end example*]
+``` cpp
+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]
+```
+*Constraints:* `T` is of the form `U[N]`.
+*Returns:* A `shared_ptr` to an object of type `T` with a default
+initial value.
+[*Example 3*:
+``` cpp
+shared_ptr<double[1024]> p = make_shared<double[1024]>();
+  // shared_ptr to a value-initialized double[1024]
+shared_ptr<double[6][2][2]> q = make_shared<double[6][2][2]>();
+  // shared_ptr to a value-initialized double[6][2][2]
+```
+— *end example*]
+``` cpp
+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[]
+```
+*Constraints:* `T` is of the form `U[]`.
+*Returns:* A `shared_ptr` to an object of type `U[N]`, where `U` is
+`remove_extent_t<T>` and each array element has an initial value of `u`.
+[*Example 4*:
+``` cpp
+shared_ptr<double[]> p = make_shared<double[]>(1024, 1.0);
+  // shared_ptr to a double[1024], where each element is 1.0
+shared_ptr<double[][2]> q = make_shared<double[][2]>(6, {1.0, 0.0});
+  // shared_ptr to a double[6][2], where each double[2] element is {1.0, 0.0}
+shared_ptr<vector<int>[]> r = make_shared<vector<int>[]>(4, {1, 2});
+  // shared_ptr to a vector<int>[4], where each vector has contents {1, 2}
+```
+— *end example*]
+``` cpp
+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]
+```
+*Constraints:* `T` is of the form `U[N]`.
+*Returns:* A `shared_ptr` to an object of type `T`, where each array
+element of type `remove_extent_t<T>` has an initial value of `u`.
+[*Example 5*:
+``` cpp
+shared_ptr<double[1024]> p = make_shared<double[1024]>(1.0);
+  // shared_ptr to a double[1024], where each element is 1.0
+shared_ptr<double[6][2]> q = make_shared<double[6][2]>({1.0, 0.0});
+  // shared_ptr to a double[6][2], where each double[2] element is {1.0, 0.0}
+shared_ptr<vector<int>[4]> r = make_shared<vector<int>[4]>({1, 2});
+  // shared_ptr to a vector<int>[4], where each vector has contents {1, 2}
+```
+— *end example*]
+``` cpp
+template<class T>
+  shared_ptr<T> make_shared_for_overwrite();
+template<class T, class A>
+  shared_ptr<T> allocate_shared_for_overwrite(const A& a);
+```
+*Constraints:* `T` is not an array of unknown bound.
+*Returns:* A `shared_ptr` to an object of type `T`.
+[*Example 6*:
+``` cpp
+struct X { double data[1024]; };
+shared_ptr<X> p = make_shared_for_overwrite<X>();
+  // shared_ptr to a default-initialized X, where each element in X::data has an indeterminate value
+shared_ptr<double[1024]> q = make_shared_for_overwrite<double[1024]>();
+  // shared_ptr to a default-initialized double[1024], where each element has an indeterminate value
+```
+— *end example*]
+``` cpp
+template<class T>
+  shared_ptr<T> make_shared_for_overwrite(size_t N);
+template<class T, class A>
+  shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N);
+```
+*Constraints:* `T` is an array of unknown bound.
+*Returns:* A `shared_ptr` to an object of type `U[N]`, where `U` is
+`remove_extent_t<T>`.
+[*Example 7*:
+``` cpp
+shared_ptr<double[]> p = make_shared_for_overwrite<double[]>(1024);
+  // shared_ptr to a default-initialized double[1024], where each element has an indeterminate value
+```
+— *end example*]
+#### Comparison <a id="util.smartptr.shared.cmp">[[util.smartptr.shared.cmp]]</a>
 ``` cpp
 template<class T, class U>
   bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `a.get() == b.get()`.
 ``` cpp
 template<class T>
   bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
 ```
 *Returns:* `!a`.
 ``` cpp
+template<class T, class U>
+ strong_ordering operator<=>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
+*Returns:* `compare_three_way()(a.get(), b.get())`.
+[*Note 1*: Defining a comparison function allows `shared_ptr` objects
+to be used as keys in associative containers. — *end note*]
 ``` cpp
 template<class T>
+ strong_ordering operator<=>(const shared_ptr<T>& a, nullptr_t) noexcept;
 ```
+*Returns:* `compare_three_way()(a.get(), nullptr)`.
+#### Specialized algorithms <a id="util.smartptr.shared.spec">[[util.smartptr.shared.spec]]</a>
 ``` cpp
 template<class T>
   void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
+#### Casts <a id="util.smartptr.shared.cast">[[util.smartptr.shared.cast]]</a>
 ``` cpp
 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;
 ```
+*Mandates:* The expression `static_cast<T*>((U*)nullptr)` is
+well-formed.
 *Returns:*
 ``` cpp
+shared_ptr<T>(R, static_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
+where *`R`* is `r` for the first overload, and `std::move(r)` for the
+second.
+[*Note 1*: The seemingly equivalent expression
 `shared_ptr<T>(static_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 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;
 ```
+*Mandates:* The expression `dynamic_cast<T*>((U*)nullptr)` is
+well-formed. The expression
+`dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())` is well
+formed.
+*Preconditions:* The expression
+`dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())` has
+well-defined behavior.
 *Returns:*
 - When `dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())`
+  returns a non-null value `p`, `shared_ptr<T>(`*`R`*`, p)`, where *`R`*
+  is `r` for the first overload, and `std::move(r)` for the second.
 - Otherwise, `shared_ptr<T>()`.
+[*Note 2*: The seemingly equivalent expression
 `shared_ptr<T>(dynamic_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 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;
 ```
+*Mandates:* The expression `const_cast<T*>((U*)nullptr)` is well-formed.
 *Returns:*
 ``` cpp
+shared_ptr<T>(R, const_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
+where *`R`* is `r` for the first overload, and `std::move(r)` for the
+second.
+[*Note 3*: The seemingly equivalent expression
 `shared_ptr<T>(const_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 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;
 ```
+*Mandates:* The expression `reinterpret_cast<T*>((U*)nullptr)` is
+well-formed.
 *Returns:*
 ``` cpp
+shared_ptr<T>(R, reinterpret_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
+where *`R`* is `r` for the first overload, and `std::move(r)` for the
+second.
+[*Note 4*: The seemingly equivalent expression
 `shared_ptr<T>(reinterpret_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
+#### `get_deleter` <a id="util.smartptr.getdeleter">[[util.smartptr.getdeleter]]</a>
 ``` cpp
 template<class D, class T>
   D* get_deleter(const shared_ptr<T>& p) noexcept;
 ```
 *Returns:* If `p` owns a deleter `d` of type cv-unqualified `D`, returns
 `addressof(d)`; otherwise returns `nullptr`. The returned pointer
 remains valid as long as there exists a `shared_ptr` instance that owns
 `d`.
+[*Note 1*: It is unspecified whether the pointer remains valid longer
 than that. This can happen if the implementation doesn’t destroy the
 deleter until all `weak_ptr` instances that share ownership with `p`
 have been destroyed. — *end note*]
+#### I/O <a id="util.smartptr.shared.io">[[util.smartptr.shared.io]]</a>
 ``` cpp
 template<class E, class T, class Y>
   basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);
 ```
 *Effects:* As if by: `os << p.get();`
 *Returns:* `os`.
+### Class template `weak_ptr` <a id="util.smartptr.weak">[[util.smartptr.weak]]</a>
 The `weak_ptr` class template stores a weak reference to an object that
 is already managed by a `shared_ptr`. To access the object, a `weak_ptr`
 can be converted to a `shared_ptr` using the member function `lock`.
 ``` cpp
 namespace std {
   template<class T> class weak_ptr {
   public:
+    using element_type = remove_extent_t<T>;
     // [util.smartptr.weak.const], constructors
     constexpr weak_ptr() noexcept;
+    template<class Y>
+      weak_ptr(const shared_ptr<Y>& r) noexcept;
     weak_ptr(const weak_ptr& r) noexcept;
+    template<class Y>
+      weak_ptr(const weak_ptr<Y>& r) noexcept;
     weak_ptr(weak_ptr&& r) noexcept;
+    template<class Y>
+      weak_ptr(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.dest], destructor
     ~weak_ptr();
     // [util.smartptr.weak.assign], assignment
     weak_ptr& operator=(const weak_ptr& r) noexcept;
+    template<class Y>
+ weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
+    template<class Y>
+      weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
     weak_ptr& operator=(weak_ptr&& r) noexcept;
+    template<class Y>
+      weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.mod], modifiers
     void swap(weak_ptr& r) noexcept;
     void reset() noexcept;
     // [util.smartptr.weak.obs], observers
     long use_count() const noexcept;
     bool expired() const noexcept;
     shared_ptr<T> lock() const noexcept;
+    template<class U>
+ bool owner_before(const shared_ptr<U>& b) const noexcept;
+    template<class U>
+      bool owner_before(const weak_ptr<U>& b) const noexcept;
   };
+  template<class T>
+    weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
   // [util.smartptr.weak.spec], specialized algorithms
+  template<class T>
+    void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 }
 ```
+Specializations of `weak_ptr` shall be *Cpp17CopyConstructible* and
+*Cpp17CopyAssignable*, allowing their use in standard containers. The
 template parameter `T` of `weak_ptr` may be an incomplete type.
+#### Constructors <a id="util.smartptr.weak.const">[[util.smartptr.weak.const]]</a>
 ``` cpp
 constexpr weak_ptr() noexcept;
 ```
 *Effects:* Constructs an empty `weak_ptr` object.
+*Ensures:* `use_count() == 0`.
 ``` cpp
 weak_ptr(const weak_ptr& r) noexcept;
 template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
 template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
 ```
+*Constraints:* For the second and third constructors, `Y*` is compatible
+with `T*`.
 *Effects:* If `r` is empty, constructs an empty `weak_ptr` object;
 otherwise, constructs a `weak_ptr` object that shares ownership with `r`
 and stores a copy of the pointer stored in `r`.
+*Ensures:* `use_count() == r.use_count()`.
 ``` cpp
 weak_ptr(weak_ptr&& r) noexcept;
 template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
 ```
+*Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `weak_ptr` instance from `r`.
+*Ensures:* `*this` shall contain the old value of `r`. `r` shall be
+empty. `r.use_count() == 0`.
+#### Destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
 ``` cpp
 ~weak_ptr();
 ```
 *Effects:* Destroys this `weak_ptr` object but has no effect on the
 object its stored pointer points to.
+#### Assignment <a id="util.smartptr.weak.assign">[[util.smartptr.weak.assign]]</a>
 ``` cpp
 weak_ptr& operator=(const weak_ptr& r) noexcept;
 template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
 template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr(r).swap(*this)`.
 *Remarks:* The implementation may meet the effects (and the implied
+guarantees) via different means, without creating a temporary object.
 *Returns:* `*this`.
 ``` cpp
 weak_ptr& operator=(weak_ptr&& r) noexcept;
 *Effects:* Equivalent to `weak_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
+#### Modifiers <a id="util.smartptr.weak.mod">[[util.smartptr.weak.mod]]</a>
 ``` cpp
 void swap(weak_ptr& r) noexcept;
 ```
 void reset() noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr().swap(*this)`.
+#### Observers <a id="util.smartptr.weak.obs">[[util.smartptr.weak.obs]]</a>
 ``` cpp
 long use_count() const noexcept;
 ```
 *Returns:* `expired() ? shared_ptr<T>() : shared_ptr<T>(*this)`,
 executed atomically.
 ``` cpp
+template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
+template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
 ```
 *Returns:* An unspecified value such that
 - `x.owner_before(y)` defines a strict weak ordering as defined
 - under the equivalence relation defined by `owner_before`,
   `!a.owner_before(b) && !b.owner_before(a)`, two `shared_ptr` or
   `weak_ptr` instances are equivalent if and only if they share
   ownership or are both empty.
+#### Specialized algorithms <a id="util.smartptr.weak.spec">[[util.smartptr.weak.spec]]</a>
 ``` cpp
 template<class T>
   void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
+### Class template `owner_less` <a id="util.smartptr.ownerless">[[util.smartptr.ownerless]]</a>
 The class template `owner_less` allows ownership-based mixed comparisons
 of shared and weak pointers.
 ``` cpp
     using is_transparent = unspecified;
   };
 }
 ```
+`operator()(x, y)` returns `x.owner_before(y)`.
 [*Note 1*:
 Note that
   `weak_ptr` instances are equivalent if and only if they share
   ownership or are both empty.
 — *end note*]
+### Class template `enable_shared_from_this` <a id="util.smartptr.enab">[[util.smartptr.enab]]</a>
 A class `T` can inherit from `enable_shared_from_this<T>` to inherit the
 `shared_from_this` member functions that obtain a `shared_ptr` instance
 pointing to `*this`.
   protected:
     constexpr enable_shared_from_this() noexcept;
     enable_shared_from_this(const enable_shared_from_this&) noexcept;
     enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept;
     ~enable_shared_from_this();
   public:
     shared_ptr<T> shared_from_this();
     shared_ptr<T const> shared_from_this() const;
     weak_ptr<T> weak_from_this() noexcept;
     weak_ptr<T const> weak_from_this() const noexcept;
   private:
     mutable weak_ptr<T> weak_this;  // exposition only
   };
 }
 ```
 weak_ptr<T const> weak_from_this() const noexcept;
 ```
 *Returns:* `weak_this`.
+### Smart pointer hash support <a id="util.smartptr.hash">[[util.smartptr.hash]]</a>
 ``` cpp
 template<class T, class D> struct hash<unique_ptr<T, D>>;
 ```
 Letting `UP` be `unique_ptr<T,D>`, the specialization `hash<UP>` is
+enabled [[unord.hash]] if and only if `hash<typename UP::pointer>` is
 enabled. When enabled, for an object `p` of type `UP`, `hash<UP>()(p)`
+evaluates to the same value as `hash<typename UP::pointer>()(p.get())`.
+The member functions are not guaranteed to be `noexcept`.
 ``` cpp
 template<class T> struct hash<shared_ptr<T>>;
 ```
 For an object `p` of type `shared_ptr<T>`, `hash<shared_ptr<T>>()(p)`
+evaluates to the same value as
 `hash<typename shared_ptr<T>::element_type*>()(p.get())`.

Diff to HTML by rtfpessoa