[util.smartptr] - C++14 → C++17

Files changed (1) hide show

tmp/tmpzaxqa4nt/{from.md → to.md} +377 -291

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

@@ -1,93 +1,96 @@
 ### Shared-ownership pointers <a id="util.smartptr">[[util.smartptr]]</a>
-#### Class `bad_weak_ptr` <a id="util.smartptr.weakptr">[[util.smartptr.weakptr]]</a>
 ``` cpp
 namespace std {
-  class bad_weak_ptr: public std::exception {
   public:
     bad_weak_ptr() noexcept;
   };
-} // namespace std
 ```
 An exception of type `bad_weak_ptr` is thrown by the `shared_ptr`
 constructor taking a `weak_ptr`.
 ``` cpp
 bad_weak_ptr() noexcept;
 ```
-*Postconditions:* `what()` returns `"bad_weak_ptr"`.
 #### 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.
-A `shared_ptr` object is *empty* if it does not own a pointer.
 ``` cpp
 namespace std {
   template<class T> class shared_ptr {
   public:
- typedef T element_type;
-    // [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, T* 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> shared_ptr(auto_ptr<Y>&& r);
     template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
-    constexpr shared_ptr(nullptr_t) : 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> shared_ptr& operator=(auto_ptr<Y>&& r);
     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:
- T* get() const noexcept;
     T& operator*() const noexcept;
     T* operator->() const noexcept;
     long use_count() const noexcept;
-    bool unique() const noexcept;
     explicit operator bool() const noexcept;
-    template<class U> bool owner_before(shared_ptr<U> const& b) const;
-    template<class U> bool owner_before(weak_ptr<U> const& b) const;
   };
   // [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>
@@ -122,218 +125,252 @@ namespace std {
   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;
-  // [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);
-} // namespace std
 ```
 Specializations of `shared_ptr` shall be `CopyConstructible`,
 `CopyAssignable`, and `LessThanComparable`, allowing their use in
 standard containers. Specializations of `shared_ptr` shall be
-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.
 ``` cpp
 if (shared_ptr<X> px = dynamic_pointer_cast<X>(py)) {
   // do something with px
 }
 ```
 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.
 ##### `shared_ptr` constructors <a id="util.smartptr.shared.const">[[util.smartptr.shared.const]]</a>
 ``` 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:* `p` shall be convertible to `T*`. `Y` shall be a complete
-type. The expression `delete p` shall be well formed, shall have well
-defined behavior, and shall not throw exceptions.
-*Effects:* Constructs a `shared_ptr` object that *owns* the pointer `p`.
 *Postconditions:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
-If an exception is thrown, `delete p` is called.
 ``` 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:* `p` shall be convertible to `T*`. `D` shall be
-`CopyConstructible`. The copy constructor and destructor of ` D` shall
-not throw exceptions. The expression `d(p)` shall be well formed, shall
-have well defined behavior, and shall not throw exceptions. `A` shall be
-an allocator ([[allocator.requirements]]). The copy constructor and
-destructor of `A` shall not throw exceptions.
-*Effects:* Constructs a `shared_ptr` object that *owns* the object `p`
-and the deleter `d`. The second and fourth constructors shall use a copy
-of `a` to allocate memory for internal use.
 *Postconditions:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
-If an exception is thrown, `d(p)` is called.
 ``` cpp
-template<class Y> shared_ptr(const shared_ptr<Y>& r, T* p) noexcept;
 ```
-*Effects:* Constructs a `shared_ptr` instance that stores `p` and
-*shares ownership* with `r`.
-*Postconditions:* `get() == p && use_count() == r.use_count()`
-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.
-This constructor allows creation of an *empty* `shared_ptr` instance
-with a non-null stored pointer.
 ``` cpp
 shared_ptr(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
 ```
-The second constructor shall not participate in overload resolution
-unless `Y*` is implicitly convertible to `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;
 ```
-The second constructor shall not participate in overload resolution
-unless `Y*` is convertible to `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);
 ```
-*Requires:* `Y*` shall be convertible to `T*`.
-*Effects:* Constructs a `shared_ptr` object that *shares ownership* with
-`r` and stores a copy of the pointer stored in `r`.
 *Postconditions:* `use_count() == r.use_count()`.
 *Throws:* `bad_weak_ptr` when `r.expired()`.
-If an exception is thrown, the constructor has no effect.
-``` cpp
-template<class Y> shared_ptr(auto_ptr<Y>&& r);
-```
-*Requires:* `r.release()` shall be convertible to `T*`. `Y` shall be a
-complete type. The expression `delete r.release()` shall be well formed,
-shall have well defined behavior, and shall not throw exceptions.
-*Effects:* Constructs a `shared_ptr` object that stores and *owns*
-`r.release()`.
-*Postconditions:* `use_count() == 1` `&&` `r.get() == nullptr`.
-*Throws:* `bad_alloc`, or an *implementation-defined* exception when a
-resource other than memory could not be obtained.
-If an exception is thrown, the constructor has no effect.
 ``` cpp
 template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
 ```
-*Effects:* Equivalent to `shared_ptr(r.release(), r.get_deleter())` when
-`D` is not a reference type, otherwise
-`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();
 ```
 *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.
-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.
 ##### `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;
-template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r);
 ```
 *Effects:* Equivalent to `shared_ptr(r).swap(*this)`.
 *Returns:* `*this`.
 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:
@@ -344,10 +381,12 @@ p = p;
 q = p;
 ```
 both assignments may be no-ops.
 ``` cpp
 shared_ptr& operator=(shared_ptr&& r) noexcept;
 template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
 ```
@@ -359,11 +398,11 @@ template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
 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;
@@ -396,64 +435,87 @@ 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
-T* get() const noexcept;
 ```
-*Returns:* the stored pointer.
 ``` cpp
 T& operator*() const noexcept;
 ```
 *Requires:* `get() != 0`.
 *Returns:* `*get()`.
-*Remarks:* When `T` is `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()`.
 ``` 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*.
-`use_count()` is not necessarily efficient.
-``` cpp
-bool unique() const noexcept;
-```
-*Returns:* `use_count() == 1`.
-`unique()` may be faster than `use_count()`. If you are using `unique()`
-to implement copy on write, do not rely on a specific value when
-`get() == nullptr`.
 ``` cpp
 explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != 0`.
 ``` cpp
-template<class U> bool owner_before(shared_ptr<U> const& b) const;
-template<class U> bool owner_before(weak_ptr<U> const& b) const;
 ```
 *Returns:* An unspecified value such that
 - `x.owner_before(y)` defines a strict weak ordering as defined
@@ -464,59 +526,66 @@ template<class U> bool owner_before(weak_ptr<U> const& b) const;
   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:* Implementations should perform no more than one memory
-allocation. This provides efficiency equivalent to an intrusive smart
-pointer.
-These functions will typically allocate more memory than `sizeof(T)` to
-allow for internal bookkeeping structures such as the reference counts.
 ##### `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<V>()(a.get(), b.get())`, where `V` is the composite
-pointer type (Clause  [[expr]]) of `T*` and `U*`.
-Defining a comparison operator allows `shared_ptr` objects to be used as
-keys in associative containers.
 ``` cpp
 template <class T>
   bool operator==(const shared_ptr<T>& a, nullptr_t) noexcept;
 template <class T>
@@ -540,12 +609,13 @@ template <class T>
 template <class T>
   bool operator<(nullptr_t, const shared_ptr<T>& a) noexcept;
 ```
 *Returns:* The first function template returns
-`less<T*>()(a.get(), nullptr)`. The second function template returns
-`less<T*>()(nullptr, a.get())`.
 ``` cpp
 template <class T>
   bool operator>(const shared_ptr<T>& a, nullptr_t) noexcept;
 template <class T>
@@ -576,94 +646,118 @@ template <class T>
 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*>(r.get())` shall be well
 formed.
-*Returns:* If `r` is *empty*, an *empty* `shared_ptr<T>`; otherwise, a
-`shared_ptr<T>` object that stores `static_cast<T*>(r.get())` and
-*shares ownership* with `r`.
-*Postconditions:* `w.get() == static_cast<T*>(r.get())` and
-`w.use_count() == r.use_count()`, where `w` is the return value.
-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.
 ``` cpp
-template<class T, class U> shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
 ```
-*Requires:* The expression `dynamic_cast<T*>(r.get())` shall be well
 formed and shall have well defined behavior.
 *Returns:*
-- When `dynamic_cast<T*>(r.get())` returns a nonzero value, a
- `shared_ptr<T>` object that stores a copy of it and *shares ownership*
-  with `r`;
-- Otherwise, an *empty* `shared_ptr<T>` object.
-`w.get() == dynamic_cast<T*>(r.get())`, where `w` is the return value.
-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.
 ``` cpp
-template<class T, class U> shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
 ```
-*Requires:* The expression `const_cast<T*>(r.get())` shall be well
-formed.
-*Returns:* If `r` is empty, an empty `shared_ptr<T>`; otherwise, a
-`shared_ptr<T>` object that stores `const_cast<T*>(r.get())` and shares
-ownership with `r`.
-*Postconditions:* `w.get() == const_cast<T*>(r.get())` and
-`w.use_count() == r.use_count()`, where `w` is the return value.
-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.
-##### 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 `&d`; otherwise returns `nullptr`. The returned pointer remains
-valid as long as there exists a `shared_ptr` instance that owns `d`. 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.
 ##### `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, shared_ptr<Y> const& p);
 ```
-*Effects:* `os << p.get();`.
 *Returns:* `os`.
 #### Class template `weak_ptr` <a id="util.smartptr.weak">[[util.smartptr.weak]]</a>
@@ -673,27 +767,27 @@ can be converted to a `shared_ptr` using the member function `lock`.
 ``` cpp
 namespace std {
   template<class T> class weak_ptr {
   public:
- typedef T element_type;
     // [util.smartptr.weak.const], constructors
     constexpr weak_ptr() noexcept;
-    template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept;
-    weak_ptr(weak_ptr const& r) noexcept;
-    template<class Y> weak_ptr(weak_ptr<Y> const& 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=(weak_ptr const& r) noexcept;
-    template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r) noexcept;
-    template<class Y> weak_ptr& operator=(shared_ptr<Y> const& 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;
@@ -701,17 +795,20 @@ namespace std {
     // [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(shared_ptr<U> const& b) const;
-    template<class U> bool owner_before(weak_ptr<U> const& b) const;
   };
   // [util.smartptr.weak.spec], specialized algorithms
   template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
-} // namespace std
 ```
 Specializations of `weak_ptr` shall be `CopyConstructible` and
 `CopyAssignable`, allowing their use in standard containers. The
 template parameter `T` of `weak_ptr` may be an incomplete type.
@@ -720,41 +817,41 @@ template parameter `T` of `weak_ptr` may be an incomplete type.
 ``` cpp
 constexpr weak_ptr() noexcept;
 ```
-*Effects:* Constructs an *empty* `weak_ptr` object.
 *Postconditions:* `use_count() == 0`.
 ``` cpp
 weak_ptr(const weak_ptr& r) noexcept;
 template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
 template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
 ```
-The second and third constructors shall not participate in overload
-resolution unless `Y*` is implicitly convertible to `T*`.
-*Effects:* If `r` is *empty*, constructs an *empty* `weak_ptr` object;
-otherwise, constructs a `weak_ptr` object that *shares ownership* with
-`r` and stores a copy of the pointer stored in `r`.
 *Postconditions:* `use_count() == r.use_count()`.
 ``` cpp
 weak_ptr(weak_ptr&& r) noexcept;
 template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
 ```
-The second constructor shall not participate in overload resolution
-unless `Y*` is implicitly convertible to `T*`.
-*Effects:* Move-constructs a `weak_ptr` instance from `r`.
 *Postconditions:* `*this` shall contain the old value of `r`. `r` shall
-be *empty*. `r.use_count() == 0`.
 ##### `weak_ptr` destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
 ``` cpp
 ~weak_ptr();
@@ -805,33 +902,29 @@ void reset() noexcept;
 ``` cpp
 long use_count() const noexcept;
 ```
-*Returns:* `0` if `*this` is *empty*; otherwise, the number of
-`shared_ptr` instances that *share ownership* with `*this`.
-`use_count()` is not necessarily efficient.
 ``` cpp
 bool expired() const noexcept;
 ```
 *Returns:* `use_count() == 0`.
-`expired()` may be faster than `use_count()`.
 ``` 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(shared_ptr<U> const& b) const;
-template<class U> bool owner_before(weak_ptr<U> const& b) const;
 ```
 *Returns:* An unspecified value such that
 - `x.owner_before(y)` defines a strict weak ordering as defined
@@ -842,11 +935,12 @@ template<class U> bool owner_before(weak_ptr<U> const& b) const;
   ownership or are both empty.
 ##### `weak_ptr` specialized algorithms <a id="util.smartptr.weak.spec">[[util.smartptr.weak.spec]]</a>
 ``` cpp
-template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
 #### Class template `owner_less` <a id="util.smartptr.ownerless">[[util.smartptr.ownerless]]</a>
@@ -854,130 +948,125 @@ template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 The class template `owner_less` allows ownership-based mixed comparisons
 of shared and weak pointers.
 ``` cpp
 namespace std {
-  template<class T> struct owner_less;
   template<class T> struct owner_less<shared_ptr<T>> {
- typedef bool result_type;
- typedef shared_ptr<T> first_argument_type;
- typedef shared_ptr<T> second_argument_type;
-    bool operator()(shared_ptr<T> const&, shared_ptr<T> const&) const;
-    bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const;
-    bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const;
   };
   template<class T> struct owner_less<weak_ptr<T>> {
- typedef bool result_type;
- typedef weak_ptr<T> first_argument_type;
- typedef weak_ptr<T> second_argument_type;
-    bool operator()(weak_ptr<T> const&, weak_ptr<T> const&) const;
-    bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const;
-    bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const;
   };
 }
 ```
-`operator()(x,y)` shall return `x.owner_before(y)`. Note that
 - `operator()` defines a strict weak ordering as defined in
   [[alg.sorting]];
 - under the equivalence relation defined by `operator()`,
   `!operator()(a, b) && !operator()(b, a)`, two `shared_ptr` or
   `weak_ptr` instances are equivalent if and only if they share
   ownership or are both empty.
 #### 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`.
 ``` 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 < q ) && !(q < p)); // p and q share ownership
 }
 ```
 ``` cpp
 namespace std {
   template<class T> class enable_shared_from_this {
   protected:
     constexpr enable_shared_from_this() noexcept;
-    enable_shared_from_this(enable_shared_from_this const&) noexcept;
-    enable_shared_from_this& operator=(enable_shared_from_this const&) noexcept;
     ~enable_shared_from_this();
   public:
     shared_ptr<T> shared_from_this();
     shared_ptr<T const> shared_from_this() const;
   };
-} // namespace std
 ```
 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:* Constructs an `enable_shared_from_this<T>` object.
 ``` cpp
 enable_shared_from_this<T>& operator=(const enable_shared_from_this<T>&) noexcept;
 ```
 *Returns:* `*this`.
-``` cpp
-~enable_shared_from_this();
-```
-*Effects:* Destroys `*this`.
 ``` cpp
 shared_ptr<T>       shared_from_this();
 shared_ptr<T const> shared_from_this() const;
 ```
-*Requires:* `enable_shared_from_this<T>` shall be an accessible base
-class of `T`. `*this` shall be a subobject of an object `t` of type `T`.
-There shall be at least one `shared_ptr` instance `p` that *owns* `&t`.
-*Returns:* A `shared_ptr<T>` object `r` that *shares ownership with*
-`p`.
-*Postconditions:* `r.get() == this`.
-A possible implementation is shown below:
 ``` cpp
-template<class T> class enable_shared_from_this {
-private:
-  weak_ptr<T> __weak_this;
-protected:
-  constexpr enable_shared_from_this() : __weak_this() { }
-  enable_shared_from_this(enable_shared_from_this const &) { }
-  enable_shared_from_this& operator=(enable_shared_from_this const &) { return *this; }
-  ~enable_shared_from_this() { }
-public:
-  shared_ptr<T> shared_from_this() { return shared_ptr<T>(__weak_this); }
-  shared_ptr<T const> shared_from_this() const { return shared_ptr<T const>(__weak_this); }
-};
 ```
-The `shared_ptr` constructors that create unique pointers can detect the
-presence of an `enable_shared_from_this` base and assign the newly
-created `shared_ptr` to its `__weak_this` member.
 #### `shared_ptr` atomic access <a id="util.smartptr.shared.atomic">[[util.smartptr.shared.atomic]]</a>
 Concurrent access to a `shared_ptr` object from multiple threads does
 not introduce a data race if the access is done exclusively via the
@@ -1029,11 +1118,11 @@ template<class T>
   void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
 ```
 *Requires:* `p` shall not be null.
-*Effects:* `atomic_store_explicit(p, r, memory_order_seq_cst)`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
@@ -1043,11 +1132,11 @@ template<class T>
 *Requires:* `p` shall not be null.
 *Requires:* `mo` shall not be `memory_order_acquire` or
 `memory_order_acq_rel`.
-*Effects:* `p->swap(r)`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
@@ -1060,43 +1149,46 @@ template<class T>
 *Throws:* Nothing.
 ``` cpp
 template<class T>
-  shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r,
-                                         memory_order mo);
 ```
 *Requires:* `p` shall not be null.
-*Effects:* `p->swap(r)`.
 *Returns:* The previous value of `*p`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
-  bool atomic_compare_exchange_weak(
-    shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
 ```
 *Requires:* `p` shall not be null and `v` shall not be null.
 *Returns:*
-`atomic_compare_exchange_weak_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
-  bool atomic_compare_exchange_strong(
-    shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
 ```
-*Returns:* `atomic_compare_exchange_strong_explicit(p, v, w,`
-`memory_order_seq_cst, memory_order_seq_cst)`.
 ``` cpp
 template<class T>
   bool atomic_compare_exchange_weak_explicit(
     shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
@@ -1105,49 +1197,43 @@ template<class T>
   bool atomic_compare_exchange_strong_explicit(
     shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
     memory_order success, memory_order failure);
 ```
-*Requires:* `p` shall not be null and `v` shall not be null.
-*Requires:* `failure` shall not be `memory_order_release`,
-`memory_order_acq_rel`, or stronger than `success`.
 *Effects:* If `*p` is equivalent to `*v`, assigns `w` to `*p` and has
 synchronization semantics corresponding to the value of `success`,
 otherwise assigns `*p` to `*v` and has synchronization semantics
 corresponding to the value of `failure`.
 *Returns:* `true` if `*p` was equivalent to `*v`, `false` otherwise.
 *Throws:* Nothing.
-*Remarks:* two `shared_ptr` objects are equivalent if they store the
-same pointer value and share ownership.
-*Remarks:* the weak forms may fail spuriously.
-See  [[atomics.types.operations]].
 #### Smart pointer hash support <a id="util.smartptr.hash">[[util.smartptr.hash]]</a>
 ``` cpp
 template <class T, class D> struct hash<unique_ptr<T, D>>;
 ```
-The template specialization shall meet the requirements of class
-template `hash` ([[unord.hash]]). For an object `p` of type `UP`, where
-`UP` is `unique_ptr<T, D>`, `hash<UP>()(p)` shall evaluate to the same
-value as `hash<typename UP::pointer>()(p.get())`.
-*Requires:* The specialization `hash<typename UP::pointer>` shall be
-well-formed and well-defined, and shall meet the requirements of class
-template `hash` ([[unord.hash]]).
 ``` cpp
 template <class T> struct hash<shared_ptr<T>>;
 ```
-The template specialization shall meet the requirements of class
-template `hash` ([[unord.hash]]). For an object `p` of type
-`shared_ptr<T>`, `hash<shared_ptr<T> >()(p)` shall evaluate to the same
-value as `hash<T*>()(p.get())`.

 ### Shared-ownership pointers <a id="util.smartptr">[[util.smartptr]]</a>
+#### Class `bad_weak_ptr` <a id="util.smartptr.weak.bad">[[util.smartptr.weak.bad]]</a>
 ``` cpp
 namespace std {
+  class bad_weak_ptr : public exception {
   public:
     bad_weak_ptr() noexcept;
   };
+}
 ```
 An exception of type `bad_weak_ptr` is thrown by the `shared_ptr`
 constructor taking a `weak_ptr`.
 ``` cpp
 bad_weak_ptr() noexcept;
 ```
+*Postconditions:* `what()` returns an *implementation-defined* NTBS.
 #### Class template `shared_ptr` <a id="util.smartptr.shared">[[util.smartptr.shared]]</a>
 The `shared_ptr` class template stores a pointer, usually obtained via
 `new`. `shared_ptr` implements semantics of shared ownership; the last
 remaining owner of the pointer is responsible for destroying the object,
 or otherwise releasing the resources associated with the stored pointer.
+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;
     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>
   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)) {
   // 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 [[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();
 ```
 *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 1*: Since the destruction of `*this` decreases the number of
+instances that share ownership with `*this` by one, after `*this` has
+been destroyed all `shared_ptr` instances that shared ownership with
+`*this` will report a `use_count()` that is one less than its previous
+value. — *end note*]
 ##### `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:
 q = p;
 ```
 both assignments may be no-ops.
+— *end note*]
 ``` cpp
 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);
 ```
 *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;
 *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;
 ```
+*Returns:* The stored pointer.
 ``` 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;
 ```
+*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*]
 ``` cpp
 explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != 0`.
 ``` cpp
+template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
+template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
 ```
 *Returns:* An unspecified value such that
 - `x.owner_before(y)` defines a strict weak ordering as defined
   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>
 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>
 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;
 ```
+*Returns:* If `p` owns a deleter `d` of type cv-unqualified `D`, returns
+`addressof(d)`; otherwise returns `nullptr`. The returned pointer
+remains valid as long as there exists a `shared_ptr` instance that owns
+`d`.
+[*Note 14*: It is unspecified whether the pointer remains valid longer
+than that. This can happen if the implementation doesn’t destroy the
+deleter until all `weak_ptr` instances that share ownership with `p`
+have been destroyed. — *end note*]
 ##### `shared_ptr` I/O <a id="util.smartptr.shared.io">[[util.smartptr.shared.io]]</a>
 ``` cpp
 template<class E, class T, class Y>
+  basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, const shared_ptr<Y>& p);
 ```
+*Effects:* As if by: `os << p.get();`
 *Returns:* `os`.
 #### Class template `weak_ptr` <a id="util.smartptr.weak">[[util.smartptr.weak]]</a>
 ``` cpp
 namespace std {
   template<class T> class weak_ptr {
   public:
+ using element_type = T;
     // [util.smartptr.weak.const], constructors
     constexpr weak_ptr() noexcept;
+    template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
+    weak_ptr(const weak_ptr& r) noexcept;
+    template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
     weak_ptr(weak_ptr&& r) noexcept;
     template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.dest], destructor
     ~weak_ptr();
     // [util.smartptr.weak.assign], assignment
+    weak_ptr& operator=(const weak_ptr& r) noexcept;
+    template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
+    template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
     weak_ptr& operator=(weak_ptr&& r) noexcept;
     template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.mod], modifiers
     void swap(weak_ptr& r) noexcept;
     // [util.smartptr.weak.obs], observers
     long use_count() const noexcept;
     bool expired() const noexcept;
     shared_ptr<T> lock() const noexcept;
+    template<class U> bool owner_before(const shared_ptr<U>& b) const;
+    template<class U> bool owner_before(const weak_ptr<U>& b) const;
   };
+  template<class T> weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
   // [util.smartptr.weak.spec], specialized algorithms
   template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
+}
 ```
 Specializations of `weak_ptr` shall be `CopyConstructible` and
 `CopyAssignable`, allowing their use in standard containers. The
 template parameter `T` of `weak_ptr` may be an incomplete type.
 ``` cpp
 constexpr weak_ptr() noexcept;
 ```
+*Effects:* Constructs an empty `weak_ptr` object.
 *Postconditions:* `use_count() == 0`.
 ``` cpp
 weak_ptr(const weak_ptr& r) noexcept;
 template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
 template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
 ```
+*Remarks:* The second and third constructors shall not participate in
+overload resolution unless `Y*` is compatible with `T*`.
+*Effects:* If `r` is empty, constructs an empty `weak_ptr` object;
+otherwise, constructs a `weak_ptr` object that shares ownership with `r`
+and stores a copy of the pointer stored in `r`.
 *Postconditions:* `use_count() == r.use_count()`.
 ``` cpp
 weak_ptr(weak_ptr&& r) noexcept;
 template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
 ```
+*Remarks:* The second constructor shall not participate in overload
+resolution unless `Y*` is compatible with `T*`.
+*Effects:* Move constructs a `weak_ptr` instance from `r`.
 *Postconditions:* `*this` shall contain the old value of `r`. `r` shall
+be empty. `r.use_count() == 0`.
 ##### `weak_ptr` destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
 ``` cpp
 ~weak_ptr();
 ``` 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;
+template<class U> bool owner_before(const weak_ptr<U>& b) const;
 ```
 *Returns:* An unspecified value such that
 - `x.owner_before(y)` defines a strict weak ordering as defined
   ownership or are both empty.
 ##### `weak_ptr` specialized algorithms <a id="util.smartptr.weak.spec">[[util.smartptr.weak.spec]]</a>
 ``` cpp
+template<class T>
+  void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
 #### Class template `owner_less` <a id="util.smartptr.ownerless">[[util.smartptr.ownerless]]</a>
 The class template `owner_less` allows ownership-based mixed comparisons
 of shared and weak pointers.
 ``` cpp
 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)` shall return `x.owner_before(y)`.
+[*Note 1*:
+Note that
 - `operator()` defines a strict weak ordering as defined in
   [[alg.sorting]];
 - under the equivalence relation defined by `operator()`,
   `!operator()(a, b) && !operator()(b, a)`, two `shared_ptr` or
   `weak_ptr` instances are equivalent if and only if they share
   ownership or are both empty.
+— *end note*]
 #### Class template `enable_shared_from_this` <a id="util.smartptr.enab">[[util.smartptr.enab]]</a>
 A class `T` can inherit from `enable_shared_from_this<T>` to inherit the
+`shared_from_this` member functions that obtain a `shared_ptr` instance
 pointing to `*this`.
+[*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`.
 #### `shared_ptr` atomic access <a id="util.smartptr.shared.atomic">[[util.smartptr.shared.atomic]]</a>
 Concurrent access to a `shared_ptr` object from multiple threads does
 not introduce a data race if the access is done exclusively via the
   void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
 ```
 *Requires:* `p` shall not be null.
+*Effects:* As if by `atomic_store_explicit(p, r, memory_order_seq_cst)`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
 *Requires:* `p` shall not be null.
 *Requires:* `mo` shall not be `memory_order_acquire` or
 `memory_order_acq_rel`.
+*Effects:* As if by `p->swap(r)`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
 *Throws:* Nothing.
 ``` cpp
 template<class T>
+  shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
 ```
 *Requires:* `p` shall not be null.
+*Effects:* As if by `p->swap(r)`.
 *Returns:* The previous value of `*p`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
+  bool atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
 ```
 *Requires:* `p` shall not be null and `v` shall not be null.
 *Returns:*
+``` cpp
+atomic_compare_exchange_weak_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)
+```
 *Throws:* Nothing.
 ``` cpp
 template<class T>
+  bool atomic_compare_exchange_strong(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
 ```
+*Returns:*
+``` cpp
+atomic_compare_exchange_strong_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)
+```
 ``` cpp
 template<class T>
   bool atomic_compare_exchange_weak_explicit(
     shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
   bool atomic_compare_exchange_strong_explicit(
     shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
     memory_order success, memory_order failure);
 ```
+*Requires:* `p` shall not be null and `v` shall not be null. The
+`failure` argument shall not be `memory_order_release` nor
+`memory_order_acq_rel`.
 *Effects:* If `*p` is equivalent to `*v`, assigns `w` to `*p` and has
 synchronization semantics corresponding to the value of `success`,
 otherwise assigns `*p` to `*v` and has synchronization semantics
 corresponding to the value of `failure`.
 *Returns:* `true` if `*p` was equivalent to `*v`, `false` otherwise.
 *Throws:* Nothing.
+*Remarks:* Two `shared_ptr` objects are equivalent if they store the
+same pointer value and share ownership. The weak form may fail
+spuriously. See  [[atomics.types.operations]].
 #### Smart pointer hash support <a id="util.smartptr.hash">[[util.smartptr.hash]]</a>
 ``` cpp
 template <class T, class D> struct hash<unique_ptr<T, D>>;
 ```
+Letting `UP` be `unique_ptr<T,D>`, the specialization `hash<UP>` is
+enabled ([[unord.hash]]) if and only if `hash<typename UP::pointer>` is
+enabled. When enabled, for an object `p` of type `UP`, `hash<UP>()(p)`
+shall evaluate to the same value as
+`hash<typename UP::pointer>()(p.get())`. The member functions are not
+guaranteed to be `noexcept`.
 ``` cpp
 template <class T> struct hash<shared_ptr<T>>;
 ```
+For an object `p` of type `shared_ptr<T>`, `hash<shared_ptr<T>>()(p)`
+shall evaluate to the same value as
+`hash<typename shared_ptr<T>::element_type*>()(p.get())`.

Diff to HTML by rtfpessoa