[util.smartptr.shared] - C++17 → C++20

Files changed (1) hide show

tmp/tmp8b0tqeqb/{from.md → to.md} +424 -263

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

@@ -1,6 +1,6 @@
-#### 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.
@@ -13,130 +13,88 @@ namespace std {
     using element_type = remove_extent_t<T>;
     using weak_type    = weak_ptr<T>;
     // [util.smartptr.shared.const], constructors
     constexpr shared_ptr() noexcept;
-    template<class Y> explicit shared_ptr(Y* p);
-    template<class Y, class D> shared_ptr(Y* p, D d);
-    template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
-    template <class D> shared_ptr(nullptr_t p, D d);
-    template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
-    template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
-    shared_ptr(const shared_ptr& r) noexcept;
-    template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
-    shared_ptr(shared_ptr&& r) noexcept;
-    template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
-    template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
-    template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
     constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
     // [util.smartptr.shared.dest], destructor
     ~shared_ptr();
     // [util.smartptr.shared.assign], assignment
     shared_ptr& operator=(const shared_ptr& r) noexcept;
-    template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
     shared_ptr& operator=(shared_ptr&& r) noexcept;
-    template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
-    template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.mod], modifiers
     void swap(shared_ptr& r) noexcept;
     void reset() noexcept;
-    template<class Y> void reset(Y* p);
-    template<class Y, class D> void reset(Y* p, D d);
-    template<class Y, class D, class A> void reset(Y* p, D d, A a);
     // [util.smartptr.shared.obs], observers
     element_type* get() const noexcept;
     T& operator*() const noexcept;
     T* operator->() const noexcept;
     element_type& operator[](ptrdiff_t i) const;
     long use_count() const noexcept;
     explicit operator bool() const noexcept;
-    template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
-    template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
   };
-  template<class T> shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
-  template<class T, class D> shared_ptr(unique_ptr<T, D>) -> shared_ptr<T>;
-  // [util.smartptr.shared.create], shared_ptr creation
-  template<class T, class... Args>
-    shared_ptr<T> make_shared(Args&&... args);
-  template<class T, class A, class... Args>
-    shared_ptr<T> allocate_shared(const A& a, Args&&... args);
-  // [util.smartptr.shared.cmp], shared_ptr comparisons
-  template<class T, class U>
-    bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator<=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-  template<class T, class U>
-    bool operator>=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
   template<class T>
- bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
- bool operator==(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator!=(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator!=(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator<(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator<(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator<=(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator<=(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator>(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator>(nullptr_t, const shared_ptr<T>& b) noexcept;
-  template <class T>
-    bool operator>=(const shared_ptr<T>& a, nullptr_t) noexcept;
-  template <class T>
-    bool operator>=(nullptr_t, const shared_ptr<T>& b) noexcept;
-  // [util.smartptr.shared.spec], shared_ptr specialized algorithms
-  template<class T>
-    void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
-  // [util.smartptr.shared.cast], shared_ptr casts
-  template<class T, class U>
-    shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
-  template<class T, class U>
-    shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
-  template<class T, class U>
-    shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
-  template<class T, class U>
-    shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
-  // [util.smartptr.getdeleter], shared_ptr get_deleter
-  template<class D, class T>
-    D* get_deleter(const shared_ptr<T>& p) noexcept;
-  // [util.smartptr.shared.io], shared_ptr I/O
-  template<class E, class T, class Y>
-    basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, const shared_ptr<Y>& p);
 }
 ```
-Specializations of `shared_ptr` shall be `CopyConstructible`,
-`CopyAssignable`, and `LessThanComparable`, allowing their use in
-standard containers. Specializations of `shared_ptr` shall be
 contextually convertible to `bool`, allowing their use in boolean
-expressions and declarations in conditions. The template parameter `T`
-of `shared_ptr` may be an incomplete type.
 [*Example 1*:
 ``` cpp
 if (shared_ptr<X> px = dynamic_pointer_cast<X>(py)) {
@@ -150,173 +108,168 @@ For purposes of determining the presence of a data race, member
 functions shall access and modify only the `shared_ptr` and `weak_ptr`
 objects themselves and not objects they refer to. Changes in
 `use_count()` do not reflect modifications that can introduce data
 races.
-For the purposes of subclause [[util.smartptr]], a pointer type `Y*` is
-said to be *compatible with* a pointer type `T*` when either `Y*` is
 convertible to `T*` or `Y` is `U[N]` and `T` is cv `U[]`.
-##### `shared_ptr` constructors <a id="util.smartptr.shared.const">[[util.smartptr.shared.const]]</a>
 In the constructor definitions below, enables `shared_from_this` with
 `p`, for a pointer `p` of type `Y*`, means that if `Y` has an
 unambiguous and accessible base class that is a specialization of
-`enable_shared_from_this` ([[util.smartptr.enab]]), then
-`remove_cv_t<Y>*` shall be implicitly convertible to `T*` and the
-constructor evaluates the statement:
 ``` cpp
 if (p != nullptr && p->weak_this.expired())
   p->weak_this = shared_ptr<remove_cv_t<Y>>(*this, const_cast<remove_cv_t<Y>*>(p));
 ```
 The assignment to the `weak_this` member is not atomic and conflicts
-with any potentially concurrent access to the same object (
-[[intro.multithread]]).
 ``` cpp
 constexpr shared_ptr() noexcept;
 ```
-*Effects:* Constructs an empty `shared_ptr` object.
-*Postconditions:* `use_count() == 0 && get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(Y* p);
 ```
-*Requires:* `Y` shall be a complete type. The expression `delete[] p`,
-when `T` is an array type, or `delete p`, when `T` is not an array type,
-shall have well-defined behavior, and shall not throw exceptions.
 *Effects:* When `T` is not an array type, constructs a `shared_ptr`
 object that owns the pointer `p`. Otherwise, constructs a `shared_ptr`
 that owns `p` and a deleter of an unspecified type that calls
 `delete[] p`. When `T` is not an array type, enables `shared_from_this`
 with `p`. If an exception is thrown, `delete p` is called when `T` is
 not an array type, `delete[] p` otherwise.
-*Postconditions:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
-*Remarks:* When `T` is an array type, this constructor shall not
-participate in overload resolution unless the expression `delete[] p` is
-well-formed and either `T` is `U[N]` and `Y(*)[N]` is convertible to
-`T*`, or `T` is `U[]` and `Y(*)[]` is convertible to `T*`. When `T` is
-not an array type, this constructor shall not participate in overload
-resolution unless the expression `delete p` is well-formed and `Y*` is
-convertible to `T*`.
 ``` cpp
 template<class Y, class D> shared_ptr(Y* p, D d);
 template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
 template<class D> shared_ptr(nullptr_t p, D d);
 template<class D, class A> shared_ptr(nullptr_t p, D d, A a);
 ```
-*Requires:* Construction of `d` and a deleter of type `D` initialized
-with `std::move(d)` shall not throw exceptions. The expression `d(p)`
-shall have well-defined behavior and shall not throw exceptions. `A`
-shall be an allocator ([[allocator.requirements]]).
 *Effects:* Constructs a `shared_ptr` object that owns the object `p` and
 the deleter `d`. When `T` is not an array type, the first and second
 constructors enable `shared_from_this` with `p`. The second and fourth
 constructors shall use a copy of `a` to allocate memory for internal
 use. If an exception is thrown, `d(p)` is called.
-*Postconditions:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
-*Remarks:* When `T` is an array type, this constructor shall not
-participate in overload resolution unless `is_move_constructible_v<D>`
-is `true`, the expression `d(p)` is well-formed, and either `T` is
-`U[N]` and `Y(*)[N]` is convertible to `T*`, or `T` is `U[]` and
-`Y(*)[]` is convertible to `T*`. When `T` is not an array type, this
-constructor shall not participate in overload resolution unless
-`is_move_constructible_v<D>` is `true`, the expression `d(p)` is
-well-formed, and `Y*` is convertible to `T*`.
 ``` cpp
 template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
 ```
 *Effects:* Constructs a `shared_ptr` instance that stores `p` and shares
-ownership with `r`.
-*Postconditions:* `get() == p && use_count() == r.use_count()`.
 [*Note 1*: To avoid the possibility of a dangling pointer, the user of
-this constructor must ensure that `p` remains valid at least until the
 ownership group of `r` is destroyed. — *end note*]
 [*Note 2*: This constructor allows creation of an empty `shared_ptr`
 instance with a non-null stored pointer. — *end note*]
 ``` cpp
 shared_ptr(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
 ```
-*Remarks:* The second constructor shall not participate in overload
-resolution unless `Y*` is compatible with `T*`.
 *Effects:* If `r` is empty, constructs an empty `shared_ptr` object;
 otherwise, constructs a `shared_ptr` object that shares ownership with
 `r`.
-*Postconditions:* `get() == r.get() && use_count() == r.use_count()`.
 ``` cpp
 shared_ptr(shared_ptr&& r) noexcept;
 template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
 ```
-*Remarks:* The second constructor shall not participate in overload
-resolution unless `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `shared_ptr` instance from `r`.
-*Postconditions:* `*this` shall contain the old value of `r`. `r` shall
-be empty. `r.get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
 ```
 *Effects:* Constructs a `shared_ptr` object that shares ownership with
 `r` and stores a copy of the pointer stored in `r`. If an exception is
 thrown, the constructor has no effect.
-*Postconditions:* `use_count() == r.use_count()`.
 *Throws:* `bad_weak_ptr` when `r.expired()`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `Y*` is compatible with `T*`.
 ``` cpp
 template<class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
 ```
-*Remarks:* This constructor shall not participate in overload resolution
-unless `Y*` is compatible with `T*` and `unique_ptr<Y, D>::pointer` is
-convertible to `element_type*`.
 *Effects:* If `r.get() == nullptr`, equivalent to `shared_ptr()`.
 Otherwise, if `D` is not a reference type, equivalent to
 `shared_ptr(r.release(), r.get_deleter())`. Otherwise, equivalent to
 `shared_ptr(r.release(), ref(r.get_deleter()))`. If an exception is
 thrown, the constructor has no effect.
-##### `shared_ptr` destructor <a id="util.smartptr.shared.dest">[[util.smartptr.shared.dest]]</a>
 ``` cpp
 ~shared_ptr();
 ```
@@ -332,22 +285,22 @@ thrown, the constructor has no effect.
 instances that share ownership with `*this` by one, after `*this` has
 been destroyed all `shared_ptr` instances that shared ownership with
 `*this` will report a `use_count()` that is one less than its previous
 value. — *end note*]
-##### `shared_ptr` assignment <a id="util.smartptr.shared.assign">[[util.smartptr.shared.assign]]</a>
 ``` cpp
 shared_ptr& operator=(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(r).swap(*this)`.
 *Returns:* `*this`.
-[*Note 3*:
 The use count updates caused by the temporary object construction and
 destruction are not observable side effects, so the implementation may
 meet the effects (and the implied guarantees) via different means,
 without creating a temporary. In particular, in the example:
@@ -378,11 +331,11 @@ template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
 *Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
-##### `shared_ptr` modifiers <a id="util.smartptr.shared.mod">[[util.smartptr.shared.mod]]</a>
 ``` cpp
 void swap(shared_ptr& r) noexcept;
 ```
@@ -410,11 +363,11 @@ template<class Y, class D> void reset(Y* p, D d);
 template<class Y, class D, class A> void reset(Y* p, D d, A a);
 ```
 *Effects:* Equivalent to `shared_ptr(p, d, a).swap(*this)`.
-##### `shared_ptr` observers <a id="util.smartptr.shared.obs">[[util.smartptr.shared.obs]]</a>
 ``` cpp
 element_type* get() const noexcept;
 ```
@@ -422,45 +375,45 @@ element_type* get() const noexcept;
 ``` cpp
 T& operator*() const noexcept;
 ```
-*Requires:* `get() != 0`.
 *Returns:* `*get()`.
 *Remarks:* When `T` is an array type or cv `void`, it is unspecified
 whether this member function is declared. If it is declared, it is
 unspecified what its return type is, except that the declaration
-(although not necessarily the definition) of the function shall be well
-formed.
 ``` cpp
 T* operator->() const noexcept;
 ```
-*Requires:* `get() != 0`.
 *Returns:* `get()`.
 *Remarks:* When `T` is an array type, it is unspecified whether this
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
-necessarily the definition) of the function shall be well formed.
 ``` cpp
 element_type& operator[](ptrdiff_t i) const;
 ```
-*Requires:* `get() != 0 && i >= 0`. If `T` is `U[N]`, `i < N`.
 *Returns:* `get()[i]`.
 *Remarks:* When `T` is not an array type, it is unspecified whether this
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
-necessarily the definition) of the function shall be well formed.
 *Throws:* Nothing.
 ``` cpp
 long use_count() const noexcept;
@@ -469,17 +422,17 @@ long use_count() const noexcept;
 *Returns:* The number of `shared_ptr` objects, `*this` included, that
 share ownership with `*this`, or `0` when `*this` is empty.
 *Synchronization:* None.
-[*Note 4*: `get() == nullptr` does not imply a specific return value of
 `use_count()`. — *end note*]
-[*Note 5*: `weak_ptr<T>::lock()` can affect the return value of
 `use_count()`. — *end note*]
-[*Note 6*: When multiple threads can affect the return value of
 `use_count()`, the result should be treated as approximate. In
 particular, `use_count() == 1` does not imply that accesses through a
 previously destroyed `shared_ptr` have in any sense
 completed. — *end note*]
@@ -501,217 +454,425 @@ template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
 - under the equivalence relation defined by `owner_before`,
   `!a.owner_before(b) && !b.owner_before(a)`, two `shared_ptr` or
   `weak_ptr` instances are equivalent if and only if they share
   ownership or are both empty.
-##### `shared_ptr` creation <a id="util.smartptr.shared.create">[[util.smartptr.shared.create]]</a>
 ``` cpp
-template<class T, class... Args>
-  shared_ptr<T> make_shared(Args&&... args);
-template<class T, class A, class... Args>
-  shared_ptr<T> allocate_shared(const A& a, Args&&... args);
 ```
-*Requires:* The expression `::new (pv) T(std::forward<Args>(args)...)`,
-where `pv` has type `void*` and points to storage suitable to hold an
-object of type `T`, shall be well formed. `A` shall be an
-allocator ([[allocator.requirements]]). The copy constructor and
-destructor of `A` shall not throw exceptions.
-*Effects:* Allocates memory suitable for an object of type `T` and
-constructs an object in that memory via the placement *new-expression*
-`::new (pv) T(std::forward<Args>(args)...)`. The template
-`allocate_shared` uses a copy of `a` to allocate memory. If an exception
-is thrown, the functions have no effect.
 *Returns:* A `shared_ptr` instance that stores and owns the address of
-the newly constructed object of type `T`.
-*Postconditions:* `get() != 0 && use_count() == 1`.
-*Throws:* `bad_alloc`, or an exception thrown from `A::allocate` or from
-the constructor of `T`.
-*Remarks:* The `shared_ptr` constructor called by this function enables
-`shared_from_this` with the address of the newly constructed object of
-type `T`. Implementations should perform no more than one memory
-allocation.
-[*Note 7*: This provides efficiency equivalent to an intrusive smart
   pointer. — *end note*]
-[*Note 8*: These functions will typically allocate more memory than
-`sizeof(T)` to allow for internal bookkeeping structures such as the
 reference counts. — *end note*]
-##### `shared_ptr` comparison <a id="util.smartptr.shared.cmp">[[util.smartptr.shared.cmp]]</a>
 ``` cpp
 template<class T, class U>
   bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `a.get() == b.get()`.
-``` cpp
-template<class T, class U>
-  bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
-```
-*Returns:* `less<>()(a.get(), b.get())`.
-[*Note 9*: Defining a comparison function allows `shared_ptr` objects
-to be used as keys in associative containers. — *end note*]
 ``` cpp
 template<class T>
   bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator==(nullptr_t, const shared_ptr<T>& a) noexcept;
 ```
 *Returns:* `!a`.
 ``` cpp
-template <class T>
- bool operator!=(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator!=(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* `(bool)a`.
-``` cpp
-template <class T>
-  bool operator<(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator<(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* The first function template returns
-`less<shared_ptr<T>::element_type*>()(a.get(), nullptr)`. The second
-function template returns
-`less<shared_ptr<T>::element_type*>()(nullptr, a.get())`.
-``` cpp
-template <class T>
-  bool operator>(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator>(nullptr_t, const shared_ptr<T>& a) noexcept;
 ```
-*Returns:* The first function template returns `nullptr < a`. The second
-function template returns `a < nullptr`.
-``` cpp
-template <class T>
-  bool operator<=(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator<=(nullptr_t, const shared_ptr<T>& a) noexcept;
-```
-*Returns:* The first function template returns `!(nullptr < a)`. The
-second function template returns `!(a < nullptr)`.
 ``` cpp
 template<class T>
- bool operator>=(const shared_ptr<T>& a, nullptr_t) noexcept;
-template <class T>
-  bool operator>=(nullptr_t, const shared_ptr<T>& a) noexcept;
 ```
-*Returns:* The first function template returns `!(a < nullptr)`. The
-second function template returns `!(nullptr < a)`.
-##### `shared_ptr` specialized algorithms <a id="util.smartptr.shared.spec">[[util.smartptr.shared.spec]]</a>
 ``` cpp
 template<class T>
   void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
-##### `shared_ptr` casts <a id="util.smartptr.shared.cast">[[util.smartptr.shared.cast]]</a>
 ``` cpp
 template<class T, class U>
   shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
 ```
-*Requires:* The expression `static_cast<T*>((U*)0)` shall be well
-formed.
 *Returns:*
 ``` cpp
-shared_ptr<T>(r, static_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
-[*Note 10*: The seemingly equivalent expression
 `shared_ptr<T>(static_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
 ```
-*Requires:* The expression `dynamic_cast<T*>((U*)0)` shall be well
-formed and shall have well defined behavior.
 *Returns:*
 - When `dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())`
-  returns a nonzero value `p`, `shared_ptr<T>(r, p)`.
 - Otherwise, `shared_ptr<T>()`.
-[*Note 11*: The seemingly equivalent expression
 `shared_ptr<T>(dynamic_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
 ```
-*Requires:* The expression `const_cast<T*>((U*)0)` shall be well formed.
 *Returns:*
 ``` cpp
-shared_ptr<T>(r, const_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
-[*Note 12*: The seemingly equivalent expression
 `shared_ptr<T>(const_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
 ```
-*Requires:* The expression `reinterpret_cast<T*>((U*)0)` shall be well
-formed.
 *Returns:*
 ``` cpp
-shared_ptr<T>(r, reinterpret_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
-[*Note 13*: The seemingly equivalent expression
 `shared_ptr<T>(reinterpret_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
-##### `get_deleter` <a id="util.smartptr.getdeleter">[[util.smartptr.getdeleter]]</a>
 ``` cpp
 template<class D, class T>
   D* get_deleter(const shared_ptr<T>& p) noexcept;
 ```
@@ -719,16 +880,16 @@ template<class D, class T>
 *Returns:* If `p` owns a deleter `d` of type cv-unqualified `D`, returns
 `addressof(d)`; otherwise returns `nullptr`. The returned pointer
 remains valid as long as there exists a `shared_ptr` instance that owns
 `d`.
-[*Note 14*: It is unspecified whether the pointer remains valid longer
 than that. This can happen if the implementation doesn’t destroy the
 deleter until all `weak_ptr` instances that share ownership with `p`
 have been destroyed. — *end note*]
-##### `shared_ptr` I/O <a id="util.smartptr.shared.io">[[util.smartptr.shared.io]]</a>
 ``` cpp
 template<class E, class T, class Y>
   basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);
 ```

+### Class template `shared_ptr` <a id="util.smartptr.shared">[[util.smartptr.shared]]</a>
 The `shared_ptr` class template stores a pointer, usually obtained via
 `new`. `shared_ptr` implements semantics of shared ownership; the last
 remaining owner of the pointer is responsible for destroying the object,
 or otherwise releasing the resources associated with the stored pointer.
     using element_type = remove_extent_t<T>;
     using weak_type    = weak_ptr<T>;
     // [util.smartptr.shared.const], constructors
     constexpr shared_ptr() noexcept;
     constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
+    template<class Y>
+      explicit shared_ptr(Y* p);
+    template<class Y, class D>
+      shared_ptr(Y* p, D d);
+    template<class Y, class D, class A>
+      shared_ptr(Y* p, D d, A a);
+    template<class D>
+      shared_ptr(nullptr_t p, D d);
+    template<class D, class A>
+      shared_ptr(nullptr_t p, D d, A a);
+    template<class Y>
+      shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
+    template<class Y>
+      shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
+    shared_ptr(const shared_ptr& r) noexcept;
+    template<class Y>
+      shared_ptr(const shared_ptr<Y>& r) noexcept;
+    shared_ptr(shared_ptr&& r) noexcept;
+    template<class Y>
+      shared_ptr(shared_ptr<Y>&& r) noexcept;
+    template<class Y>
+      explicit shared_ptr(const weak_ptr<Y>& r);
+    template<class Y, class D>
+      shared_ptr(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.dest], destructor
     ~shared_ptr();
     // [util.smartptr.shared.assign], assignment
     shared_ptr& operator=(const shared_ptr& r) noexcept;
+    template<class Y>
+      shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
     shared_ptr& operator=(shared_ptr&& r) noexcept;
+    template<class Y>
+ shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
+    template<class Y, class D>
+      shared_ptr& operator=(unique_ptr<Y, D>&& r);
     // [util.smartptr.shared.mod], modifiers
     void swap(shared_ptr& r) noexcept;
     void reset() noexcept;
+    template<class Y>
+ void reset(Y* p);
+    template<class Y, class D>
+      void reset(Y* p, D d);
+    template<class Y, class D, class A>
+      void reset(Y* p, D d, A a);
     // [util.smartptr.shared.obs], observers
     element_type* get() const noexcept;
     T& operator*() const noexcept;
     T* operator->() const noexcept;
     element_type& operator[](ptrdiff_t i) const;
     long use_count() const noexcept;
     explicit operator bool() const noexcept;
+    template<class U>
+ bool owner_before(const shared_ptr<U>& b) const noexcept;
+    template<class U>
+      bool owner_before(const weak_ptr<U>& b) const noexcept;
   };
   template<class T>
+    shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
+  template<class T, class D>
+ shared_ptr(unique_ptr<T, D>) -> shared_ptr<T>;
 }
 ```
+Specializations of `shared_ptr` shall be *Cpp17CopyConstructible*,
+*Cpp17CopyAssignable*, and *Cpp17LessThanComparable*, allowing their use
+in standard containers. Specializations of `shared_ptr` shall be
 contextually convertible to `bool`, allowing their use in boolean
+expressions and declarations in conditions.
+The template parameter `T` of `shared_ptr` may be an incomplete type.
+[*Note 1*: `T` may be a function type. — *end note*]
 [*Example 1*:
 ``` cpp
 if (shared_ptr<X> px = dynamic_pointer_cast<X>(py)) {
 functions shall access and modify only the `shared_ptr` and `weak_ptr`
 objects themselves and not objects they refer to. Changes in
 `use_count()` do not reflect modifications that can introduce data
 races.
+For the purposes of subclause [[smartptr]], a pointer type `Y*` is said
+to be *compatible with* a pointer type `T*` when either `Y*` is
 convertible to `T*` or `Y` is `U[N]` and `T` is cv `U[]`.
+#### Constructors <a id="util.smartptr.shared.const">[[util.smartptr.shared.const]]</a>
 In the constructor definitions below, enables `shared_from_this` with
 `p`, for a pointer `p` of type `Y*`, means that if `Y` has an
 unambiguous and accessible base class that is a specialization of
+`enable_shared_from_this` [[util.smartptr.enab]], then `remove_cv_t<Y>*`
+shall be implicitly convertible to `T*` and the constructor evaluates
+the statement:
 ``` cpp
 if (p != nullptr && p->weak_this.expired())
   p->weak_this = shared_ptr<remove_cv_t<Y>>(*this, const_cast<remove_cv_t<Y>*>(p));
 ```
 The assignment to the `weak_this` member is not atomic and conflicts
+with any potentially concurrent access to the same object
+[[intro.multithread]].
 ``` cpp
 constexpr shared_ptr() noexcept;
 ```
+*Ensures:* `use_count() == 0 && get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(Y* p);
 ```
+*Mandates:* `Y` is a complete type.
+*Constraints:* When `T` is an array type, the expression `delete[] p` is
+well-formed and either `T` is `U[N]` and `Y(*)[N]` is convertible to
+`T*`, or `T` is `U[]` and `Y(*)[]` is convertible to `T*`. When `T` is
+not an array type, the expression `delete p` is well-formed and `Y*` is
+convertible to `T*`.
+*Preconditions:* The expression `delete[] p`, when `T` is an array type,
+or `delete p`, when `T` is not an array type, has well-defined behavior,
+and does not throw exceptions.
 *Effects:* When `T` is not an array type, constructs a `shared_ptr`
 object that owns the pointer `p`. Otherwise, constructs a `shared_ptr`
 that owns `p` and a deleter of an unspecified type that calls
 `delete[] p`. When `T` is not an array type, enables `shared_from_this`
 with `p`. If an exception is thrown, `delete p` is called when `T` is
 not an array type, `delete[] p` otherwise.
+*Ensures:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
 ``` cpp
 template<class Y, class D> shared_ptr(Y* p, D d);
 template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
 template<class D> shared_ptr(nullptr_t p, D d);
 template<class D, class A> shared_ptr(nullptr_t p, D d, A a);
 ```
+*Constraints:* `is_move_constructible_v<D>` is `true`, and `d(p)` is a
+well-formed expression. For the first two overloads:
+- If `T` is an array type, then either `T` is `U[N]` and `Y(*)[N]` is
+  convertible to `T*`, or `T` is `U[]` and `Y(*)[]` is convertible to
+  `T*`.
+- If `T` is not an array type, then `Y*` is convertible to `T*`.
+*Preconditions:* Construction of `d` and a deleter of type `D`
+initialized with `std::move(d)` do not throw exceptions. The expression
+`d(p)` has well-defined behavior and does not throw exceptions. `A`
+meets the *Cpp17Allocator* requirements ([[cpp17.allocator]]).
 *Effects:* Constructs a `shared_ptr` object that owns the object `p` and
 the deleter `d`. When `T` is not an array type, the first and second
 constructors enable `shared_from_this` with `p`. The second and fourth
 constructors shall use a copy of `a` to allocate memory for internal
 use. If an exception is thrown, `d(p)` is called.
+*Ensures:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
 ``` cpp
 template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
+template<class Y> shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
 ```
 *Effects:* Constructs a `shared_ptr` instance that stores `p` and shares
+ownership with the initial value of `r`.
+*Ensures:* `get() == p`. For the second overload, `r` is empty and
+`r.get() == nullptr`.
 [*Note 1*: To avoid the possibility of a dangling pointer, the user of
+this constructor should ensure that `p` remains valid at least until the
 ownership group of `r` is destroyed. — *end note*]
 [*Note 2*: This constructor allows creation of an empty `shared_ptr`
 instance with a non-null stored pointer. — *end note*]
 ``` cpp
 shared_ptr(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
 ```
+*Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* If `r` is empty, constructs an empty `shared_ptr` object;
 otherwise, constructs a `shared_ptr` object that shares ownership with
 `r`.
+*Ensures:* `get() == r.get() && use_count() == r.use_count()`.
 ``` cpp
 shared_ptr(shared_ptr&& r) noexcept;
 template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
 ```
+*Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `shared_ptr` instance from `r`.
+*Ensures:* `*this` shall contain the old value of `r`. `r` shall be
+empty. `r.get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
 ```
+*Constraints:* `Y*` is compatible with `T*`.
 *Effects:* Constructs a `shared_ptr` object that shares ownership with
 `r` and stores a copy of the pointer stored in `r`. If an exception is
 thrown, the constructor has no effect.
+*Ensures:* `use_count() == r.use_count()`.
 *Throws:* `bad_weak_ptr` when `r.expired()`.
 ``` cpp
 template<class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
 ```
+*Constraints:* `Y*` is compatible with `T*` and
+`unique_ptr<Y, D>::pointer` is convertible to `element_type*`.
 *Effects:* If `r.get() == nullptr`, equivalent to `shared_ptr()`.
 Otherwise, if `D` is not a reference type, equivalent to
 `shared_ptr(r.release(), r.get_deleter())`. Otherwise, equivalent to
 `shared_ptr(r.release(), ref(r.get_deleter()))`. If an exception is
 thrown, the constructor has no effect.
+#### Destructor <a id="util.smartptr.shared.dest">[[util.smartptr.shared.dest]]</a>
 ``` cpp
 ~shared_ptr();
 ```
 instances that share ownership with `*this` by one, after `*this` has
 been destroyed all `shared_ptr` instances that shared ownership with
 `*this` will report a `use_count()` that is one less than its previous
 value. — *end note*]
+#### Assignment <a id="util.smartptr.shared.assign">[[util.smartptr.shared.assign]]</a>
 ``` cpp
 shared_ptr& operator=(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 ```
 *Effects:* Equivalent to `shared_ptr(r).swap(*this)`.
 *Returns:* `*this`.
+[*Note 1*:
 The use count updates caused by the temporary object construction and
 destruction are not observable side effects, so the implementation may
 meet the effects (and the implied guarantees) via different means,
 without creating a temporary. In particular, in the example:
 *Effects:* Equivalent to `shared_ptr(std::move(r)).swap(*this)`.
 *Returns:* `*this`.
+#### Modifiers <a id="util.smartptr.shared.mod">[[util.smartptr.shared.mod]]</a>
 ``` cpp
 void swap(shared_ptr& r) noexcept;
 ```
 template<class Y, class D, class A> void reset(Y* p, D d, A a);
 ```
 *Effects:* Equivalent to `shared_ptr(p, d, a).swap(*this)`.
+#### Observers <a id="util.smartptr.shared.obs">[[util.smartptr.shared.obs]]</a>
 ``` cpp
 element_type* get() const noexcept;
 ```
 ``` cpp
 T& operator*() const noexcept;
 ```
+*Preconditions:* `get() != 0`.
 *Returns:* `*get()`.
 *Remarks:* When `T` is an array type or cv `void`, it is unspecified
 whether this member function is declared. If it is declared, it is
 unspecified what its return type is, except that the declaration
+(although not necessarily the definition) of the function shall be
+well-formed.
 ``` cpp
 T* operator->() const noexcept;
 ```
+*Preconditions:* `get() != 0`.
 *Returns:* `get()`.
 *Remarks:* When `T` is an array type, it is unspecified whether this
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
+necessarily the definition) of the function shall be well-formed.
 ``` cpp
 element_type& operator[](ptrdiff_t i) const;
 ```
+*Preconditions:* `get() != 0 && i >= 0`. If `T` is `U[N]`, `i < N`.
 *Returns:* `get()[i]`.
 *Remarks:* When `T` is not an array type, it is unspecified whether this
 member function is declared. If it is declared, it is unspecified what
 its return type is, except that the declaration (although not
+necessarily the definition) of the function shall be well-formed.
 *Throws:* Nothing.
 ``` cpp
 long use_count() const noexcept;
 *Returns:* The number of `shared_ptr` objects, `*this` included, that
 share ownership with `*this`, or `0` when `*this` is empty.
 *Synchronization:* None.
+[*Note 1*: `get() == nullptr` does not imply a specific return value of
 `use_count()`. — *end note*]
+[*Note 2*: `weak_ptr<T>::lock()` can affect the return value of
 `use_count()`. — *end note*]
+[*Note 3*: When multiple threads can affect the return value of
 `use_count()`, the result should be treated as approximate. In
 particular, `use_count() == 1` does not imply that accesses through a
 previously destroyed `shared_ptr` have in any sense
 completed. — *end note*]
 - under the equivalence relation defined by `owner_before`,
   `!a.owner_before(b) && !b.owner_before(a)`, two `shared_ptr` or
   `weak_ptr` instances are equivalent if and only if they share
   ownership or are both empty.
+#### Creation <a id="util.smartptr.shared.create">[[util.smartptr.shared.create]]</a>
+The common requirements that apply to all `make_shared`,
+`allocate_shared`, `make_shared_for_overwrite`, and
+`allocate_shared_for_overwrite` overloads, unless specified otherwise,
+are described below.
 ``` cpp
+template<class T, ...>
+  shared_ptr<T> make_shared(args);
+template<class T, class A, ...>
+  shared_ptr<T> allocate_shared(const A& a, args);
+template<class T, ...>
+  shared_ptr<T> make_shared_for_overwrite(args);
+template<class T, class A, ...>
+  shared_ptr<T> allocate_shared_for_overwrite(const A& a, args);
 ```
+*Preconditions:* `A` meets the *Cpp17Allocator* requirements
+([[cpp17.allocator]]).
+*Effects:* Allocates memory for an object of type `T` (or `U[N]` when
+`T` is `U[]`, where `N` is determined from *args* as specified by the
+concrete overload). The object is initialized from *args* as specified
+by the concrete overload. The `allocate_shared` and
+`allocate_shared_for_overwrite` templates use a copy of `a` (rebound for
+an unspecified `value_type`) to allocate memory. If an exception is
+thrown, the functions have no effect.
 *Returns:* A `shared_ptr` instance that stores and owns the address of
+the newly constructed object.
+*Ensures:* `r.get() != 0 && r.use_count() == 1`, where `r` is the return
+value.
+*Throws:* `bad_alloc`, or an exception thrown from `allocate` or from
+the initialization of the object.
+*Remarks:*
+- Implementations should perform no more than one memory allocation.
+  \[*Note 1*: This provides efficiency equivalent to an intrusive smart
   pointer. — *end note*]
+- When an object of an array type `U` is specified to have an initial
+  value of `u` (of the same type), this shall be interpreted to mean
+  that each array element of the object has as its initial value the
+  corresponding element from `u`.
+- When an object of an array type is specified to have a default initial
+  value, this shall be interpreted to mean that each array element of
+  the object has a default initial value.
+- When a (sub)object of a non-array type `U` is specified to have an
+  initial value of `v`, or `U(l...)`, where `l...` is a list of
+  constructor arguments, `make_shared` shall initialize this (sub)object
+  via the expression `::new(pv) U(v)` or `::new(pv) U(l...)`
+  respectively, where `pv` has type `void*` and points to storage
+  suitable to hold an object of type `U`.
+- When a (sub)object of a non-array type `U` is specified to have an
+  initial value of `v`, or `U(l...)`, where `l...` is a list of
+  constructor arguments, `allocate_shared` shall initialize this
+  (sub)object via the expression
+  - `allocator_traits<A2>::construct(a2, pv, v)` or
+  - `allocator_traits<A2>::construct(a2, pv, l...)`
+  respectively, where `pv` points to storage suitable to hold an object
+  of type `U` and `a2` of type `A2` is a rebound copy of the allocator
+  `a` passed to `allocate_shared` such that its `value_type` is
+  `remove_cv_t<U>`.
+- When a (sub)object of non-array type `U` is specified to have a
+  default initial value, `make_shared` shall initialize this (sub)object
+  via the expression `::new(pv) U()`, where `pv` has type `void*` and
+  points to storage suitable to hold an object of type `U`.
+- When a (sub)object of non-array type `U` is specified to have a
+  default initial value, `allocate_shared` shall initialize this
+  (sub)object via the expression
+  `allocator_traits<A2>::construct(a2, pv)`, where `pv` points to
+  storage suitable to hold an object of type `U` and `a2` of type `A2`
+  is a rebound copy of the allocator `a` passed to `allocate_shared`
+  such that its `value_type` is `remove_cv_t<U>`.
+- When a (sub)object of non-array type `U` is initialized by
+  `make_shared_for_overwrite` or `allocate_shared_for_overwrite`, it is
+  initialized via the expression `::new(pv) U`, where `pv` has type
+  `void*` and points to storage suitable to hold an object of type `U`.
+- Array elements are initialized in ascending order of their addresses.
+- When the lifetime of the object managed by the return value ends, or
+  when the initialization of an array element throws an exception, the
+  initialized elements are destroyed in the reverse order of their
+  original construction.
+- When a (sub)object of non-array type `U` that was initialized by
+  `make_shared` is to be destroyed, it is destroyed via the expression
+  `pv->~U()` where `pv` points to that object of type `U`.
+- When a (sub)object of non-array type `U` that was initialized by
+  `allocate_shared` is to be destroyed, it is destroyed via the
+  expression `allocator_traits<A2>::destroy(a2, pv)` where `pv` points
+  to that object of type `remove_cv_t<U>` and `a2` of type `A2` is a
+  rebound copy of the allocator `a` passed to `allocate_shared` such
+  that its `value_type` is `remove_cv_t<U>`.
+[*Note 1*: These functions will typically allocate more memory than
+`sizeof(T)` to allow for internal bookkeeping structures such as
 reference counts. — *end note*]
+``` cpp
+template<class T, class... Args>
+  shared_ptr<T> make_shared(Args&&... args);                    // T is not array
+template<class T, class A, class... Args>
+  shared_ptr<T> allocate_shared(const A& a, Args&&... args);    // T is not array
+```
+*Constraints:* `T` is not an array type.
+*Returns:* A `shared_ptr` to an object of type `T` with an initial value
+`T(forward<Args>(args)...)`.
+*Remarks:* The `shared_ptr` constructors called by these functions
+enable `shared_from_this` with the address of the newly constructed
+object of type `T`.
+[*Example 1*:
+``` cpp
+shared_ptr<int> p = make_shared<int>(); // shared_ptr to int()
+shared_ptr<vector<int>> q = make_shared<vector<int>>(16, 1);
+  // shared_ptr to vector of 16 elements with value 1
+```
+— *end example*]
+``` cpp
+template<class T> shared_ptr<T>
+  make_shared(size_t N);                                        // T is U[]
+template<class T, class A>
+  shared_ptr<T> allocate_shared(const A& a, size_t N);          // T is U[]
+```
+*Constraints:* `T` is of the form `U[]`.
+*Returns:* A `shared_ptr` to an object of type `U[N]` with a default
+initial value, where `U` is `remove_extent_t<T>`.
+[*Example 2*:
+``` cpp
+shared_ptr<double[]> p = make_shared<double[]>(1024);
+  // shared_ptr to a value-initialized double[1024]
+shared_ptr<double[][2][2]> q = make_shared<double[][2][2]>(6);
+  // shared_ptr to a value-initialized double[6][2][2]
+```
+— *end example*]
+``` cpp
+template<class T>
+  shared_ptr<T> make_shared();                                  // T is U[N]
+template<class T, class A>
+  shared_ptr<T> allocate_shared(const A& a);                    // T is U[N]
+```
+*Constraints:* `T` is of the form `U[N]`.
+*Returns:* A `shared_ptr` to an object of type `T` with a default
+initial value.
+[*Example 3*:
+``` cpp
+shared_ptr<double[1024]> p = make_shared<double[1024]>();
+  // shared_ptr to a value-initialized double[1024]
+shared_ptr<double[6][2][2]> q = make_shared<double[6][2][2]>();
+  // shared_ptr to a value-initialized double[6][2][2]
+```
+— *end example*]
+``` cpp
+template<class T>
+  shared_ptr<T> make_shared(size_t N,
+                            const remove_extent_t<T>& u);       // T is U[]
+template<class T, class A>
+  shared_ptr<T> allocate_shared(const A& a, size_t N,
+                                const remove_extent_t<T>& u);   // T is U[]
+```
+*Constraints:* `T` is of the form `U[]`.
+*Returns:* A `shared_ptr` to an object of type `U[N]`, where `U` is
+`remove_extent_t<T>` and each array element has an initial value of `u`.
+[*Example 4*:
+``` cpp
+shared_ptr<double[]> p = make_shared<double[]>(1024, 1.0);
+  // shared_ptr to a double[1024], where each element is 1.0
+shared_ptr<double[][2]> q = make_shared<double[][2]>(6, {1.0, 0.0});
+  // shared_ptr to a double[6][2], where each double[2] element is {1.0, 0.0}
+shared_ptr<vector<int>[]> r = make_shared<vector<int>[]>(4, {1, 2});
+  // shared_ptr to a vector<int>[4], where each vector has contents {1, 2}
+```
+— *end example*]
+``` cpp
+template<class T>
+  shared_ptr<T> make_shared(const remove_extent_t<T>& u);       // T is U[N]
+template<class T, class A>
+  shared_ptr<T> allocate_shared(const A& a,
+                                const remove_extent_t<T>& u);   // T is U[N]
+```
+*Constraints:* `T` is of the form `U[N]`.
+*Returns:* A `shared_ptr` to an object of type `T`, where each array
+element of type `remove_extent_t<T>` has an initial value of `u`.
+[*Example 5*:
+``` cpp
+shared_ptr<double[1024]> p = make_shared<double[1024]>(1.0);
+  // shared_ptr to a double[1024], where each element is 1.0
+shared_ptr<double[6][2]> q = make_shared<double[6][2]>({1.0, 0.0});
+  // shared_ptr to a double[6][2], where each double[2] element is {1.0, 0.0}
+shared_ptr<vector<int>[4]> r = make_shared<vector<int>[4]>({1, 2});
+  // shared_ptr to a vector<int>[4], where each vector has contents {1, 2}
+```
+— *end example*]
+``` cpp
+template<class T>
+  shared_ptr<T> make_shared_for_overwrite();
+template<class T, class A>
+  shared_ptr<T> allocate_shared_for_overwrite(const A& a);
+```
+*Constraints:* `T` is not an array of unknown bound.
+*Returns:* A `shared_ptr` to an object of type `T`.
+[*Example 6*:
+``` cpp
+struct X { double data[1024]; };
+shared_ptr<X> p = make_shared_for_overwrite<X>();
+  // shared_ptr to a default-initialized X, where each element in X::data has an indeterminate value
+shared_ptr<double[1024]> q = make_shared_for_overwrite<double[1024]>();
+  // shared_ptr to a default-initialized double[1024], where each element has an indeterminate value
+```
+— *end example*]
+``` cpp
+template<class T>
+  shared_ptr<T> make_shared_for_overwrite(size_t N);
+template<class T, class A>
+  shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N);
+```
+*Constraints:* `T` is an array of unknown bound.
+*Returns:* A `shared_ptr` to an object of type `U[N]`, where `U` is
+`remove_extent_t<T>`.
+[*Example 7*:
+``` cpp
+shared_ptr<double[]> p = make_shared_for_overwrite<double[]>(1024);
+  // shared_ptr to a default-initialized double[1024], where each element has an indeterminate value
+```
+— *end example*]
+#### Comparison <a id="util.smartptr.shared.cmp">[[util.smartptr.shared.cmp]]</a>
 ``` cpp
 template<class T, class U>
   bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `a.get() == b.get()`.
 ``` cpp
 template<class T>
   bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
 ```
 *Returns:* `!a`.
 ``` cpp
+template<class T, class U>
+ strong_ordering operator<=>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
+*Returns:* `compare_three_way()(a.get(), b.get())`.
+[*Note 1*: Defining a comparison function allows `shared_ptr` objects
+to be used as keys in associative containers. — *end note*]
 ``` cpp
 template<class T>
+ strong_ordering operator<=>(const shared_ptr<T>& a, nullptr_t) noexcept;
 ```
+*Returns:* `compare_three_way()(a.get(), nullptr)`.
+#### Specialized algorithms <a id="util.smartptr.shared.spec">[[util.smartptr.shared.spec]]</a>
 ``` cpp
 template<class T>
   void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
+#### Casts <a id="util.smartptr.shared.cast">[[util.smartptr.shared.cast]]</a>
 ``` cpp
 template<class T, class U>
   shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
+template<class T, class U>
+  shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
+*Mandates:* The expression `static_cast<T*>((U*)nullptr)` is
+well-formed.
 *Returns:*
 ``` cpp
+shared_ptr<T>(R, static_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
+where *`R`* is `r` for the first overload, and `std::move(r)` for the
+second.
+[*Note 1*: The seemingly equivalent expression
 `shared_ptr<T>(static_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
+template<class T, class U>
+  shared_ptr<T> dynamic_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
+*Mandates:* The expression `dynamic_cast<T*>((U*)nullptr)` is
+well-formed. The expression
+`dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())` is well
+formed.
+*Preconditions:* The expression
+`dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())` has
+well-defined behavior.
 *Returns:*
 - When `dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())`
+  returns a non-null value `p`, `shared_ptr<T>(`*`R`*`, p)`, where *`R`*
+  is `r` for the first overload, and `std::move(r)` for the second.
 - Otherwise, `shared_ptr<T>()`.
+[*Note 2*: The seemingly equivalent expression
 `shared_ptr<T>(dynamic_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
+template<class T, class U>
+  shared_ptr<T> const_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
+*Mandates:* The expression `const_cast<T*>((U*)nullptr)` is well-formed.
 *Returns:*
 ``` cpp
+shared_ptr<T>(R, const_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
+where *`R`* is `r` for the first overload, and `std::move(r)` for the
+second.
+[*Note 3*: The seemingly equivalent expression
 `shared_ptr<T>(const_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
 ``` cpp
 template<class T, class U>
   shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
+template<class T, class U>
+  shared_ptr<T> reinterpret_pointer_cast(shared_ptr<U>&& r) noexcept;
 ```
+*Mandates:* The expression `reinterpret_cast<T*>((U*)nullptr)` is
+well-formed.
 *Returns:*
 ``` cpp
+shared_ptr<T>(R, reinterpret_cast<typename shared_ptr<T>::element_type*>(r.get()))
 ```
+where *`R`* is `r` for the first overload, and `std::move(r)` for the
+second.
+[*Note 4*: The seemingly equivalent expression
 `shared_ptr<T>(reinterpret_cast<T*>(r.get()))` will eventually result in
 undefined behavior, attempting to delete the same object
 twice. — *end note*]
+#### `get_deleter` <a id="util.smartptr.getdeleter">[[util.smartptr.getdeleter]]</a>
 ``` cpp
 template<class D, class T>
   D* get_deleter(const shared_ptr<T>& p) noexcept;
 ```
 *Returns:* If `p` owns a deleter `d` of type cv-unqualified `D`, returns
 `addressof(d)`; otherwise returns `nullptr`. The returned pointer
 remains valid as long as there exists a `shared_ptr` instance that owns
 `d`.
+[*Note 1*: It is unspecified whether the pointer remains valid longer
 than that. This can happen if the implementation doesn’t destroy the
 deleter until all `weak_ptr` instances that share ownership with `p`
 have been destroyed. — *end note*]
+#### I/O <a id="util.smartptr.shared.io">[[util.smartptr.shared.io]]</a>
 ``` cpp
 template<class E, class T, class Y>
   basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);
 ```

Diff to HTML by rtfpessoa