[util.sharedptr] - C++20 → C++23

Files changed (1) hide show

tmp/tmprx10qlgw/{from.md → to.md} +1247 -0

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

	@@ -0,0 +1,1247 @@

+### Shared-ownership pointers <a id="util.sharedptr">[[util.sharedptr]]</a>
+#### Class `bad_weak_ptr` <a id="util.smartptr.weak.bad">[[util.smartptr.weak.bad]]</a>
+``` cpp
+namespace std {
+  class bad_weak_ptr : public exception {
+  public:
+    // 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>
+##### General <a id="util.smartptr.shared.general">[[util.smartptr.shared.general]]</a>
+The `shared_ptr` class template stores a pointer, usually obtained via
+`new`. `shared_ptr` implements semantics of shared ownership; the last
+remaining owner of the pointer is responsible for destroying the object,
+or otherwise releasing the resources associated with the stored pointer.
+A `shared_ptr` is said to be empty if it does not own a pointer.
+``` cpp
+namespace std {
+  template<class T> class shared_ptr {
+  public:
+    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` can be a function type. — *end note*]
+[*Example 1*:
+``` cpp
+if (shared_ptr<X> px = dynamic_pointer_cast<X>(py)) {
+  // do something with px
+}
+```
+— *end example*]
+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
+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
+not an array type, the expression `delete p` is well-formed and `Y*` is
+convertible to `T*`.
+*Mandates:* `Y` is a complete type.
+*Preconditions:* The expression `delete[] p`, when `T` is an array type,
+or `delete p`, when `T` is not an array type, has well-defined behavior,
+and does not throw exceptions.
+*Effects:* When `T` is not an array type, constructs a `shared_ptr`
+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 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:
+- 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 [[allocator.requirements.general]].
+*Effects:* Constructs a `shared_ptr` object that owns the object `p` and
+the deleter `d`. When `T` is not an array type, the first and second
+constructors enable `shared_from_this` with `p`. The second and fourth
+constructors shall use a copy of `a` to allocate memory for internal
+use. If an exception is thrown, `d(p)` is called.
+*Ensures:* `use_count() == 1 && get() == p`.
+*Throws:* `bad_alloc`, or an *implementation-defined* exception when a
+resource other than memory cannot be obtained.
+``` cpp
+template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
+template<class Y> shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
+```
+*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*: Use of this constructor leads to a dangling pointer unless
+`p` remains valid at least until the ownership group of `r` is
+destroyed. — *end note*]
+[*Note 2*: This constructor allows creation of an empty `shared_ptr`
+instance with a non-null stored pointer. — *end note*]
+``` cpp
+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` 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
+`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(), std::move(r.get_deleter()))`. Otherwise,
+equivalent to `shared_ptr(r.release(), ref(r.get_deleter()))`. If an
+exception is thrown, the constructor has no effect.
+##### Destructor <a id="util.smartptr.shared.dest">[[util.smartptr.shared.dest]]</a>
+``` cpp
+~shared_ptr();
+```
+*Effects:*
+- If `*this` is empty or shares ownership with another `shared_ptr`
+  instance (`use_count() > 1`), there are no side effects.
+- Otherwise, if `*this` owns an object `p` and a deleter `d`, `d(p)` is
+  called.
+- Otherwise, `*this` owns a pointer `p`, and `delete p` is called.
+[*Note 2*: Since the destruction of `*this` decreases the number of
+instances that share ownership with `*this` by one, after `*this` has
+been destroyed all `shared_ptr` instances that shared ownership with
+`*this` will report a `use_count()` that is one less than its previous
+value. — *end note*]
+##### Assignment <a id="util.smartptr.shared.assign">[[util.smartptr.shared.assign]]</a>
+``` cpp
+shared_ptr& operator=(const shared_ptr& r) noexcept;
+template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
+```
+*Effects:* Equivalent to `shared_ptr(r).swap(*this)`.
+*Returns:* `*this`.
+[*Note 3*:
+The use count updates caused by the temporary object construction and
+destruction are not observable side effects, so the implementation can
+meet the effects (and the implied guarantees) via different means,
+without creating a temporary. In particular, in the example:
+``` cpp
+shared_ptr<int> p(new int);
+shared_ptr<void> q(p);
+p = p;
+q = p;
+```
+both assignments can be no-ops.
+— *end note*]
+``` cpp
+shared_ptr& operator=(shared_ptr&& r) noexcept;
+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()`.
+*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() != nullptr`.
+*Returns:* `get()`.
+*Remarks:* When `T` is an array type, it is unspecified whether this
+member function is declared. If it is declared, it is unspecified what
+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.
+*Remarks:* When `T` is not an array type, it is unspecified whether this
+member function is declared. If it is declared, it is unspecified what
+its return type is, except that the declaration (although not
+necessarily the definition) of the function shall be well-formed.
+``` cpp
+long use_count() const noexcept;
+```
+*Synchronization:* None.
+*Returns:* The number of `shared_ptr` objects, `*this` included, that
+share ownership with `*this`, or `0` when `*this` is empty.
+[*Note 4*: `get() == nullptr` does not imply a specific return value of
+`use_count()`. — *end note*]
+[*Note 5*: `weak_ptr<T>::lock()` can affect the return value of
+`use_count()`. — *end note*]
+[*Note 6*: When multiple threads might affect the return value of
+`use_count()`, the result is approximate. In particular,
+`use_count() == 1` does not imply that accesses through a previously
+destroyed `shared_ptr` have in any sense completed. — *end note*]
+``` cpp
+explicit operator bool() const noexcept;
+```
+*Returns:* `get() != nullptr`.
+``` cpp
+template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
+template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
+```
+*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]].
+*Effects:* Allocates memory for an object of type `T` (or `U[N]` when
+`T` is `U[]`, where `N` is determined from *args* as specified by the
+concrete overload). The object is initialized from *args* as specified
+by the concrete overload. The `allocate_shared` and
+`allocate_shared_for_overwrite` templates use a copy of `a` (rebound for
+an unspecified `value_type`) to allocate memory. If an exception is
+thrown, the functions have no effect.
+*Ensures:* `r.get() != nullptr && r.use_count() == 1`, where `r` is the
+return value.
+*Returns:* A `shared_ptr` instance that stores and owns the address of
+the newly constructed object.
+*Throws:* `bad_alloc`, or an exception thrown from `allocate` or from
+the initialization of the object.
+*Remarks:*
+- Implementations should perform no more than one memory allocation.
+  \[*Note 3*: This provides efficiency equivalent to an intrusive smart
+  pointer. — *end note*]
+- When an object of an array type `U` is specified to have an initial
+  value of `u` (of the same type), this shall be interpreted to mean
+  that each array element of the object has as its initial value the
+  corresponding element from `u`.
+- 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 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
+`T(std::forward<Args>(args)...)`.
+*Remarks:* The `shared_ptr` constructors called by these functions
+enable `shared_from_this` with the address of the newly constructed
+object of type `T`.
+[*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 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.
+*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 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
+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 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:*
+``` 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 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>
+  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 12*: The seemingly equivalent expression
+`shared_ptr<T>(reinterpret_cast<T*>(r.get()))` will eventually result in
+undefined behavior, attempting to delete the same object
+twice. — *end note*]
+##### `get_deleter` <a id="util.smartptr.getdeleter">[[util.smartptr.getdeleter]]</a>
+``` cpp
+template<class D, class T>
+  D* get_deleter(const shared_ptr<T>& p) noexcept;
+```
+*Returns:* If `p` owns a deleter `d` of type cv-unqualified `D`, returns
+`addressof(d)`; otherwise returns `nullptr`. The returned pointer
+remains valid as long as there exists a `shared_ptr` instance that owns
+`d`.
+[*Note 13*: It is unspecified whether the pointer remains valid longer
+than that. This can happen if the implementation doesn’t destroy the
+deleter until all `weak_ptr` instances that share ownership with `p`
+have been destroyed. — *end note*]
+##### I/O <a id="util.smartptr.shared.io">[[util.smartptr.shared.io]]</a>
+``` cpp
+template<class E, class T, class Y>
+  basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);
+```
+*Effects:* As if by: `os << p.get();`
+*Returns:* `os`.
+#### Class template `weak_ptr` <a id="util.smartptr.weak">[[util.smartptr.weak]]</a>
+##### General <a id="util.smartptr.weak.general">[[util.smartptr.weak.general]]</a>
+The `weak_ptr` class template stores a weak reference to an object that
+is already managed by a `shared_ptr`. To access the object, a `weak_ptr`
+can be converted to a `shared_ptr` using the member function `lock`.
+``` cpp
+namespace std {
+  template<class T> class weak_ptr {
+  public:
+    using element_type = remove_extent_t<T>;
+    // [util.smartptr.weak.const], constructors
+    constexpr weak_ptr() noexcept;
+    template<class Y>
+      weak_ptr(const shared_ptr<Y>& r) noexcept;
+    weak_ptr(const weak_ptr& r) noexcept;
+    template<class Y>
+      weak_ptr(const weak_ptr<Y>& r) noexcept;
+    weak_ptr(weak_ptr&& r) noexcept;
+    template<class Y>
+      weak_ptr(weak_ptr<Y>&& r) noexcept;
+    // [util.smartptr.weak.dest], destructor
+    ~weak_ptr();
+    // [util.smartptr.weak.assign], assignment
+    weak_ptr& operator=(const weak_ptr& r) noexcept;
+    template<class Y>
+      weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
+    template<class Y>
+      weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
+    weak_ptr& operator=(weak_ptr&& r) noexcept;
+    template<class Y>
+      weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
+    // [util.smartptr.weak.mod], modifiers
+    void swap(weak_ptr& r) noexcept;
+    void reset() noexcept;
+    // [util.smartptr.weak.obs], observers
+    long use_count() const noexcept;
+    bool expired() const noexcept;
+    shared_ptr<T> lock() const noexcept;
+    template<class U>
+      bool owner_before(const shared_ptr<U>& b) const noexcept;
+    template<class U>
+      bool owner_before(const weak_ptr<U>& b) const noexcept;
+  };
+  template<class T>
+    weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
+}
+```
+Specializations of `weak_ptr` shall be *Cpp17CopyConstructible* and
+*Cpp17CopyAssignable*, allowing their use in standard containers. The
+template parameter `T` of `weak_ptr` may be an incomplete type.
+##### Constructors <a id="util.smartptr.weak.const">[[util.smartptr.weak.const]]</a>
+``` cpp
+constexpr weak_ptr() noexcept;
+```
+*Effects:* Constructs an empty `weak_ptr` object that stores a null
+pointer value.
+*Ensures:* `use_count() == 0`.
+``` cpp
+weak_ptr(const weak_ptr& r) noexcept;
+template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
+template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
+```
+*Constraints:* For the second and third constructors, `Y*` is compatible
+with `T*`.
+*Effects:* If `r` is empty, constructs an empty `weak_ptr` object that
+stores a null pointer value; otherwise, constructs a `weak_ptr` object
+that shares ownership with `r` and stores a copy of the pointer stored
+in `r`.
+*Ensures:* `use_count() == r.use_count()`.
+``` cpp
+weak_ptr(weak_ptr&& r) noexcept;
+template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
+```
+*Constraints:* For the second constructor, `Y*` is compatible with `T*`.
+*Effects:* Move constructs a `weak_ptr` instance from `r`.
+*Ensures:* `*this` contains the old value of `r`. `r` is empty, stores a
+null pointer value, and `r.use_count() == 0`.
+##### Destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
+``` cpp
+~weak_ptr();
+```
+*Effects:* Destroys this `weak_ptr` object but has no effect on the
+object its stored pointer points to.
+##### Assignment <a id="util.smartptr.weak.assign">[[util.smartptr.weak.assign]]</a>
+``` cpp
+weak_ptr& operator=(const weak_ptr& r) noexcept;
+template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
+template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
+```
+*Effects:* Equivalent to `weak_ptr(r).swap(*this)`.
+*Returns:* `*this`.
+*Remarks:* The implementation may meet the effects (and the implied
+guarantees) via different means, without creating a temporary object.
+``` cpp
+weak_ptr& operator=(weak_ptr&& r) noexcept;
+template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
+```
+*Effects:* Equivalent to `weak_ptr(std::move(r)).swap(*this)`.
+*Returns:* `*this`.
+##### Modifiers <a id="util.smartptr.weak.mod">[[util.smartptr.weak.mod]]</a>
+``` cpp
+void swap(weak_ptr& r) noexcept;
+```
+*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>
+The class template `owner_less` allows ownership-based mixed comparisons
+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;
+  };
+}
+```
+`operator()(x, y)` returns `x.owner_before(y)`.
+[*Note 1*:
+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`.
+[*Example 1*:
+``` cpp
+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`.

Diff to HTML by rtfpessoa