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

Files changed (1) hide show

tmp/tmpl4azrdih/{from.md → to.md} +582 -211

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

@@ -1,8 +1,10 @@
 ## Smart pointers <a id="smartptr">[[smartptr]]</a>
-### Class template `unique_ptr` <a id="unique.ptr">[[unique.ptr]]</a>
 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
@@ -17,11 +19,11 @@ 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.
@@ -45,27 +47,27 @@ type.
 ``` cpp
 namespace std {
   template<class T> struct default_delete {
     constexpr default_delete() noexcept = default;
-    template<class U> default_delete(const default_delete<U>&) noexcept;
-    void operator()(T*) const;
   };
 }
 ```
 ``` 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`.
@@ -74,76 +76,78 @@ void operator()(T* ptr) const;
 ``` cpp
 namespace std {
   template<class T> struct default_delete<T[]> {
     constexpr default_delete() noexcept = default;
-    template<class U> default_delete(const default_delete<U[]>&) noexcept;
-    template<class U> void operator()(U* ptr) const;
   };
 }
 ```
 ``` 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 {
   public:
     using pointer      = see below;
     using element_type = T;
     using deleter_type = D;
     // [unique.ptr.single.ctor], constructors
     constexpr unique_ptr() noexcept;
-    explicit unique_ptr(pointer p) noexcept;
-    unique_ptr(pointer p, see below d1) noexcept;
-    unique_ptr(pointer p, see below d2) noexcept;
-    unique_ptr(unique_ptr&& u) noexcept;
     constexpr unique_ptr(nullptr_t) noexcept;
     template<class U, class E>
-      unique_ptr(unique_ptr<U, E>&& u) noexcept;
     // [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;
-    pointer get() const noexcept;
-    deleter_type& get_deleter() noexcept;
-    const deleter_type& get_deleter() const noexcept;
-    explicit operator bool() const noexcept;
     // [unique.ptr.single.modifiers], modifiers
-    pointer release() noexcept;
-    void reset(pointer p = pointer()) noexcept;
-    void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
     unique_ptr(const unique_ptr&) = delete;
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
@@ -167,46 +171,43 @@ 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
@@ -214,19 +215,16 @@ 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.
@@ -254,11 +252,11 @@ unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object comb
 ```
 — *end example*]
 ``` 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
@@ -278,11 +276,11 @@ 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`,
@@ -308,26 +306,25 @@ 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
@@ -338,16 +335,17 @@ 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`,
@@ -362,16 +360,16 @@ 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`.
@@ -379,128 +377,130 @@ unique_ptr& operator=(nullptr_t) noexcept;
 *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*]
 ``` cpp
-pointer get() const noexcept;
 ```
 *Returns:* The stored pointer.
 ``` cpp
-deleter_type& get_deleter() noexcept;
-const deleter_type& get_deleter() const noexcept;
 ```
 *Returns:* A reference to the stored deleter.
 ``` cpp
-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>
 ``` cpp
 namespace std {
   template<class T, class D> class unique_ptr<T[], D> {
   public:
     using pointer      = see below;
     using element_type = T;
     using deleter_type = D;
     // [unique.ptr.runtime.ctor], constructors
     constexpr unique_ptr() noexcept;
-    template<class U> explicit unique_ptr(U p) noexcept;
-    template<class U> unique_ptr(U p, see below d) noexcept;
-    template<class U> unique_ptr(U p, see below d) noexcept;
-    unique_ptr(unique_ptr&& u) noexcept;
     template<class U, class E>
-      unique_ptr(unique_ptr<U, E>&& u) noexcept;
     constexpr unique_ptr(nullptr_t) noexcept;
     // destructor
-    ~unique_ptr();
     // 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.runtime.observers], observers
-    T& operator[](size_t i) const;
-    pointer get() const noexcept;
-    deleter_type& get_deleter() noexcept;
-    const deleter_type& get_deleter() const noexcept;
-    explicit operator bool() const noexcept;
     // [unique.ptr.runtime.modifiers], modifiers
-    pointer release() noexcept;
-    template<class U> void reset(U p) noexcept;
-    void reset(nullptr_t = nullptr) noexcept;
-    void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
     unique_ptr(const unique_ptr&) = delete;
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
@@ -526,11 +526,11 @@ 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`.
@@ -539,12 +539,12 @@ template that takes a single parameter of type `pointer`.
 - `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(*)[]`.
 ``` cpp
-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.
@@ -554,11 +554,11 @@ template that take a parameter of type `pointer` and a second parameter.
 - `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>`:
@@ -574,11 +574,11 @@ This constructor behaves the same as in the primary template.
 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>`:
@@ -593,28 +593,28 @@ This operator behaves the same as in the primary template.
 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;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
 ``` cpp
-template<class U> void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
 template.
@@ -625,19 +625,19 @@ template.
   `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]())`.
@@ -647,19 +647,19 @@ 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])`.
@@ -671,20 +671,20 @@ template<class T, class... Args> unspecified make_unique_for_overwrite(Args&&...
 *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
@@ -742,20 +742,20 @@ template<class T1, class D1, class T2, class D2>
 *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.
@@ -772,46 +772,50 @@ 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>
-  bool operator>(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Returns:* The first function template returns `nullptr < x`. The second
 function template returns `x < nullptr`.
 ``` 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);
 ```
 *Returns:* The first function template returns `!(nullptr < x)`. The
 second function template returns `!(x < nullptr)`.
 ``` 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);
 ```
 *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>
@@ -822,11 +826,13 @@ template<class E, class T, class Y, class D>
 *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:
@@ -843,11 +849,13 @@ constructor taking a `weak_ptr`.
 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.
@@ -937,11 +945,11 @@ 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)) {
@@ -959,11 +967,11 @@ 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>*`
@@ -987,18 +995,18 @@ constexpr shared_ptr() noexcept;
 ``` 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`
@@ -1009,11 +1017,11 @@ 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);
@@ -1029,22 +1037,23 @@ well-formed expression. For the first two overloads:
 - 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;
 ```
@@ -1053,13 +1062,13 @@ template<class Y> shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
 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
@@ -1082,12 +1091,12 @@ 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);
 ```
@@ -1108,15 +1117,15 @@ 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();
 ```
@@ -1126,42 +1135,42 @@ thrown, the constructor has no effect.
   instance (`use_count() > 1`), there are no side effects.
 - Otherwise, if `*this` owns an object `p` and a deleter `d`, `d(p)` is
   called.
 - Otherwise, `*this` owns a pointer `p`, and `delete p` is called.
-[*Note 1*: Since the destruction of `*this` decreases the number of
 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:
 ``` cpp
 shared_ptr<int> p(new int);
 shared_ptr<void> q(p);
 p = p;
 q = p;
 ```
-both assignments may be no-ops.
 — *end note*]
 ``` cpp
 shared_ptr& operator=(shared_ptr&& r) noexcept;
@@ -1178,11 +1187,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`.
-#### Modifiers <a id="util.smartptr.shared.mod">[[util.smartptr.shared.mod]]</a>
 ``` cpp
 void swap(shared_ptr& r) noexcept;
 ```
@@ -1210,11 +1219,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)`.
-#### Observers <a id="util.smartptr.shared.obs">[[util.smartptr.shared.obs]]</a>
 ``` cpp
 element_type* get() const noexcept;
 ```
@@ -1222,11 +1231,11 @@ 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
@@ -1236,11 +1245,11 @@ 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
@@ -1249,47 +1258,47 @@ 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*]
 ``` cpp
 explicit operator bool() const noexcept;
 ```
-*Returns:* `get() != 0`.
 ``` 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;
 ```
@@ -1301,11 +1310,11 @@ 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.
-#### 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.
@@ -1319,34 +1328,34 @@ 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`.
@@ -1398,11 +1407,11 @@ the initialization of the object.
   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>
@@ -1412,11 +1421,11 @@ template<class T, class A, class... Args>
 ```
 *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`.
@@ -1572,11 +1581,11 @@ 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;
 ```
@@ -1595,30 +1604,34 @@ 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>
@@ -1635,11 +1648,11 @@ 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
@@ -1649,12 +1662,12 @@ 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.
@@ -1663,11 +1676,11 @@ well-defined behavior.
 - 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
@@ -1686,11 +1699,11 @@ 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
@@ -1710,16 +1723,16 @@ 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;
 ```
@@ -1727,27 +1740,29 @@ 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 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`.
@@ -1795,28 +1810,25 @@ namespace std {
       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;
@@ -1825,13 +1837,14 @@ 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;
@@ -1840,47 +1853,47 @@ 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;
 template<class Y> weak_ptr& operator=(weak_ptr<Y>&& 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;
 ```
@@ -1890,11 +1903,11 @@ 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;
 ```
@@ -1926,20 +1939,20 @@ 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.
-#### 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
@@ -1979,18 +1992,18 @@ namespace std {
 Note that
 - `operator()` defines a strict weak ordering as defined in
   [[alg.sorting]];
-- under the equivalence relation defined by `operator()`,
- `!operator()(a, b) && !operator()(b, a)`, two `shared_ptr` or
-  `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`.
@@ -2080,5 +2093,363 @@ 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())`.

 ## Smart pointers <a id="smartptr">[[smartptr]]</a>
+### Unique-ownership pointers <a id="unique.ptr">[[unique.ptr]]</a>
+#### General <a id="unique.ptr.general">[[unique.ptr.general]]</a>
 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
 *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 [[unique.ptr]] 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.
 ``` cpp
 namespace std {
   template<class T> struct default_delete {
     constexpr default_delete() noexcept = default;
+    template<class U> constexpr default_delete(const default_delete<U>&) noexcept;
+ constexpr void operator()(T*) const;
   };
 }
 ```
 ``` cpp
+template<class U> constexpr 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
+constexpr void operator()(T* ptr) const;
 ```
 *Mandates:* `T` is a complete type.
 *Effects:* Calls `delete` on `ptr`.
 ``` cpp
 namespace std {
   template<class T> struct default_delete<T[]> {
     constexpr default_delete() noexcept = default;
+    template<class U> constexpr default_delete(const default_delete<U[]>&) noexcept;
+    template<class U> constexpr void operator()(U* ptr) const;
   };
 }
 ```
 ``` cpp
+template<class U> constexpr 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> constexpr void operator()(U* ptr) const;
 ```
+*Constraints:* `U(*)[]` is convertible to `T(*)[]`.
 *Mandates:* `U` is a complete type.
 *Effects:* Calls `delete[]` on `ptr`.
 #### `unique_ptr` for single objects <a id="unique.ptr.single">[[unique.ptr.single]]</a>
+##### General <a id="unique.ptr.single.general">[[unique.ptr.single.general]]</a>
 ``` cpp
 namespace std {
   template<class T, class D = default_delete<T>> class unique_ptr {
   public:
     using pointer      = see below;
     using element_type = T;
     using deleter_type = D;
     // [unique.ptr.single.ctor], constructors
     constexpr unique_ptr() noexcept;
+ constexpr explicit unique_ptr(type_identity_t<pointer> p) noexcept;
+ constexpr unique_ptr(type_identity_t<pointer> p, see below d1) noexcept;
+ constexpr unique_ptr(type_identity_t<pointer> p, see below d2) noexcept;
+ constexpr unique_ptr(unique_ptr&& u) noexcept;
     constexpr unique_ptr(nullptr_t) noexcept;
     template<class U, class E>
+ constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;
     // [unique.ptr.single.dtor], destructor
+ constexpr ~unique_ptr();
     // [unique.ptr.single.asgn], assignment
+ constexpr unique_ptr& operator=(unique_ptr&& u) noexcept;
     template<class U, class E>
+ constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
+ constexpr unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.single.observers], observers
+ constexpr add_lvalue_reference_t<T> operator*() const noexcept(see below);
+ constexpr pointer operator->() const noexcept;
+ constexpr pointer get() const noexcept;
+ constexpr deleter_type& get_deleter() noexcept;
+ constexpr const deleter_type& get_deleter() const noexcept;
+ constexpr explicit operator bool() const noexcept;
     // [unique.ptr.single.modifiers], modifiers
+ constexpr pointer release() noexcept;
+ constexpr void reset(pointer p = pointer()) noexcept;
+ constexpr void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
     unique_ptr(const unique_ptr&) = delete;
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
 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`
+[[allocator.requirements.general]] 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;
 ```
+*Constraints:* `is_pointer_v<deleter_type>` is `false` and
+`is_default_constructible_v<deleter_type>` is `true`.
 *Preconditions:* `D` meets the *Cpp17DefaultConstructible* requirements
 ([[cpp17.defaultconstructible]]), and that construction does not throw
 an exception.
 *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
+constexpr explicit unique_ptr(type_identity_t<pointer> p) noexcept;
 ```
 *Constraints:* `is_pointer_v<deleter_type>` is `false` and
 `is_default_constructible_v<deleter_type>` is `true`.
 *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
 *Ensures:* `get() == p`. `get_deleter()` returns a reference to the
 stored deleter.
 ``` cpp
+constexpr unique_ptr(type_identity_t<pointer> p, const D& d) noexcept;
+constexpr unique_ptr(type_identity_t<pointer> p, remove_reference_t<D>&& d) noexcept;
 ```
 *Constraints:* `is_constructible_v<D, decltype(d)>` is `true`.
 *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.
 ```
 — *end example*]
 ``` cpp
+constexpr 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
 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> constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
 *Constraints:*
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
 to the stored deleter that was constructed from `u.get_deleter()`.
 ##### Destructor <a id="unique.ptr.single.dtor">[[unique.ptr.single.dtor]]</a>
 ``` cpp
+constexpr ~unique_ptr();
 ```
+*Effects:* Equivalent to: `if (get()) get_deleter()(get());`
 [*Note 3*: The use of `default_delete` requires `T` to be a complete
 type. — *end note*]
+*Remarks:* The behavior is undefined if the evaluation of
+`get_deleter()(get())` throws an exception.
 ##### Assignment <a id="unique.ptr.single.asgn">[[unique.ptr.single.asgn]]</a>
 ``` cpp
+constexpr 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
 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())`.
+*Ensures:* If `this != addressof(u)`, `u.get() == nullptr`, otherwise
+`u.get()` is unchanged.
 *Returns:* `*this`.
 ``` cpp
+template<class U, class E> constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 ```
 *Constraints:*
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
 exception.
 *Effects:* Calls `reset(u.release())` followed by
 `get_deleter() = std::forward<E>(u.get_deleter())`.
 *Ensures:* `u.get() == nullptr`.
+*Returns:* `*this`.
 ``` cpp
+constexpr 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
+constexpr add_lvalue_reference_t<T> operator*() const noexcept(noexcept(*declval<pointer>()));
 ```
 *Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
+constexpr 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*]
 ``` cpp
+constexpr pointer get() const noexcept;
 ```
 *Returns:* The stored pointer.
 ``` cpp
+constexpr deleter_type& get_deleter() noexcept;
+constexpr const deleter_type& get_deleter() const noexcept;
 ```
 *Returns:* A reference to the stored deleter.
 ``` cpp
+constexpr explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
 ##### Modifiers <a id="unique.ptr.single.modifiers">[[unique.ptr.single.modifiers]]</a>
 ``` cpp
+constexpr pointer release() noexcept;
 ```
 *Ensures:* `get() == nullptr`.
 *Returns:* The value `get()` had at the start of the call to `release`.
 ``` cpp
+constexpr void reset(pointer p = pointer()) noexcept;
 ```
+*Effects:* Assigns `p` to the stored pointer, and then, with the old
+value of the stored pointer, `old_p`, evaluates
+`if (old_p) get_deleter()(old_p);`
 [*Note 5*: The order of these operations is significant because the
+call to `get_deleter()` might 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*]
+*Remarks:* The behavior is undefined if the evaluation of
+`get_deleter()(old_p)` throws an exception.
 ``` cpp
+constexpr 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>
+##### General <a id="unique.ptr.runtime.general">[[unique.ptr.runtime.general]]</a>
 ``` cpp
 namespace std {
   template<class T, class D> class unique_ptr<T[], D> {
   public:
     using pointer      = see below;
     using element_type = T;
     using deleter_type = D;
     // [unique.ptr.runtime.ctor], constructors
     constexpr unique_ptr() noexcept;
+    template<class U> constexpr explicit unique_ptr(U p) noexcept;
+    template<class U> constexpr unique_ptr(U p, see below d) noexcept;
+    template<class U> constexpr unique_ptr(U p, see below d) noexcept;
+ constexpr unique_ptr(unique_ptr&& u) noexcept;
     template<class U, class E>
+ constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;
     constexpr unique_ptr(nullptr_t) noexcept;
     // destructor
+ constexpr ~unique_ptr();
     // assignment
+ constexpr unique_ptr& operator=(unique_ptr&& u) noexcept;
     template<class U, class E>
+ constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
+ constexpr unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.runtime.observers], observers
+ constexpr T& operator[](size_t i) const;
+ constexpr pointer get() const noexcept;
+ constexpr deleter_type& get_deleter() noexcept;
+ constexpr const deleter_type& get_deleter() const noexcept;
+ constexpr explicit operator bool() const noexcept;
     // [unique.ptr.runtime.modifiers], modifiers
+ constexpr pointer release() noexcept;
+    template<class U> constexpr void reset(U p) noexcept;
+ constexpr void reset(nullptr_t = nullptr) noexcept;
+ constexpr void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
     unique_ptr(const unique_ptr&) = delete;
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
 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> constexpr 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`.
 - `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(*)[]`.
 ``` cpp
+template<class U> constexpr unique_ptr(U p, see below d) noexcept;
+template<class U> constexpr 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.
 - `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> constexpr 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>`:
 primary template. — *end note*]
 ##### Assignment <a id="unique.ptr.runtime.asgn">[[unique.ptr.runtime.asgn]]</a>
 ``` cpp
+template<class U, class E> constexpr 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>`:
 primary template. — *end note*]
 ##### Observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
+constexpr 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
+constexpr void reset(nullptr_t p = nullptr) noexcept;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
 ``` cpp
+constexpr template<class U> void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
 template.
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 #### Creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
+template<class T, class... Args> constexpr 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> constexpr 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]())`.
 ```
 *Constraints:* `T` is an array of known bound.
 ``` cpp
+template<class T> constexpr unique_ptr<T> make_unique_for_overwrite();
 ```
 *Constraints:* `T` is not an array type.
 *Returns:* `unique_ptr<T>(new T)`.
 ``` cpp
+template<class T> constexpr 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])`.
 *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> constexpr 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>
+ constexpr bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `x.get() == y.get()`.
 ``` cpp
 *Returns:* `compare_three_way()(x.get(), y.get())`.
 ``` cpp
 template<class T, class D>
+ constexpr bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
 ```
 *Returns:* `!x`.
 ``` cpp
 template<class T, class D>
+ constexpr bool operator<(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
+ constexpr 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.
 less<unique_ptr<T, D>::pointer>()(nullptr, x.get())
 ```
 ``` cpp
 template<class T, class D>
+ constexpr bool operator>(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
+ constexpr bool operator>(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Returns:* The first function template returns `nullptr < x`. The second
 function template returns `x < nullptr`.
 ``` cpp
 template<class T, class D>
+ constexpr bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
+ constexpr bool operator<=(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Returns:* The first function template returns `!(nullptr < x)`. The
 second function template returns `!(x < nullptr)`.
 ``` cpp
 template<class T, class D>
+ constexpr bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
+ constexpr bool operator>=(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *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<typename unique_ptr<T, D>::pointer>
+ constexpr compare_three_way_result_t<typename unique_ptr<T, D>::pointer>
     operator<=>(const unique_ptr<T, D>& x, nullptr_t);
 ```
+*Returns:*
+``` cpp
+compare_three_way()(x.get(), static_cast<typename unique_ptr<T, D>::pointer>(nullptr)).
+```
 #### I/O <a id="unique.ptr.io">[[unique.ptr.io]]</a>
 ``` cpp
 template<class E, class T, class Y, class D>
 *Effects:* Equivalent to: `os << p.get();`
 *Returns:* `os`.
+### Shared-ownership pointers <a id="util.sharedptr">[[util.sharedptr]]</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:
 const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
+#### Class template `shared_ptr` <a id="util.smartptr.shared">[[util.smartptr.shared]]</a>
+##### General <a id="util.smartptr.shared.general">[[util.smartptr.shared.general]]</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.
 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` can be a function type. — *end note*]
 [*Example 1*:
 ``` cpp
 if (shared_ptr<X> px = dynamic_pointer_cast<X>(py)) {
 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>*`
 ``` cpp
 template<class Y> explicit shared_ptr(Y* p);
 ```
 *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*`.
+*Mandates:* `Y` is a complete type.
 *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`
 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 cannot 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);
 - 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 [[allocator.requirements.general]].
 *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 cannot 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;
 ```
 ownership with the initial value of `r`.
 *Ensures:* `get() == p`. For the second overload, `r` is empty and
 `r.get() == nullptr`.
+[*Note 1*: Use of this constructor leads to a dangling pointer unless
+`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
 *Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `shared_ptr` instance from `r`.
+*Ensures:* `*this` contains the old value of `r`. `r` is empty, and
+`r.get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(const weak_ptr<Y>& 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(), std::move(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();
 ```
   instance (`use_count() > 1`), there are no side effects.
 - Otherwise, if `*this` owns an object `p` and a deleter `d`, `d(p)` is
   called.
 - Otherwise, `*this` owns a pointer `p`, and `delete p` is called.
+[*Note 2*: Since the destruction of `*this` decreases the number of
 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 3*:
 The use count updates caused by the temporary object construction and
+destruction are not observable side effects, so the implementation can
 meet the effects (and the implied guarantees) via different means,
 without creating a temporary. In particular, in the example:
 ``` cpp
 shared_ptr<int> p(new int);
 shared_ptr<void> q(p);
 p = p;
 q = p;
 ```
+both assignments can be no-ops.
 — *end note*]
 ``` cpp
 shared_ptr& operator=(shared_ptr&& r) noexcept;
 *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() != nullptr`.
 *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
 ``` cpp
 T* operator->() const noexcept;
 ```
+*Preconditions:* `get() != nullptr`.
 *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
 ``` cpp
 element_type& operator[](ptrdiff_t i) const;
 ```
+*Preconditions:* `get() != nullptr && i >= 0`. If `T` is `U[N]`,
+`i < N`.
 *Returns:* `get()[i]`.
 *Throws:* Nothing.
+*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.
 ``` cpp
 long use_count() const noexcept;
 ```
+*Synchronization:* None.
 *Returns:* The number of `shared_ptr` objects, `*this` included, that
 share ownership with `*this`, or `0` when `*this` is empty.
+[*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 might affect the return value of
+`use_count()`, the result is approximate. In particular,
+`use_count() == 1` does not imply that accesses through a previously
+destroyed `shared_ptr` have in any sense completed. — *end note*]
 ``` cpp
 explicit operator bool() const noexcept;
 ```
+*Returns:* `get() != nullptr`.
 ``` 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;
 ```
 - 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.
   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 [[allocator.requirements.general]].
 *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.
+*Ensures:* `r.get() != nullptr && r.use_count() == 1`, where `r` is the
+return value.
 *Returns:* A `shared_ptr` instance that stores and owns the address of
 the newly constructed object.
 *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 3*: 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`.
   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 7*: 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>
 ```
 *Constraints:* `T` is not an array type.
 *Returns:* A `shared_ptr` to an object of type `T` with an initial value
+`T(std::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`.
   // 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;
 ```
   strong_ordering operator<=>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `compare_three_way()(a.get(), b.get())`.
+[*Note 8*: Defining a comparison operator 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:*
+``` cpp
+compare_three_way()(a.get(), static_cast<typename shared_ptr<T>::element_type*>(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>
 ```
 where *`R`* is `r` for the first overload, and `std::move(r)` for the
 second.
+[*Note 9*: 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
   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.
 - 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 10*: 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
 ```
 where *`R`* is `r` for the first overload, and `std::move(r)` for the
 second.
+[*Note 11*: 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
 ```
 where *`R`* is `r` for the first overload, and `std::move(r)` for the
 second.
+[*Note 12*: 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 13*: 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>
+##### General <a id="util.smartptr.weak.general">[[util.smartptr.weak.general]]</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`.
       bool owner_before(const weak_ptr<U>& b) const noexcept;
   };
   template<class T>
     weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
 }
 ```
 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 that stores a null
+pointer value.
 *Ensures:* `use_count() == 0`.
 ``` cpp
 weak_ptr(const weak_ptr& 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 that
+stores a null pointer value; 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;
 *Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `weak_ptr` instance from `r`.
+*Ensures:* `*this` contains the old value of `r`. `r` is empty, stores a
+null pointer value, and `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)`.
+*Returns:* `*this`.
 *Remarks:* The implementation may meet the effects (and the implied
 guarantees) via different means, without creating a temporary object.
 ``` cpp
 weak_ptr& operator=(weak_ptr&& r) noexcept;
 template<class Y> weak_ptr& operator=(weak_ptr<Y>&& 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;
 ```
 - 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
 Note that
 - `operator()` defines a strict weak ordering as defined in
   [[alg.sorting]];
+- two `shared_ptr` or `weak_ptr` instances are equivalent under the
+ equivalence relation defined by `operator()`,
+  `!operator()(a, b) && !operator()(b, a)`, 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`.
 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())`.
+### Smart pointer adaptors <a id="smartptr.adapt">[[smartptr.adapt]]</a>
+#### Class template `out_ptr_t` <a id="out.ptr.t">[[out.ptr.t]]</a>
+`out_ptr_t` is a class template used to adapt types such as smart
+pointers [[smartptr]] for functions that use output pointer parameters.
+[*Example 1*:
+``` cpp
+#include <memory>
+#include <cstdio>
+int fopen_s(std::FILE** f, const char* name, const char* mode);
+struct fclose_deleter {
+  void operator()(std::FILE* f) const noexcept {
+    std::fclose(f);
+  }
+};
+int main(int, char*[]) {
+  constexpr const char* file_name = "ow.o";
+  std::unique_ptr<std::FILE, fclose_deleter> file_ptr;
+  int err = fopen_s(std::out_ptr<std::FILE*>(file_ptr), file_name, "r+b");
+  if (err != 0)
+    return 1;
+  // *file_ptr is valid
+  return 0;
+}
+```
+`unique_ptr` can be used with `out_ptr` to be passed into an output
+pointer-style function, without needing to hold onto an intermediate
+pointer value and manually delete it on error or failure.
+— *end example*]
+``` cpp
+namespace std {
+  template<class Smart, class Pointer, class... Args>
+  class out_ptr_t {
+  public:
+    explicit out_ptr_t(Smart&, Args...);
+    out_ptr_t(const out_ptr_t&) = delete;
+    ~out_ptr_t();
+    operator Pointer*() const noexcept;
+    operator void**() const noexcept;
+  private:
+    Smart& s;                   // exposition only
+    tuple<Args...> a;           // exposition only
+    Pointer p;                  // exposition only
+  };
+}
+```
+`Pointer` shall meet the *Cpp17NullablePointer* requirements. If `Smart`
+is a specialization of `shared_ptr` and `sizeof...(Args) == 0`, the
+program is ill-formed.
+[*Note 1*: It is typically a user error to reset a `shared_ptr` without
+specifying a deleter, as `shared_ptr` will replace a custom deleter upon
+usage of `reset`, as specified in
+[[util.smartptr.shared.mod]]. — *end note*]
+Program-defined specializations of `out_ptr_t` that depend on at least
+one program-defined type need not meet the requirements for the primary
+template.
+Evaluations of the conversion functions on the same object may conflict
+[[intro.races]].
+``` cpp
+explicit out_ptr_t(Smart& smart, Args... args);
+```
+*Effects:* Initializes `s` with `smart`, `a` with
+`std::forward<Args>(args)...`, and value-initializes `p`. Then,
+equivalent to:
+- ``` cpp
+  s.reset();
+  ```
+  if the expression `s.reset()` is well-formed;
+- otherwise,
+  ``` cpp
+  s = Smart();
+  ```
+  if `is_constructible_v<Smart>` is `true`;
+- otherwise, the program is ill-formed.
+[*Note 1*: The constructor is not `noexcept` to allow for a variety of
+non-terminating and safe implementation strategies. For example, an
+implementation can allocate a `shared_ptr`’s internal node in the
+constructor and let implementation-defined exceptions escape safely. The
+destructor can then move the allocated control block in directly and
+avoid any other exceptions. — *end note*]
+``` cpp
+~out_ptr_t();
+```
+Let `SP` be *`POINTER_OF_OR`*`(Smart, Pointer)` [[memory.general]].
+*Effects:* Equivalent to:
+-
+  ``` cpp
+  if (p) {
+    apply([&](auto&&... args) {
+      s.reset(static_cast<SP>(p), std::forward<Args>(args)...); }, std::move(a));
+  }
+  ```
+  if the expression
+  `s.reset(static_cast<SP>(p), std::forward<Args>(args)...)` is
+  well-formed;
+- otherwise,
+  ``` cpp
+  if (p) {
+    apply([&](auto&&... args) {
+      s = Smart(static_cast<SP>(p), std::forward<Args>(args)...); }, std::move(a));
+  }
+  ```
+  if `is_constructible_v<Smart, SP, Args...>` is `true`;
+- otherwise, the program is ill-formed.
+``` cpp
+operator Pointer*() const noexcept;
+```
+*Preconditions:* `operator void**()` has not been called on `*this`.
+*Returns:* `addressof(const_cast<Pointer&>(p))`.
+``` cpp
+operator void**() const noexcept;
+```
+*Constraints:* `is_same_v<Pointer, void*>` is `false`.
+*Mandates:* `is_pointer_v<Pointer>` is `true`.
+*Preconditions:* `operator Pointer*()` has not been called on `*this`.
+*Returns:* A pointer value `v` such that:
+- the initial value `*v` is equivalent to `static_cast<void*>(p)` and
+- any modification of `*v` that is not followed by a subsequent
+  modification of `*this` affects the value of `p` during the
+  destruction of `*this`, such that `static_cast<void*>(p) == *v`.
+*Remarks:* Accessing `*v` outside the lifetime of `*this` has undefined
+behavior.
+[*Note 2*: `reinterpret_cast<void**>(static_cast<Pointer*>(*this))` can
+be a viable implementation strategy for some
+implementations. — *end note*]
+#### Function template `out_ptr` <a id="out.ptr">[[out.ptr]]</a>
+``` cpp
+template<class Pointer = void, class Smart, class... Args>
+  auto out_ptr(Smart& s, Args&&... args);
+```
+Let `P` be `Pointer` if `is_void_v<Pointer>` is `false`, otherwise
+*`POINTER_OF`*`(Smart)`.
+*Returns:*
+`out_ptr_t<Smart, P, Args&&...>(s, std::forward<Args>(args)...)`
+#### Class template `inout_ptr_t` <a id="inout.ptr.t">[[inout.ptr.t]]</a>
+`inout_ptr_t` is a class template used to adapt types such as smart
+pointers [[smartptr]] for functions that use output pointer parameters
+whose dereferenced values may first be deleted before being set to
+another allocated value.
+[*Example 1*:
+``` cpp
+#include <memory>
+struct star_fish* star_fish_alloc();
+int star_fish_populate(struct star_fish** ps, const char* description);
+struct star_fish_deleter {
+  void operator() (struct star_fish* c) const noexcept;
+};
+using star_fish_ptr = std::unique_ptr<star_fish, star_fish_deleter>;
+int main(int, char*[]) {
+  star_fish_ptr peach(star_fish_alloc());
+  // ...
+  // used, need to re-make
+  int err = star_fish_populate(std::inout_ptr(peach), "caring clown-fish liker");
+  return err;
+}
+```
+A `unique_ptr` can be used with `inout_ptr` to be passed into an output
+pointer-style function. The original value will be properly deleted
+according to the function it is used with and a new value reset in its
+place.
+— *end example*]
+``` cpp
+namespace std {
+  template<class Smart, class Pointer, class... Args>
+  class inout_ptr_t {
+  public:
+    explicit inout_ptr_t(Smart&, Args...);
+    inout_ptr_t(const inout_ptr_t&) = delete;
+    ~inout_ptr_t();
+    operator Pointer*() const noexcept;
+    operator void**() const noexcept;
+  private:
+    Smart& s;                   // exposition only
+    tuple<Args...> a;           // exposition only
+    Pointer p;                  // exposition only
+  };
+}
+```
+`Pointer` shall meet the *Cpp17NullablePointer* requirements. If `Smart`
+is a specialization of `shared_ptr`, the program is ill-formed.
+[*Note 1*: It is impossible to properly acquire unique ownership of the
+managed resource from a `shared_ptr` given its shared ownership
+model. — *end note*]
+Program-defined specializations of `inout_ptr_t` that depend on at least
+one program-defined type need not meet the requirements for the primary
+template.
+Evaluations of the conversion functions on the same object may conflict
+[[intro.races]].
+``` cpp
+explicit inout_ptr_t(Smart& smart, Args... args);
+```
+*Effects:* Initializes `s` with `smart`, `a` with
+`std::forward<Args>(args)...`, and `p` to either
+- `smart` if `is_pointer_v<Smart>` is `true`,
+- otherwise, `smart.get()`.
+*Remarks:* An implementation can call `s.release()`.
+[*Note 1*: The constructor is not `noexcept` to allow for a variety of
+non-terminating and safe implementation strategies. For example, an
+intrusive pointer implementation with a control block can allocate in
+the constructor and safely fail with an exception. — *end note*]
+``` cpp
+~inout_ptr_t();
+```
+Let `SP` be *`POINTER_OF_OR`*`(Smart, Pointer)` [[memory.general]].
+Let *release-statement* be `s.release();` if an implementation does not
+call `s.release()` in the constructor. Otherwise, it is empty.
+*Effects:* Equivalent to:
+-
+  ``` cpp
+  if (p) {
+    apply([&](auto&&... args) {
+      s = Smart( static_cast<SP>(p), std::forward<Args>(args)...); }, std::move(a));
+  }
+  ```
+  if `is_pointer_v<Smart>` is `true`;
+- otherwise,
+  ``` cpp
+  release-statement;
+  if (p) {
+    apply([&](auto&&... args) {
+      s.reset(static_cast<SP>(p), std::forward<Args>(args)...); }, std::move(a));
+  }
+  ```
+  if the expression
+  `s.reset(static_cast<SP>(p), std::forward<Args>(args)...)` is well-
+  formed;
+- otherwise,
+  ``` cpp
+  release-statement;
+  if (p) {
+    apply([&](auto&&... args) {
+      s = Smart(static_cast<SP>(p), std::forward<Args>(args)...); }, std::move(a));
+  }
+  ```
+  if `is_constructible_v<Smart, SP, Args...>` is `true`;
+- otherwise, the program is ill-formed.
+``` cpp
+operator Pointer*() const noexcept;
+```
+*Preconditions:* `operator void**()` has not been called on `*this`.
+*Returns:* `addressof(const_cast<Pointer&>(p))`.
+``` cpp
+operator void**() const noexcept;
+```
+*Constraints:* `is_same_v<Pointer, void*>` is `false`.
+*Mandates:* `is_pointer_v<Pointer>` is `true`.
+*Preconditions:* `operator Pointer*()` has not been called on `*this`.
+*Returns:* A pointer value `v` such that:
+- the initial value `*v` is equivalent to `static_cast<void*>(p)` and
+- any modification of `*v` that is not followed by subsequent
+  modification of `*this` affects the value of `p` during the
+  destruction of `*this`, such that `static_cast<void*>(p) == *v`.
+*Remarks:* Accessing `*v` outside the lifetime of `*this` has undefined
+behavior.
+[*Note 2*: `reinterpret_cast<void**>(static_cast<Pointer*>(*this))` can
+be a viable implementation strategy for some
+implementations. — *end note*]
+#### Function template `inout_ptr` <a id="inout.ptr">[[inout.ptr]]</a>
+``` cpp
+template<class Pointer = void, class Smart, class... Args>
+  auto inout_ptr(Smart& s, Args&&... args);
+```
+Let `P` be `Pointer` if `is_void_v<Pointer>` is `false`, otherwise
+*`POINTER_OF`*`(Smart)`.
+*Returns:*
+`inout_ptr_t<Smart, P, Args&&...>(s, std::forward<Args>(args)...)`.

Diff to HTML by rtfpessoa