[smartptr] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp2vi9brs0/{from.md → to.md} +360 -244

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

@@ -33,11 +33,11 @@ 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
 (destruction policy) for the class template `unique_ptr`.
 The template parameter `T` of `default_delete` may be an incomplete
@@ -152,10 +152,16 @@ namespace std {
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
 }
 ```
 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)`
@@ -380,11 +386,15 @@ constexpr unique_ptr& operator=(nullptr_t) noexcept;
 ``` cpp
 constexpr add_lvalue_reference_t<T> operator*() const noexcept(noexcept(*declval<pointer>()));
 ```
-*Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
 constexpr pointer operator->() const noexcept;
@@ -610,11 +620,11 @@ 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.
@@ -687,11 +697,11 @@ template<class T1, class D1, class T2, class D2>
 *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
@@ -710,34 +720,34 @@ 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())`.
@@ -835,20 +845,20 @@ template<class E, class T, class Y, class D>
 ``` 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>
@@ -870,68 +880,73 @@ namespace std {
     // [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>
@@ -963,13 +978,13 @@ 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 [[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
@@ -977,26 +992,26 @@ 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);
 ```
 *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
@@ -1020,14 +1035,14 @@ not an array type, `delete[] p` otherwise.
 *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);
-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:
@@ -1052,12 +1067,12 @@ use. If an exception is thrown, `d(p)` is called.
 *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;
 ```
 *Effects:* Constructs a `shared_ptr` instance that stores `p` and shares
 ownership with the initial value of `r`.
@@ -1070,12 +1085,12 @@ 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;
@@ -1083,23 +1098,23 @@ 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` 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*`.
 *Effects:* Constructs a `shared_ptr` object that shares ownership with
@@ -1109,11 +1124,11 @@ 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*`.
@@ -1124,11 +1139,11 @@ 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();
 ```
 *Effects:*
 - If `*this` is empty or shares ownership with another `shared_ptr`
@@ -1144,12 +1159,12 @@ been destroyed all `shared_ptr` instances that shared ownership with
 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`.
@@ -1171,68 +1186,68 @@ q = p;
 both assignments can be no-ops.
 — *end note*]
 ``` cpp
-shared_ptr& operator=(shared_ptr&& r) noexcept;
-template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
 ``` cpp
-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;
 ```
 *Effects:* Exchanges the contents of `*this` and `r`.
 ``` cpp
-void reset() noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr().swap(*this)`.
 ``` cpp
-template<class Y> void reset(Y* p);
 ```
 *Effects:* Equivalent to `shared_ptr(p).swap(*this)`.
 ``` cpp
-template<class Y, class D> void reset(Y* p, D d);
 ```
 *Effects:* Equivalent to `shared_ptr(p, d).swap(*this)`.
 ``` cpp
-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;
 ```
 *Returns:* The stored pointer.
 ``` cpp
-T& operator*() const noexcept;
 ```
 *Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
@@ -1242,11 +1257,11 @@ 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() != nullptr`.
 *Returns:* `get()`.
@@ -1255,15 +1270,16 @@ T* operator->() const noexcept;
 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() != nullptr && i >= 0`. If `T` is `U[N]`,
-`i < N`.
 *Returns:* `get()[i]`.
 *Throws:* Nothing.
@@ -1271,11 +1287,11 @@ element_type& operator[](ptrdiff_t i) const;
 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
@@ -1291,45 +1307,62 @@ share ownership with `*this`, or `0` when `*this` is empty.
 `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;
 ```
 *Returns:* An unspecified value such that
-- `x.owner_before(y)` defines a strict weak ordering as defined
   in  [[alg.sorting]];
-- 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 [[allocator.requirements.general]].
@@ -1370,56 +1403,58 @@ the initialization of the object.
   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 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>
-  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
@@ -1438,14 +1473,14 @@ shared_ptr<vector<int>> q = make_shared<vector<int>>(16, 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
@@ -1462,13 +1497,13 @@ shared_ptr<double[][2][2]> q = make_shared<double[][2][2]>(6);
 — *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
@@ -1485,14 +1520,14 @@ shared_ptr<double[6][2][2]> q = make_shared<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[]`.
@@ -1512,13 +1547,13 @@ shared_ptr<vector<int>[]> r = make_shared<vector<int>[]>(4, {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]`.
@@ -1538,13 +1573,13 @@ shared_ptr<vector<int>[4]> r = make_shared<vector<int>[4]>({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`.
@@ -1562,13 +1597,13 @@ shared_ptr<double[1024]> q = make_shared_for_overwrite<double[1024]>();
 — *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
@@ -1585,59 +1620,59 @@ shared_ptr<double[]> p = make_shared_for_overwrite<double[]>(1024);
 ##### 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 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>
-  shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
 *Mandates:* The expression `static_cast<T*>((U*)nullptr)` is
 well-formed.
@@ -1649,19 +1684,18 @@ 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 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
 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
@@ -1677,19 +1711,18 @@ well-defined behavior.
   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
 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:*
@@ -1700,13 +1733,12 @@ 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 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
 template<class T, class U>
   shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
@@ -1724,19 +1756,18 @@ 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 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
@@ -1773,43 +1804,48 @@ namespace std {
     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>;
 }
@@ -1829,13 +1865,13 @@ constexpr weak_ptr() noexcept;
 pointer value.
 *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*`.
@@ -1845,12 +1881,12 @@ 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`.
@@ -1859,95 +1895,112 @@ template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
 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;
 ```
 *Effects:* Exchanges the contents of `*this` and `r`.
 ``` cpp
-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:* `0` if `*this` is empty; otherwise, the number of
 `shared_ptr` instances that share ownership with `*this`.
 ``` cpp
-bool expired() const noexcept;
 ```
 *Returns:* `use_count() == 0`.
 ``` cpp
-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 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
   in  [[alg.sorting]];
-- 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>
@@ -1958,30 +2011,30 @@ of shared and weak pointers.
 ``` cpp
 namespace std {
   template<class T = void> struct owner_less;
   template<class T> struct owner_less<shared_ptr<T>> {
-    bool operator()(const shared_ptr<T>&, const shared_ptr<T>&) const noexcept;
-    bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
-    bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
   };
   template<class T> struct owner_less<weak_ptr<T>> {
-    bool operator()(const weak_ptr<T>&, const weak_ptr<T>&) const noexcept;
-    bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
-    bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
   };
   template<> struct owner_less<void> {
     template<class T, class U>
-      bool operator()(const shared_ptr<T>&, const shared_ptr<U>&) const noexcept;
     template<class T, class U>
-      bool operator()(const shared_ptr<T>&, const weak_ptr<U>&) const noexcept;
     template<class T, class U>
-      bool operator()(const weak_ptr<T>&, const shared_ptr<U>&) const noexcept;
     template<class T, class U>
-      bool operator()(const weak_ptr<T>&, const weak_ptr<U>&) const noexcept;
     using is_transparent = unspecified;
   };
 }
 ```
@@ -1992,17 +2045,83 @@ namespace std {
 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`.
@@ -2014,68 +2133,68 @@ struct X: public enable_shared_from_this<X> { };
 int main() {
   shared_ptr<X> p(new X);
   shared_ptr<X> q = p->shared_from_this();
   assert(p == q);
-  assert(!p.owner_before(q) && !q.owner_before(p)); // p and q share ownership
 }
 ```
 — *end example*]
 ``` cpp
 namespace std {
   template<class T> class enable_shared_from_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
   };
 }
 ```
 The template parameter `T` of `enable_shared_from_this` may be an
 incomplete type.
 ``` cpp
 constexpr enable_shared_from_this() noexcept;
-enable_shared_from_this(const enable_shared_from_this<T>&) noexcept;
 ```
-*Effects:* Value-initializes `weak_this`.
 ``` cpp
-enable_shared_from_this<T>& operator=(const enable_shared_from_this<T>&) noexcept;
 ```
 *Returns:* `*this`.
-[*Note 1*: `weak_this` is not changed. — *end note*]
 ``` cpp
-shared_ptr<T>       shared_from_this();
-shared_ptr<T const> shared_from_this() const;
 ```
-*Returns:* `shared_ptr<T>(weak_this)`.
 ``` cpp
-weak_ptr<T>       weak_from_this() noexcept;
-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>>;
@@ -2136,16 +2255,16 @@ pointer value and manually delete it on error or failure.
 ``` 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
@@ -2169,41 +2288,40 @@ 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:
@@ -2229,11 +2347,11 @@ Let `SP` be *`POINTER_OF_OR`*`(Smart, Pointer)` [[memory.general]].
   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))`.
@@ -2264,18 +2382,18 @@ 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
@@ -2315,16 +2433,16 @@ place.
 ``` 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
@@ -2346,11 +2464,11 @@ 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
@@ -2363,11 +2481,11 @@ explicit inout_ptr_t(Smart& smart, Args... args);
 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
@@ -2375,14 +2493,12 @@ 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
@@ -2407,11 +2523,11 @@ call `s.release()` in the constructor. Otherwise, it is empty.
   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))`.
@@ -2442,11 +2558,11 @@ 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)`.

 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>
+##### General <a id="unique.ptr.dltr.general">[[unique.ptr.dltr.general]]</a>
 The class template `default_delete` serves as the default deleter
 (destruction policy) for the class template `unique_ptr`.
 The template parameter `T` of `default_delete` may be an incomplete
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
 }
 ```
+A program that instantiates the definition of `unique_ptr<T, D>` is
+ill-formed if `T*` is an invalid type.
+[*Note 1*: This prevents the instantiation of specializations such as
+`unique_ptr<T&, D>` and `unique_ptr<int() const, D>`. — *end note*]
 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)`
 ``` cpp
 constexpr add_lvalue_reference_t<T> operator*() const noexcept(noexcept(*declval<pointer>()));
 ```
+*Mandates:*
+`reference_converts_from_temporary_v<add_lvalue_reference_t<T>, decltype(*declval<pointer>())>`
+is `false`.
+*Preconditions:* `get() != nullptr` is `true`.
 *Returns:* `*get()`.
 ``` cpp
 constexpr pointer operator->() const noexcept;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
 ``` cpp
+template<class U> constexpr void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
 template.
 *Returns:* `x.get() == y.get()`.
 ``` 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);
 ```
 Let `CT` denote
 ``` cpp
 *Returns:* `less<CT>()(x.get(), y.get())`.
 ``` 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:* `y < x`.
 ``` 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:* `!(y < x)`.
 ``` 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 < 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>
+ constexpr 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
 namespace std {
   class bad_weak_ptr : public exception {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr 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
+constexpr const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 #### Class template `shared_ptr` <a id="util.smartptr.shared">[[util.smartptr.shared]]</a>
     // [util.smartptr.shared.const], constructors
     constexpr shared_ptr() noexcept;
     constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
     template<class Y>
+ constexpr explicit shared_ptr(Y* p);
     template<class Y, class D>
+ constexpr shared_ptr(Y* p, D d);
     template<class Y, class D, class A>
+ constexpr shared_ptr(Y* p, D d, A a);
     template<class D>
+ constexpr shared_ptr(nullptr_t p, D d);
     template<class D, class A>
+ constexpr shared_ptr(nullptr_t p, D d, A a);
     template<class Y>
+ constexpr shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
     template<class Y>
+ constexpr shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
+ constexpr shared_ptr(const shared_ptr& r) noexcept;
     template<class Y>
+ constexpr shared_ptr(const shared_ptr<Y>& r) noexcept;
+ constexpr shared_ptr(shared_ptr&& r) noexcept;
     template<class Y>
+ constexpr shared_ptr(shared_ptr<Y>&& r) noexcept;
     template<class Y>
+ constexpr explicit shared_ptr(const weak_ptr<Y>& r);
     template<class Y, class D>
+ constexpr shared_ptr(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.dest], destructor
+ constexpr ~shared_ptr();
     // [util.smartptr.shared.assign], assignment
+ constexpr shared_ptr& operator=(const shared_ptr& r) noexcept;
     template<class Y>
+ constexpr shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
+ constexpr shared_ptr& operator=(shared_ptr&& r) noexcept;
     template<class Y>
+ constexpr shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
     template<class Y, class D>
+ constexpr shared_ptr& operator=(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.mod], modifiers
+ constexpr void swap(shared_ptr& r) noexcept;
+ constexpr void reset() noexcept;
     template<class Y>
+ constexpr void reset(Y* p);
     template<class Y, class D>
+ constexpr void reset(Y* p, D d);
     template<class Y, class D, class A>
+ constexpr void reset(Y* p, D d, A a);
     // [util.smartptr.shared.obs], observers
+ constexpr element_type* get() const noexcept;
+ constexpr T& operator*() const noexcept;
+ constexpr T* operator->() const noexcept;
+ constexpr element_type& operator[](ptrdiff_t i) const;
+ constexpr long use_count() const noexcept;
+ constexpr explicit operator bool() const noexcept;
     template<class U>
+ constexpr bool owner_before(const shared_ptr<U>& b) const noexcept;
     template<class U>
+ constexpr bool owner_before(const weak_ptr<U>& b) const noexcept;
+    size_t owner_hash() const noexcept;
+    template<class U>
+      constexpr bool owner_equal(const shared_ptr<U>& b) const noexcept;
+    template<class U>
+      constexpr bool owner_equal(const weak_ptr<U>& b) const noexcept;
   };
   template<class T>
     shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
   template<class T, class D>
 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 [[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
 `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> constexpr 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
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory cannot be obtained.
 ``` cpp
+template<class Y, class D> constexpr shared_ptr(Y* p, D d);
+template<class Y, class D, class A> constexpr shared_ptr(Y* p, D d, A a);
+template<class D> constexpr shared_ptr(nullptr_t p, D d);
+template<class D, class A> constexpr 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:
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory cannot be obtained.
 ``` cpp
+template<class Y> constexpr shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
+template<class Y> constexpr 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`.
 [*Note 2*: This constructor allows creation of an empty `shared_ptr`
 instance with a non-null stored pointer. — *end note*]
 ``` cpp
+constexpr shared_ptr(const shared_ptr& r) noexcept;
+template<class Y> constexpr 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;
 `r`.
 *Ensures:* `get() == r.get() && use_count() == r.use_count()`.
 ``` cpp
+constexpr shared_ptr(shared_ptr&& r) noexcept;
+template<class Y> constexpr 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` contains the old value of `r`. `r` is empty, and
 `r.get() == nullptr`.
 ``` cpp
+template<class Y> constexpr explicit shared_ptr(const weak_ptr<Y>& r);
 ```
 *Constraints:* `Y*` is compatible with `T*`.
 *Effects:* Constructs a `shared_ptr` object that shares ownership with
 *Ensures:* `use_count() == r.use_count()`.
 *Throws:* `bad_weak_ptr` when `r.expired()`.
 ``` cpp
+template<class Y, class D> constexpr shared_ptr(unique_ptr<Y, D>&& r);
 ```
 *Constraints:* `Y*` is compatible with `T*` and
 `unique_ptr<Y, D>::pointer` is convertible to `element_type*`.
 exception is thrown, the constructor has no effect.
 ##### Destructor <a id="util.smartptr.shared.dest">[[util.smartptr.shared.dest]]</a>
 ``` cpp
+constexpr ~shared_ptr();
 ```
 *Effects:*
 - If `*this` is empty or shares ownership with another `shared_ptr`
 value. — *end note*]
 ##### Assignment <a id="util.smartptr.shared.assign">[[util.smartptr.shared.assign]]</a>
 ``` cpp
+constexpr shared_ptr& operator=(const shared_ptr& r) noexcept;
+template<class Y> constexpr shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(r).swap(*this)`.
 *Returns:* `*this`.
 both assignments can be no-ops.
 — *end note*]
 ``` cpp
+constexpr shared_ptr& operator=(shared_ptr&& r) noexcept;
+template<class Y> constexpr shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
 ``` cpp
+template<class Y, class D> constexpr 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
+constexpr void swap(shared_ptr& r) noexcept;
 ```
 *Effects:* Exchanges the contents of `*this` and `r`.
 ``` cpp
+constexpr void reset() noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr().swap(*this)`.
 ``` cpp
+template<class Y> constexpr void reset(Y* p);
 ```
 *Effects:* Equivalent to `shared_ptr(p).swap(*this)`.
 ``` cpp
+template<class Y, class D> constexpr void reset(Y* p, D d);
 ```
 *Effects:* Equivalent to `shared_ptr(p, d).swap(*this)`.
 ``` cpp
+template<class Y, class D, class A> constexpr 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
+constexpr element_type* get() const noexcept;
 ```
 *Returns:* The stored pointer.
 ``` cpp
+constexpr T& operator*() const noexcept;
 ```
 *Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
 unspecified what its return type is, except that the declaration
 (although not necessarily the definition) of the function shall be
 well-formed.
 ``` cpp
+constexpr T* operator->() const noexcept;
 ```
 *Preconditions:* `get() != nullptr`.
 *Returns:* `get()`.
 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
+constexpr element_type& operator[](ptrdiff_t i) const;
 ```
+*Preconditions:* `get() != nullptr` is `true`.
+`i` ≥ 0. If `T` is `U[N]`, `i` < `N`.
 *Returns:* `get()[i]`.
 *Throws:* Nothing.
 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
+constexpr long use_count() const noexcept;
 ```
 *Synchronization:* None.
 *Returns:* The number of `shared_ptr` objects, `*this` included, that
 `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
+constexpr explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
 ``` cpp
+template<class U> constexpr bool owner_before(const shared_ptr<U>& b) const noexcept;
+template<class U> constexpr bool owner_before(const weak_ptr<U>& b) const noexcept;
 ```
 *Returns:* An unspecified value such that
+- `owner_before(b)` defines a strict weak ordering as defined
   in  [[alg.sorting]];
+- `!owner_before(b) && !b.owner_before(*this)` is `true` if and only if
+  `owner_equal(b)` is `true`.
+``` cpp
+size_t owner_hash() const noexcept;
+```
+*Returns:* An unspecified value such that, for any object `x` where
+`owner_equal(x)` is `true`, `owner_hash() == x.owner_hash()` is `true`.
+``` cpp
+template<class U>
+  constexpr bool owner_equal(const shared_ptr<U>& b) const noexcept;
+template<class U>
+  constexpr bool owner_equal(const weak_ptr<U>& b) const noexcept;
+```
+*Returns:* `true` if and only if `*this` and `b` share ownership or are
+both empty. Otherwise returns `false`.
+*Remarks:* `owner_equal` is an equivalence relation.
 ##### 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, ...>
+ constexpr shared_ptr<T> make_shared(args);
 template<class T, class A, ...>
+ constexpr shared_ptr<T> allocate_shared(const A& a, args);
 template<class T, ...>
+ constexpr shared_ptr<T> make_shared_for_overwrite(args);
 template<class T, class A, ...>
+ constexpr shared_ptr<T> allocate_shared_for_overwrite(const A& a, args);
 ```
 *Preconditions:* `A` meets the *Cpp17Allocator*
 requirements [[allocator.requirements.general]].
   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, pu, v)` or
+  - `allocator_traits<A2>::construct(a2, pu, l...)`
+  respectively, where `pu` is a pointer of type `remove_cv_t<U>*`
+ pointing to storage suitable to hold an object of type
+  `remove_cv_t<U>` and `a2` of type `A2` is a potentially rebound copy
+ of the allocator `a` passed to `allocate_shared`.
 - 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` initializes this (sub)object
+  via the expression `allocator_traits<A2>::construct(a2, pu)`, where
+  `pu` is a pointer of type `remove_cv_t<U>*` pointing to storage
+  suitable to hold an object of type `remove_cv_t<U>` and `a2` of type
+ `A2` is a potentially rebound copy of the allocator `a` passed to
+  `allocate_shared`.
 - 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`, `make_shared_for_overwrite`, or
+  `allocate_shared_for_overwrite` is to be destroyed, it is destroyed
+  via the expression `pu->~U()` where `pu` 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, pu)` where `pu` is a
+ pointer of type `remove_cv_t<U>*` pointing to that object of type
+ `remove_cv_t<U>` and `a2` of type `A2` is a potentially rebound copy
+ of the allocator `a` passed to `allocate_shared`.
 [*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>
+ constexpr shared_ptr<T> make_shared(Args&&... args);                    // T is not array
 template<class T, class A, class... Args>
+ constexpr 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
 ```
 — *end example*]
 ``` cpp
+template<class T>
+ constexpr shared_ptr<T> make_shared(size_t N); // T is U[]
 template<class T, class A>
+ constexpr 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
 — *end example*]
 ``` cpp
 template<class T>
+ constexpr shared_ptr<T> make_shared();                                  // T is U[N]
 template<class T, class A>
+ constexpr 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
 — *end example*]
 ``` cpp
 template<class T>
+ constexpr shared_ptr<T> make_shared(size_t N,
                                       const remove_extent_t<T>& u);     // T is U[]
 template<class T, class A>
+ constexpr 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[]`.
 — *end example*]
 ``` cpp
 template<class T>
+ constexpr shared_ptr<T> make_shared(const remove_extent_t<T>& u);       // T is U[N]
 template<class T, class A>
+ constexpr 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]`.
 — *end example*]
 ``` cpp
 template<class T>
+ constexpr shared_ptr<T> make_shared_for_overwrite();
 template<class T, class A>
+ constexpr 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`.
 — *end example*]
 ``` cpp
 template<class T>
+ constexpr shared_ptr<T> make_shared_for_overwrite(size_t N);
 template<class T, class A>
+ constexpr 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
 ##### Comparison <a id="util.smartptr.shared.cmp">[[util.smartptr.shared.cmp]]</a>
 ``` cpp
 template<class T, class U>
+ constexpr bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `a.get() == b.get()`.
 ``` cpp
 template<class T>
+ constexpr bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
 ```
 *Returns:* `!a`.
 ``` cpp
 template<class T, class U>
+ constexpr 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>
+ constexpr 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>
+ constexpr 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>
+ constexpr shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
+ constexpr shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
 *Mandates:* The expression `static_cast<T*>((U*)nullptr)` is
 well-formed.
 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()))` can result in undefined
+behavior, attempting to delete the same object twice. — *end note*]
 ``` cpp
 template<class T, class U>
+ constexpr shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
+ constexpr 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
   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()))` can result in undefined
+behavior, attempting to delete the same object twice. — *end note*]
 ``` cpp
 template<class T, class U>
+ constexpr shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
 template<class T, class U>
+ constexpr shared_ptr<T> const_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
 *Mandates:* The expression `const_cast<T*>((U*)nullptr)` is well-formed.
 *Returns:*
 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()))` can 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>
 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()))` can 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>
+ constexpr 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
     using element_type = remove_extent_t<T>;
     // [util.smartptr.weak.const], constructors
     constexpr weak_ptr() noexcept;
     template<class Y>
+ constexpr weak_ptr(const shared_ptr<Y>& r) noexcept;
+ constexpr weak_ptr(const weak_ptr& r) noexcept;
     template<class Y>
+ constexpr weak_ptr(const weak_ptr<Y>& r) noexcept;
+ constexpr weak_ptr(weak_ptr&& r) noexcept;
     template<class Y>
+ constexpr weak_ptr(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.dest], destructor
+ constexpr ~weak_ptr();
     // [util.smartptr.weak.assign], assignment
+ constexpr weak_ptr& operator=(const weak_ptr& r) noexcept;
     template<class Y>
+ constexpr weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
     template<class Y>
+ constexpr weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
+ constexpr weak_ptr& operator=(weak_ptr&& r) noexcept;
     template<class Y>
+ constexpr weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.mod], modifiers
+ constexpr void swap(weak_ptr& r) noexcept;
+ constexpr void reset() noexcept;
     // [util.smartptr.weak.obs], observers
+ constexpr long use_count() const noexcept;
+ constexpr bool expired() const noexcept;
+ constexpr shared_ptr<T> lock() const noexcept;
     template<class U>
+ constexpr bool owner_before(const shared_ptr<U>& b) const noexcept;
     template<class U>
+ constexpr bool owner_before(const weak_ptr<U>& b) const noexcept;
+    size_t owner_hash() const noexcept;
+    template<class U>
+      constexpr bool owner_equal(const shared_ptr<U>& b) const noexcept;
+    template<class U>
+      constexpr bool owner_equal(const weak_ptr<U>& b) const noexcept;
   };
   template<class T>
     weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
 }
 pointer value.
 *Ensures:* `use_count() == 0`.
 ``` cpp
+constexpr weak_ptr(const weak_ptr& r) noexcept;
+template<class Y> constexpr weak_ptr(const weak_ptr<Y>& r) noexcept;
+template<class Y> constexpr weak_ptr(const shared_ptr<Y>& r) noexcept;
 ```
 *Constraints:* For the second and third constructors, `Y*` is compatible
 with `T*`.
 in `r`.
 *Ensures:* `use_count() == r.use_count()`.
 ``` cpp
+constexpr weak_ptr(weak_ptr&& r) noexcept;
+template<class Y> constexpr 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`.
 null pointer value, and `r.use_count() == 0`.
 ##### Destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
 ``` cpp
+constexpr ~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
+constexpr weak_ptr& operator=(const weak_ptr& r) noexcept;
+template<class Y> constexpr weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
+template<class Y> constexpr 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
+constexpr weak_ptr& operator=(weak_ptr&& r) noexcept;
+template<class Y> constexpr 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
+constexpr void swap(weak_ptr& r) noexcept;
 ```
 *Effects:* Exchanges the contents of `*this` and `r`.
 ``` cpp
+constexpr void reset() noexcept;
 ```
 *Effects:* Equivalent to `weak_ptr().swap(*this)`.
 ##### Observers <a id="util.smartptr.weak.obs">[[util.smartptr.weak.obs]]</a>
 ``` cpp
+constexpr long use_count() const noexcept;
 ```
 *Returns:* `0` if `*this` is empty; otherwise, the number of
 `shared_ptr` instances that share ownership with `*this`.
 ``` cpp
+constexpr bool expired() const noexcept;
 ```
 *Returns:* `use_count() == 0`.
 ``` cpp
+constexpr shared_ptr<T> lock() const noexcept;
 ```
 *Returns:* `expired() ? shared_ptr<T>() : shared_ptr<T>(*this)`,
 executed atomically.
 ``` cpp
+template<class U> constexpr bool owner_before(const shared_ptr<U>& b) const noexcept;
+template<class U> constexpr bool owner_before(const weak_ptr<U>& b) const noexcept;
 ```
 *Returns:* An unspecified value such that
+- `owner_before(b)` defines a strict weak ordering as defined
   in  [[alg.sorting]];
+- `!owner_before(b) && !b.owner_before(*this)` is `true` if and only if
+  `owner_equal(b)` is `true`.
+``` cpp
+size_t owner_hash() const noexcept;
+```
+*Returns:* An unspecified value such that, for any object `x` where
+`owner_equal(x)` is `true`, `owner_hash() == x.owner_hash()` is `true`.
+``` cpp
+template<class U>
+  constexpr bool owner_equal(const shared_ptr<U>& b) const noexcept;
+template<class U>
+  constexpr bool owner_equal(const weak_ptr<U>& b) const noexcept;
+```
+*Returns:* `true` if and only if `*this` and `b` share ownership or are
+both empty. Otherwise returns `false`.
+*Remarks:* `owner_equal` is an equivalence relation.
 ##### Specialized algorithms <a id="util.smartptr.weak.spec">[[util.smartptr.weak.spec]]</a>
 ``` cpp
 template<class T>
+ constexpr 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>
 ``` cpp
 namespace std {
   template<class T = void> struct owner_less;
   template<class T> struct owner_less<shared_ptr<T>> {
+ constexpr bool operator()(const shared_ptr<T>&, const shared_ptr<T>&) const noexcept;
+ constexpr bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
+ constexpr bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
   };
   template<class T> struct owner_less<weak_ptr<T>> {
+ constexpr bool operator()(const weak_ptr<T>&, const weak_ptr<T>&) const noexcept;
+ constexpr bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
+ constexpr bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
   };
   template<> struct owner_less<void> {
     template<class T, class U>
+ constexpr bool operator()(const shared_ptr<T>&, const shared_ptr<U>&) const noexcept;
     template<class T, class U>
+ constexpr bool operator()(const shared_ptr<T>&, const weak_ptr<U>&) const noexcept;
     template<class T, class U>
+ constexpr bool operator()(const weak_ptr<T>&, const shared_ptr<U>&) const noexcept;
     template<class T, class U>
+ constexpr bool operator()(const weak_ptr<T>&, const weak_ptr<U>&) const noexcept;
     using is_transparent = unspecified;
   };
 }
 ```
 Note that
 - `operator()` defines a strict weak ordering as defined in
   [[alg.sorting]];
+- `!operator()(a, b) && !operator()(b, a)` is `true` if and only if
+  `a.owner_equal(b)` is `true`.
 — *end note*]
+#### Struct `owner_hash` <a id="util.smartptr.owner.hash">[[util.smartptr.owner.hash]]</a>
+The class `owner_hash` provides ownership-based hashing.
+``` cpp
+namespace std {
+  struct owner_hash {
+    template<class T>
+      size_t operator()(const shared_ptr<T>&) const noexcept;
+    template<class T>
+      size_t operator()(const weak_ptr<T>&) const noexcept;
+    using is_transparent = unspecified;
+  };
+}
+```
+``` cpp
+template<class T>
+  size_t operator()(const shared_ptr<T>& x) const noexcept;
+template<class T>
+  size_t operator()(const weak_ptr<T>& x) const noexcept;
+```
+*Returns:* `x.owner_hash()`.
+[*Note 1*: For any object `y` where `x.owner_equal(y)` is `true`,
+`x.owner_hash() == y.owner_hash()` is `true`. — *end note*]
+#### Struct `owner_equal` <a id="util.smartptr.owner.equal">[[util.smartptr.owner.equal]]</a>
+The class `owner_equal` provides ownership-based mixed equality
+comparisons of shared and weak pointers.
+``` cpp
+namespace std {
+  struct owner_equal {
+    template<class T, class U>
+      constexpr bool operator()(const shared_ptr<T>&, const shared_ptr<U>&) const noexcept;
+    template<class T, class U>
+      constexpr bool operator()(const shared_ptr<T>&, const weak_ptr<U>&) const noexcept;
+    template<class T, class U>
+      constexpr bool operator()(const weak_ptr<T>&, const shared_ptr<U>&) const noexcept;
+    template<class T, class U>
+      constexpr bool operator()(const weak_ptr<T>&, const weak_ptr<U>&) const noexcept;
+    using is_transparent = unspecified;
+  };
+}
+```
+``` cpp
+template<class T, class U>
+  constexpr bool operator()(const shared_ptr<T>& x, const shared_ptr<U>& y) const noexcept;
+template<class T, class U>
+  constexpr bool operator()(const shared_ptr<T>& x, const weak_ptr<U>& y) const noexcept;
+template<class T, class U>
+  constexpr bool operator()(const weak_ptr<T>& x, const shared_ptr<U>& y) const noexcept;
+template<class T, class U>
+  constexpr bool operator()(const weak_ptr<T>& x, const weak_ptr<U>& y) const noexcept;
+```
+*Returns:* `x.owner_equal(y)`.
+[*Note 1*: `x.owner_equal(y)` is `true` if and only if `x` and `y`
+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`.
 int main() {
   shared_ptr<X> p(new X);
   shared_ptr<X> q = p->shared_from_this();
   assert(p == q);
+  assert(p.owner_equal(q)); // p and q share ownership
 }
 ```
 — *end example*]
 ``` cpp
 namespace std {
   template<class T> class enable_shared_from_this {
   protected:
     constexpr enable_shared_from_this() noexcept;
+ constexpr enable_shared_from_this(const enable_shared_from_this&) noexcept;
+ constexpr enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept;
+ constexpr ~enable_shared_from_this();
   public:
+ constexpr shared_ptr<T> shared_from_this();
+ constexpr shared_ptr<T const> shared_from_this() const;
+ constexpr weak_ptr<T> weak_from_this() noexcept;
+ constexpr weak_ptr<T const> weak_from_this() const noexcept;
   private:
+    mutable weak_ptr<T> weak-this;  // exposition only
   };
 }
 ```
 The template parameter `T` of `enable_shared_from_this` may be an
 incomplete type.
 ``` cpp
 constexpr enable_shared_from_this() noexcept;
+constexpr enable_shared_from_this(const enable_shared_from_this<T>&) noexcept;
 ```
+*Effects:* Value-initializes *weak-this*.
 ``` cpp
+constexpr enable_shared_from_this<T>& operator=(const enable_shared_from_this<T>&) noexcept;
 ```
 *Returns:* `*this`.
+[*Note 1*: *weak-this* is not changed. — *end note*]
 ``` cpp
+constexpr shared_ptr<T>       shared_from_this();
+constexpr shared_ptr<T const> shared_from_this() const;
 ```
+*Returns:* `shared_ptr<T>(`*`weak-this`*`)`.
 ``` cpp
+constexpr weak_ptr<T>       weak_from_this() noexcept;
+constexpr 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>>;
 ``` cpp
 namespace std {
   template<class Smart, class Pointer, class... Args>
   class out_ptr_t {
   public:
+ constexpr explicit out_ptr_t(Smart&, Args...);
     out_ptr_t(const out_ptr_t&) = delete;
+ constexpr ~out_ptr_t();
+ constexpr operator Pointer*() const noexcept;
     operator void**() const noexcept;
   private:
     Smart& s;                   // exposition only
     tuple<Args...> a;           // exposition only
 Evaluations of the conversion functions on the same object may conflict
 [[intro.races]].
 ``` cpp
+constexpr 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
+constexpr ~out_ptr_t();
 ```
 Let `SP` be *`POINTER_OF_OR`*`(Smart, Pointer)` [[memory.general]].
 *Effects:* Equivalent to:
   if `is_constructible_v<Smart, SP, Args...>` is `true`;
 - otherwise, the program is ill-formed.
 ``` cpp
+constexpr operator Pointer*() const noexcept;
 ```
 *Preconditions:* `operator void**()` has not been called on `*this`.
 *Returns:* `addressof(const_cast<Pointer&>(p))`.
 #### Function template `out_ptr` <a id="out.ptr">[[out.ptr]]</a>
 ``` cpp
 template<class Pointer = void, class Smart, class... Args>
+ constexpr 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
 ``` cpp
 namespace std {
   template<class Smart, class Pointer, class... Args>
   class inout_ptr_t {
   public:
+ constexpr explicit inout_ptr_t(Smart&, Args...);
     inout_ptr_t(const inout_ptr_t&) = delete;
+ constexpr ~inout_ptr_t();
+ constexpr operator Pointer*() const noexcept;
     operator void**() const noexcept;
   private:
     Smart& s;                   // exposition only
     tuple<Args...> a;           // exposition only
 Evaluations of the conversion functions on the same object may conflict
 [[intro.races]].
 ``` cpp
+constexpr explicit inout_ptr_t(Smart& smart, Args... args);
 ```
 *Effects:* Initializes `s` with `smart`, `a` with
 `std::forward<Args>(args)...`, and `p` to either
 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
+constexpr ~inout_ptr_t();
 ```
 Let `SP` be *`POINTER_OF_OR`*`(Smart, Pointer)` [[memory.general]].
 Let *release-statement* be `s.release();` if an implementation does not
 *Effects:* Equivalent to:
 -
   ``` cpp
   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
   if `is_constructible_v<Smart, SP, Args...>` is `true`;
 - otherwise, the program is ill-formed.
 ``` cpp
+constexpr operator Pointer*() const noexcept;
 ```
 *Preconditions:* `operator void**()` has not been called on `*this`.
 *Returns:* `addressof(const_cast<Pointer&>(p))`.
 #### Function template `inout_ptr` <a id="inout.ptr">[[inout.ptr]]</a>
 ``` cpp
 template<class Pointer = void, class Smart, class... Args>
+ constexpr auto inout_ptr(Smart& s, Args&&... args);
 ```
 Let `P` be `Pointer` if `is_void_v<Pointer>` is `false`, otherwise
 *`POINTER_OF`*`(Smart)`.

Diff to HTML by rtfpessoa