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

Files changed (1) hide show

tmp/tmp9__7q8st/{from.md → to.md} +266 -172

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

@@ -2,70 +2,73 @@
 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>
@@ -100,218 +103,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:
@@ -322,10 +359,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;
 ```
@@ -337,11 +376,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;
@@ -374,64 +413,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
@@ -442,59 +504,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>
@@ -518,12 +587,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>
@@ -554,92 +624,116 @@ 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`.

 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`.

Diff to HTML by rtfpessoa