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

Files changed (1) hide show

tmp/tmpq41ma8tp/{from.md → to.md} +601 -430

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

@@ -27,24 +27,26 @@ postconditions hold:
 - if the pre-transfer *u.d* maintained state, such state has been
   transferred to *u2.d*.
 As in the case of a reset, *u2* must properly dispose of its
 pre-transfer owned object via the pre-transfer associated deleter before
-the ownership transfer is considered complete. A deleter’s state need
-never be copied, only moved or swapped as ownership is transferred.
 Each object of a type `U` instantiated from the `unique_ptr` template
 specified in this subclause has the strict ownership semantics,
 specified above, of a unique pointer. In partial satisfaction of these
 semantics, each such `U` is `MoveConstructible` and `MoveAssignable`,
 but is not `CopyConstructible` nor `CopyAssignable`. The template
 parameter `T` of `unique_ptr` may be an incomplete type.
-The uses of `unique_ptr` include providing exception safety for
-dynamically allocated memory, passing ownership of dynamically allocated
-memory to a function, and returning dynamically allocated memory from a
-function.
 ``` cpp
 namespace std {
   template<class T> struct default_delete;
   template<class T> struct default_delete<T[]>;
@@ -133,56 +135,65 @@ unless `U*` is implicitly convertible to `T*`.
 ``` cpp
 void operator()(T* ptr) const;
 ```
-*Effects:* calls `delete` on `ptr`.
 *Remarks:* If `T` is an incomplete type, the program is ill-formed.
 ##### `default_delete<T[]>` <a id="unique.ptr.dltr.dflt1">[[unique.ptr.dltr.dflt1]]</a>
 ``` cpp
 namespace std {
   template <class T> struct default_delete<T[]> {
     constexpr default_delete() noexcept = default;
- void operator()(T*) const;
-    template <class U> void operator()(U*) const = delete;
   };
 }
 ```
 ``` cpp
-void operator()(T* ptr) const;
 ```
-*Effects:* calls `delete[]` on `ptr`.
-*Remarks:* If T is an incomplete type, the program is ill-formed.
 #### `unique_ptr` for single objects <a id="unique.ptr.single">[[unique.ptr.single]]</a>
 ``` cpp
 namespace std {
   template <class T, class D = default_delete<T>> class unique_ptr {
   public:
- typedef see below pointer;
- typedef T element_type;
- typedef D deleter_type;
     // [unique.ptr.single.ctor], constructors
     constexpr unique_ptr() noexcept;
     explicit unique_ptr(pointer p) noexcept;
     unique_ptr(pointer p, see below d1) noexcept;
     unique_ptr(pointer p, see below d2) noexcept;
     unique_ptr(unique_ptr&& u) noexcept;
-    constexpr unique_ptr(nullptr_t) noexcept
-      : unique_ptr() { }
     template <class U, class E>
       unique_ptr(unique_ptr<U, E>&& u) noexcept;
-    template <class U>
-      unique_ptr(auto_ptr<U>&& u) noexcept;
     // [unique.ptr.single.dtor], destructor
     ~unique_ptr();
     // [unique.ptr.single.asgn], assignment
@@ -196,11 +207,11 @@ namespace std {
     pointer get() const noexcept;
     deleter_type& get_deleter() noexcept;
     const deleter_type& get_deleter() const noexcept;
     explicit operator bool() const noexcept;
-    // [unique.ptr.single.modifiers] modifiers
     pointer release() noexcept;
     void reset(pointer p = pointer()) noexcept;
     void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
@@ -210,149 +221,148 @@ namespace std {
 }
 ```
 The default type for the template parameter `D` is `default_delete`. A
 client-supplied template argument `D` shall be a function object type (
-[[function.objects]]), lvalue-reference to function, or lvalue-reference
 to function object type for which, given a value `d` of type `D` and a
 value `ptr` of type `unique_ptr<T, D>::pointer`, the expression `d(ptr)`
 is valid and has the effect of disposing of the pointer as appropriate
 for that deleter.
 If the deleter’s type `D` is not a reference type, `D` shall satisfy the
-requirements of `Destructible` (Table  [[destructible]]).
-If the type `remove_reference_t<D>::pointer` exists, then `unique_ptr<T,
 D>::pointer` shall be a synonym for `remove_reference_t<D>::pointer`.
-Otherwise `unique_ptr<T, D>::pointer` shall be a synonym for `T*`. The
-type `unique_ptr<T,
 D>::pointer` shall satisfy the requirements of `NullablePointer` (
 [[nullablepointer.requirements]]).
-Given an allocator type `X` ([[allocator.requirements]]) and letting
-`A` be a synonym for `allocator_traits<X>`, the types `A::pointer`,
-`A::const_pointer`, `A::void_pointer`, and `A::const_void_pointer` may
-be used as `unique_ptr<T, D>::pointer`.
 ##### `unique_ptr` constructors <a id="unique.ptr.single.ctor">[[unique.ptr.single.ctor]]</a>
 ``` cpp
 constexpr unique_ptr() noexcept;
 ```
 *Requires:* `D` shall satisfy the requirements of `DefaultConstructible`
-(Table  [[defaultconstructible]]), and that construction shall not throw
-an exception.
 *Effects:* Constructs a `unique_ptr` object that owns nothing,
 value-initializing the stored pointer and the stored deleter.
 *Postconditions:* `get() == nullptr`. `get_deleter()` returns a
 reference to the stored deleter.
-*Remarks:* If this constructor is instantiated with a pointer type or
-reference type for the template argument `D`, the program is ill-formed.
 ``` cpp
 explicit unique_ptr(pointer p) noexcept;
 ```
 *Requires:* `D` shall satisfy the requirements of `DefaultConstructible`
-(Table  [[defaultconstructible]]), and that construction shall not throw
-an exception.
 *Effects:* Constructs a `unique_ptr` which owns `p`, initializing the
 stored pointer with `p` and value-initializing the stored deleter.
 *Postconditions:* `get() == p`. `get_deleter()` returns a reference to
 the stored deleter.
-*Remarks:* If this constructor is instantiated with a pointer type or
-reference type for the template argument `D`, the program is ill-formed.
 ``` cpp
 unique_ptr(pointer p, see below d1) noexcept;
 unique_ptr(pointer p, see below d2) noexcept;
 ```
 The signature of these constructors depends upon whether `D` is a
-reference type. If `D` is non-reference type `A`, then the signatures
 are:
 ``` cpp
-unique_ptr(pointer p, const A& d);
-unique_ptr(pointer p, A&& d);
 ```
-If `D` is an lvalue-reference type `A&`, then the signatures are:
 ``` cpp
-unique_ptr(pointer p, A& d);
-unique_ptr(pointer p, A&& d);
 ```
-If `D` is an lvalue-reference type `const A&`, then the signatures are:
 ``` cpp
-unique_ptr(pointer p, const A& d);
-unique_ptr(pointer p, const A&& d);
 ```
-*Requires:*
-- If `D` is not an lvalue-reference type then
-  - If `d` is an lvalue or `const` rvalue then the first constructor of
-    this pair will be selected. `D` shall satisfy the requirements of
-    `CopyConstructible` (Table  [[copyconstructible]]), and the copy
-    constructor of `D` shall not throw an exception. This `unique_ptr`
-    will hold a copy of `d`.
-  - Otherwise, `d` is a non-const rvalue and the second constructor of
-    this pair will be selected. `D` shall satisfy the requirements of
-    `MoveConstructible` (Table  [[moveconstructible]]), and the move
-    constructor of `D` shall not throw an exception. This `unique_ptr`
-    will hold a value move constructed from `d`.
-- Otherwise `D` is an lvalue-reference type. `d` shall be
-  reference-compatible with one of the constructors. If `d` is an
-  rvalue, it will bind to the second constructor of this pair and the
-  program is ill-formed. The diagnostic could be implemented using a
-  `static_assert` which assures that `D` is not a reference type. Else
-  `d` is an lvalue and will bind to the first constructor of this pair.
-  The type which `D` references need not be `CopyConstructible` nor
-  `MoveConstructible`. This `unique_ptr` will hold a `D` which refers to
-  the lvalue `d`. `D` may not be an rvalue-reference type.
 *Effects:* Constructs a `unique_ptr` object which owns `p`, initializing
-the stored pointer with `p` and initializing the deleter as described
-above.
 *Postconditions:* `get() == p`. `get_deleter()` returns a reference to
 the stored deleter. If `D` is a reference type then `get_deleter()`
 returns a reference to the lvalue `d`.
 ``` cpp
 D d;
 unique_ptr<int, D> p1(new int, D());        // D must be MoveConstructible
 unique_ptr<int, D> p2(new int, d);          // D must be CopyConstructible
 unique_ptr<int, D&> p3(new int, d);         // p3 holds a reference to d
 unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object combined
                                             // with reference deleter type
 ```
 ``` cpp
 unique_ptr(unique_ptr&& u) noexcept;
 ```
 *Requires:* If `D` is not a reference type, `D` shall satisfy the
-requirements of `MoveConstructible` (Table  [[moveconstructible]]).
 Construction of the deleter from an rvalue of type `D` shall not throw
 an exception.
 *Effects:* Constructs a `unique_ptr` by transferring ownership from `u`
 to `*this`. If `D` is a reference type, this deleter is copy constructed
 from `u`’s deleter; otherwise, this deleter is move constructed from
-`u`’s deleter. The deleter constructor can be implemented with
-`std::forward<D>`.
 *Postconditions:* `get()` yields the value `u.get()` yielded before the
 construction. `get_deleter()` returns a reference to the stored deleter
 that was constructed from `u.get_deleter()`. If `D` is a reference type
 then `get_deleter()` and `u.get_deleter()` both reference the same
@@ -377,42 +387,30 @@ unless:
   is not a reference type and `E` is implicitly convertible to `D`.
 *Effects:* Constructs a `unique_ptr` by transferring ownership from `u`
 to `*this`. If `E` is a reference type, this deleter is copy constructed
 from `u`’s deleter; otherwise, this deleter is move constructed from
-`u`’s deleter. The deleter constructor can be implemented with
-`std::forward<E>`.
 *Postconditions:* `get()` yields the value `u.get()` yielded before the
 construction. `get_deleter()` returns a reference to the stored deleter
 that was constructed from `u.get_deleter()`.
-``` cpp
-template <class U>
-  unique_ptr(auto_ptr<U>&& u) noexcept;
-```
-*Effects:* Constructs a `unique_ptr` object, initializing the stored
-pointer with `u.release()` and value-initializing the stored deleter.
-*Postconditions:* `get()` yields the value `u.get()` yielded before the
-construction. `u.get() == nullptr`. `get_deleter()` returns a reference
-to the stored deleter.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `U*` is implicitly convertible to `T*` and `D` is the same type
-as `default_delete<T>`.
 ##### `unique_ptr` destructor <a id="unique.ptr.single.dtor">[[unique.ptr.single.dtor]]</a>
 ``` cpp
 ~unique_ptr();
 ```
 *Requires:* The expression `get_deleter()(get())` shall be well formed,
-shall have well-defined behavior, and shall not throw exceptions. The
-use of `default_delete` requires `T` to be a complete type.
 *Effects:* If `get() == nullptr` there are no effects. Otherwise
 `get_deleter()(get())`.
 ##### `unique_ptr` assignment <a id="unique.ptr.single.asgn">[[unique.ptr.single.asgn]]</a>
@@ -420,11 +418,11 @@ use of `default_delete` requires `T` to be a complete type.
 ``` cpp
 unique_ptr& operator=(unique_ptr&& u) noexcept;
 ```
 *Requires:* If `D` is not a reference type, `D` shall satisfy the
-requirements of `MoveAssignable` (Table  [[moveassignable]]) and
 assignment of the deleter from an rvalue of type `D` shall not throw an
 exception. Otherwise, `D` is a reference type; `remove_reference_t<D>`
 shall satisfy the `CopyAssignable` requirements and assignment of the
 deleter from an lvalue of type `D` shall not throw an exception.
@@ -445,12 +443,14 @@ deleter from an lvalue of type `E` shall be well-formed and shall not
 throw an exception.
 *Remarks:* This operator shall not participate in overload resolution
 unless:
-- `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer` and
-- `U` is not an array type.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
 `reset(u.release())` followed by
 `get_deleter() = std::forward<E>(u.get_deleter())`.
@@ -458,13 +458,13 @@ unless:
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 ```
-*Effects:* `reset()`.
-`get() == nullptr`
 *Returns:* `*this`.
 ##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
@@ -482,11 +482,12 @@ pointer operator->() const noexcept;
 *Requires:* `get() != nullptr`.
 *Returns:* `get()`.
-*Note:* use typically requires that `T` be a complete type.
 ``` cpp
 pointer get() const noexcept;
 ```
@@ -509,29 +510,33 @@ explicit operator bool() const noexcept;
 ``` cpp
 pointer release() noexcept;
 ```
-`get() == nullptr`.
 *Returns:* The value `get()` had at the start of the call to `release`.
 ``` cpp
 void reset(pointer p = pointer()) noexcept;
 ```
 *Requires:* The expression `get_deleter()(get())` shall be well formed,
 shall have well-defined behavior, and shall not throw exceptions.
-*Effects:* assigns `p` to the stored pointer, and then if the old value
-of the stored pointer, `old_p`, was not equal to `nullptr`, calls
-`get_deleter()(old_p)`. The order of these operations is significant
-because the call to `get_deleter()` may destroy `*this`.
-*Postconditions:* `get() == p`. The postcondition does not hold if the
-call to `get_deleter()` destroys `*this` since `this->get()` is no
-longer a valid expression.
 ``` cpp
 void swap(unique_ptr& u) noexcept;
 ```
@@ -546,41 +551,44 @@ deleters of `*this` and `u`.
 ``` cpp
 namespace std {
   template <class T, class D> class unique_ptr<T[], D> {
   public:
- typedef see below pointer;
- typedef T element_type;
- typedef D deleter_type;
     // [unique.ptr.runtime.ctor], constructors
     constexpr unique_ptr() noexcept;
-    explicit unique_ptr(pointer p) noexcept;
-    unique_ptr(pointer p, see below d) noexcept;
-    unique_ptr(pointer p, see below d) noexcept;
     unique_ptr(unique_ptr&& u) noexcept;
- constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
     // destructor
     ~unique_ptr();
     // assignment
     unique_ptr& operator=(unique_ptr&& u) noexcept;
     unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.runtime.observers], observers
     T& operator[](size_t i) const;
     pointer get() const noexcept;
     deleter_type& get_deleter() noexcept;
     const deleter_type& get_deleter() const noexcept;
     explicit operator bool() const noexcept;
-    // [unique.ptr.runtime.modifiers] modifiers
     pointer release() noexcept;
-    void reset(pointer p = pointer()) noexcept;
-    void reset(nullptr_t) noexcept;
-    template <class U> void reset(U) = delete;
     void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
     unique_ptr(const unique_ptr&) = delete;
     unique_ptr& operator=(const unique_ptr&) = delete;
@@ -589,36 +597,92 @@ namespace std {
 ```
 A specialization for array types is provided with a slightly altered
 interface.
-- Conversions between different types of `unique_ptr<T[], D>` or to or
- from the non-array forms of `unique_ptr` produce an ill-formed
- program.
 - Pointers to types derived from `T` are rejected by the constructors,
   and by `reset`.
 - The observers `operator*` and `operator->` are not provided.
 - The indexing observer `operator[]` is provided.
 - The default deleter will call `delete[]`.
-Descriptions are provided below only for member functions that have
-behavior different from the primary template.
 The template argument `T` shall be a complete type.
 ##### `unique_ptr` constructors <a id="unique.ptr.runtime.ctor">[[unique.ptr.runtime.ctor]]</a>
 ``` cpp
-explicit unique_ptr(pointer p) noexcept;
-unique_ptr(pointer p, see below d) noexcept;
-unique_ptr(pointer p, see below d) noexcept;
 ```
-These constructors behave the same as in the primary template except
-that they do not accept pointer types which are convertible to
-`pointer`. One implementation technique is to create private templated
-overloads of these members.
 ##### `unique_ptr` observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
 T& operator[](size_t i) const;
@@ -630,15 +694,27 @@ stored pointer points.
 *Returns:* `get()[i]`.
 ##### `unique_ptr` modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
-void reset(nullptr_t p) noexcept;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
 #### `unique_ptr` creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
 template <class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
 ```
@@ -668,10 +744,13 @@ unless `T` is an array of known bound.
 ``` cpp
 template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 ```
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template <class T1, class D1, class T2, class D2>
   bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
@@ -689,20 +768,26 @@ template <class T1, class D1, class T2, class D2>
 ``` cpp
 template <class T1, class D1, class T2, class D2>
   bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
-*Requires:* Let `CT` be `common_type<unique_ptr<T1, D1>::pointer,`
-`unique_ptr<T2, D2>::pointer>::type`. Then the specialization `less<CT>`
-shall be a function object type ([[function.objects]]) that induces a
-strict weak ordering ([[alg.sorting]]) on the pointer values.
-*Returns:* `less<CT>()(x.get(), y.get()).`
 *Remarks:* If `unique_ptr<T1, D1>::pointer` is not implicitly
-convertible to `CT` or `unique_ptr<T2, D2>::pointer` is not implicitly
-convertible to `CT`, the program is ill-formed.
 ``` cpp
 template <class T1, class D1, class T2, class D2>
   bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
@@ -787,96 +872,99 @@ template <class T, class D>
 *Returns:* The first function template returns `!(x < nullptr)`. The
 second function template returns `!(nullptr < x)`.
 ### 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>
@@ -911,218 +999,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:
@@ -1133,10 +1255,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;
 ```
@@ -1148,11 +1272,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;
@@ -1185,64 +1309,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
@@ -1253,59 +1400,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>
@@ -1329,12 +1483,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>
@@ -1365,94 +1520,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>
@@ -1462,27 +1641,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;
@@ -1490,17 +1669,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.
@@ -1509,41 +1691,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();
@@ -1594,33 +1776,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
@@ -1631,11 +1809,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>
@@ -1643,130 +1822,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
@@ -1818,11 +1992,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>
@@ -1832,11 +2006,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>
@@ -1849,43 +2023,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,
@@ -1894,49 +2071,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())`.

 - if the pre-transfer *u.d* maintained state, such state has been
   transferred to *u2.d*.
 As in the case of a reset, *u2* must properly dispose of its
 pre-transfer owned object via the pre-transfer associated deleter before
+the ownership transfer is considered complete.
+[*Note 1*: A deleter’s state need never be copied, only moved or
+swapped as ownership is transferred. — *end note*]
 Each object of a type `U` instantiated from the `unique_ptr` template
 specified in this subclause has the strict ownership semantics,
 specified above, of a unique pointer. In partial satisfaction of these
 semantics, each such `U` is `MoveConstructible` and `MoveAssignable`,
 but is not `CopyConstructible` nor `CopyAssignable`. The template
 parameter `T` of `unique_ptr` may be an incomplete type.
+[*Note 2*: The uses of `unique_ptr` include providing exception safety
+for dynamically allocated memory, passing ownership of dynamically
+allocated memory to a function, and returning dynamically allocated
+memory from a function. — *end note*]
 ``` cpp
 namespace std {
   template<class T> struct default_delete;
   template<class T> struct default_delete<T[]>;
 ``` cpp
 void operator()(T* ptr) const;
 ```
+*Effects:* Calls `delete` on `ptr`.
 *Remarks:* If `T` is an incomplete type, the program is ill-formed.
 ##### `default_delete<T[]>` <a id="unique.ptr.dltr.dflt1">[[unique.ptr.dltr.dflt1]]</a>
 ``` cpp
 namespace std {
   template <class T> struct default_delete<T[]> {
     constexpr default_delete() noexcept = default;
+ template <class U> default_delete(const default_delete<U[]>&) noexcept;
+    template <class U> void operator()(U* ptr) const;
   };
 }
 ```
 ``` cpp
+template <class U> default_delete(const default_delete<U[]>& other) noexcept;
 ```
+*Effects:* constructs a `default_delete` object from another
+`default_delete<U[]>` object.
+*Remarks:* This constructor shall not participate in overload resolution
+unless `U(*)[]` is convertible to `T(*)[]`.
+``` cpp
+template <class U> void operator()(U* ptr) const;
+```
+*Effects:* Calls `delete[]` on `ptr`.
+*Remarks:* If `U` is an incomplete type, the program is ill-formed. This
+function shall not participate in overload resolution unless `U(*)[]` is
+convertible to `T(*)[]`.
 #### `unique_ptr` for single objects <a id="unique.ptr.single">[[unique.ptr.single]]</a>
 ``` cpp
 namespace std {
   template <class T, class D = default_delete<T>> class unique_ptr {
   public:
+ using pointer      = see below;
+ using element_type = T;
+ using deleter_type = D;
     // [unique.ptr.single.ctor], constructors
     constexpr unique_ptr() noexcept;
     explicit unique_ptr(pointer p) noexcept;
     unique_ptr(pointer p, see below d1) noexcept;
     unique_ptr(pointer p, see below d2) noexcept;
     unique_ptr(unique_ptr&& u) noexcept;
+    constexpr unique_ptr(nullptr_t) noexcept;
     template <class U, class E>
       unique_ptr(unique_ptr<U, E>&& u) noexcept;
     // [unique.ptr.single.dtor], destructor
     ~unique_ptr();
     // [unique.ptr.single.asgn], assignment
     pointer get() const noexcept;
     deleter_type& get_deleter() noexcept;
     const deleter_type& get_deleter() const noexcept;
     explicit operator bool() const noexcept;
+    // [unique.ptr.single.modifiers], modifiers
     pointer release() noexcept;
     void reset(pointer p = pointer()) noexcept;
     void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
 }
 ```
 The default type for the template parameter `D` is `default_delete`. A
 client-supplied template argument `D` shall be a function object type (
+[[function.objects]]), lvalue reference to function, or lvalue reference
 to function object type for which, given a value `d` of type `D` and a
 value `ptr` of type `unique_ptr<T, D>::pointer`, the expression `d(ptr)`
 is valid and has the effect of disposing of the pointer as appropriate
 for that deleter.
 If the deleter’s type `D` is not a reference type, `D` shall satisfy the
+requirements of `Destructible` (Table  [[tab:destructible]]).
+If the *qualified-id* `remove_reference_t<D>::pointer` is valid and
+denotes a type ([[temp.deduct]]), then `unique_ptr<T,
 D>::pointer` shall be a synonym for `remove_reference_t<D>::pointer`.
+Otherwise `unique_ptr<T, D>::pointer` shall be a synonym for
+`element_type*`. The type `unique_ptr<T,
 D>::pointer` shall satisfy the requirements of `NullablePointer` (
 [[nullablepointer.requirements]]).
+[*Example 1*: Given an allocator type `X` ([[allocator.requirements]])
+and letting `A` be a synonym for `allocator_traits<X>`, the types
+`A::pointer`, `A::const_pointer`, `A::void_pointer`, and
+`A::const_void_pointer` may be used as
+`unique_ptr<T, D>::pointer`. — *end example*]
 ##### `unique_ptr` constructors <a id="unique.ptr.single.ctor">[[unique.ptr.single.ctor]]</a>
 ``` cpp
 constexpr unique_ptr() noexcept;
+constexpr unique_ptr(nullptr_t) noexcept;
 ```
 *Requires:* `D` shall satisfy the requirements of `DefaultConstructible`
+(Table  [[tab:defaultconstructible]]), and that construction shall not
+throw an exception.
 *Effects:* Constructs a `unique_ptr` object that owns nothing,
 value-initializing the stored pointer and the stored deleter.
 *Postconditions:* `get() == nullptr`. `get_deleter()` returns a
 reference to the stored deleter.
+*Remarks:* If `is_pointer_v<deleter_type>` is `true` or
+`is_default_constructible_v<deleter_type>` is `false`, this constructor
+shall not participate in overload resolution.
 ``` cpp
 explicit unique_ptr(pointer p) noexcept;
 ```
 *Requires:* `D` shall satisfy the requirements of `DefaultConstructible`
+(Table  [[tab:defaultconstructible]]), and that construction shall not
+throw an exception.
 *Effects:* Constructs a `unique_ptr` which owns `p`, initializing the
 stored pointer with `p` and value-initializing the stored deleter.
 *Postconditions:* `get() == p`. `get_deleter()` returns a reference to
 the stored deleter.
+*Remarks:* If `is_pointer_v<deleter_type>` is `true` or
+`is_default_constructible_v<deleter_type>` is `false`, this constructor
+shall not participate in overload resolution. If class template argument
+deduction ([[over.match.class.deduct]]) would select the function
+template corresponding to this constructor, then the program is
+ill-formed.
 ``` cpp
 unique_ptr(pointer p, see below d1) noexcept;
 unique_ptr(pointer p, see below d2) noexcept;
 ```
 The signature of these constructors depends upon whether `D` is a
+reference type. If `D` is a non-reference type `A`, then the signatures
 are:
 ``` cpp
+unique_ptr(pointer p, const A& d) noexcept;
+unique_ptr(pointer p, A&& d) noexcept;
 ```
+If `D` is an lvalue reference type `A&`, then the signatures are:
 ``` cpp
+unique_ptr(pointer p, A& d) noexcept;
+unique_ptr(pointer p, A&& d) = delete;
 ```
+If `D` is an lvalue reference type `const A&`, then the signatures are:
 ``` cpp
+unique_ptr(pointer p, const A& d) noexcept;
+unique_ptr(pointer p, const A&& d) = delete;
 ```
 *Effects:* Constructs a `unique_ptr` object which owns `p`, initializing
+the stored pointer with `p` and initializing the deleter from
+`std::forward<decltype(d)>(d)`.
+*Remarks:* These constructors shall not participate in overload
+resolution unless `is_constructible_v<D, decltype(d)>` is `true`.
 *Postconditions:* `get() == p`. `get_deleter()` returns a reference to
 the stored deleter. If `D` is a reference type then `get_deleter()`
 returns a reference to the lvalue `d`.
+*Remarks:* If class template argument
+deduction ([[over.match.class.deduct]]) would select a function
+template corresponding to either of these constructors, then the program
+is ill-formed.
+[*Example 1*:
 ``` cpp
 D d;
 unique_ptr<int, D> p1(new int, D());        // D must be MoveConstructible
 unique_ptr<int, D> p2(new int, d);          // D must be CopyConstructible
 unique_ptr<int, D&> p3(new int, d);         // p3 holds a reference to d
 unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object combined
                                             // with reference deleter type
 ```
+— *end example*]
 ``` cpp
 unique_ptr(unique_ptr&& u) noexcept;
 ```
 *Requires:* If `D` is not a reference type, `D` shall satisfy the
+requirements of `MoveConstructible` (Table  [[tab:moveconstructible]]).
 Construction of the deleter from an rvalue of type `D` shall not throw
 an exception.
 *Effects:* Constructs a `unique_ptr` by transferring ownership from `u`
 to `*this`. If `D` is a reference type, this deleter is copy constructed
 from `u`’s deleter; otherwise, this deleter is move constructed from
+`u`’s deleter.
+[*Note 1*: The deleter constructor can be implemented with
+`std::forward<D>`. — *end note*]
 *Postconditions:* `get()` yields the value `u.get()` yielded before the
 construction. `get_deleter()` returns a reference to the stored deleter
 that was constructed from `u.get_deleter()`. If `D` is a reference type
 then `get_deleter()` and `u.get_deleter()` both reference the same
   is not a reference type and `E` is implicitly convertible to `D`.
 *Effects:* Constructs a `unique_ptr` by transferring ownership from `u`
 to `*this`. If `E` is a reference type, this deleter is copy constructed
 from `u`’s deleter; otherwise, this deleter is move constructed from
+`u`’s deleter.
+[*Note 2*: The deleter constructor can be implemented with
+`std::forward<E>`. — *end note*]
 *Postconditions:* `get()` yields the value `u.get()` yielded before the
 construction. `get_deleter()` returns a reference to the stored deleter
 that was constructed from `u.get_deleter()`.
 ##### `unique_ptr` destructor <a id="unique.ptr.single.dtor">[[unique.ptr.single.dtor]]</a>
 ``` cpp
 ~unique_ptr();
 ```
 *Requires:* The expression `get_deleter()(get())` shall be well formed,
+shall have well-defined behavior, and shall not throw exceptions.
+[*Note 3*: The use of `default_delete` requires `T` to be a complete
+type. — *end note*]
 *Effects:* If `get() == nullptr` there are no effects. Otherwise
 `get_deleter()(get())`.
 ##### `unique_ptr` assignment <a id="unique.ptr.single.asgn">[[unique.ptr.single.asgn]]</a>
 ``` cpp
 unique_ptr& operator=(unique_ptr&& u) noexcept;
 ```
 *Requires:* If `D` is not a reference type, `D` shall satisfy the
+requirements of `MoveAssignable` (Table  [[tab:moveassignable]]) and
 assignment of the deleter from an rvalue of type `D` shall not throw an
 exception. Otherwise, `D` is a reference type; `remove_reference_t<D>`
 shall satisfy the `CopyAssignable` requirements and assignment of the
 deleter from an lvalue of type `D` shall not throw an exception.
 throw an exception.
 *Remarks:* This operator shall not participate in overload resolution
 unless:
+- `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
+  and
+- `U` is not an array type, and
+- `is_assignable_v<D&, E&&>` is `true`.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
 `reset(u.release())` followed by
 `get_deleter() = std::forward<E>(u.get_deleter())`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 ```
+*Effects:* As if by `reset()`.
+*Postconditions:* `get() == nullptr`.
 *Returns:* `*this`.
 ##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 *Requires:* `get() != nullptr`.
 *Returns:* `get()`.
+[*Note 4*: The use of this function typically requires that `T` be a
+complete type. — *end note*]
 ``` cpp
 pointer get() const noexcept;
 ```
 ``` cpp
 pointer release() noexcept;
 ```
+*Postconditions:* `get() == nullptr`.
 *Returns:* The value `get()` had at the start of the call to `release`.
 ``` cpp
 void reset(pointer p = pointer()) noexcept;
 ```
 *Requires:* The expression `get_deleter()(get())` shall be well formed,
 shall have well-defined behavior, and shall not throw exceptions.
+*Effects:* Assigns `p` to the stored pointer, and then if and only if
+the old value of the stored pointer, `old_p`, was not equal to
+`nullptr`, calls `get_deleter()(old_p)`.
+[*Note 5*: The order of these operations is significant because the
+call to `get_deleter()` may destroy `*this`. — *end note*]
+*Postconditions:* `get() == p`.
+[*Note 6*: The postcondition does not hold if the call to
+`get_deleter()` destroys `*this` since `this->get()` is no longer a
+valid expression. — *end note*]
 ``` cpp
 void swap(unique_ptr& u) noexcept;
 ```
 ``` cpp
 namespace std {
   template <class T, class D> class unique_ptr<T[], D> {
   public:
+ using pointer      = see below;
+ using element_type = T;
+ using deleter_type = D;
     // [unique.ptr.runtime.ctor], constructors
     constexpr unique_ptr() noexcept;
+ template <class U> explicit unique_ptr(U p) noexcept;
+ template <class U> unique_ptr(U p, see below d) noexcept;
+ template <class U> unique_ptr(U p, see below d) noexcept;
     unique_ptr(unique_ptr&& u) noexcept;
+ template <class U, class E>
+      unique_ptr(unique_ptr<U, E>&& u) noexcept;
+    constexpr unique_ptr(nullptr_t) noexcept;
     // destructor
     ~unique_ptr();
     // assignment
     unique_ptr& operator=(unique_ptr&& u) noexcept;
+    template <class U, class E>
+      unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
     unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.runtime.observers], observers
     T& operator[](size_t i) const;
     pointer get() const noexcept;
     deleter_type& get_deleter() noexcept;
     const deleter_type& get_deleter() const noexcept;
     explicit operator bool() const noexcept;
+    // [unique.ptr.runtime.modifiers], modifiers
     pointer release() noexcept;
+ template <class U> void reset(U p) noexcept;
+    void reset(nullptr_t = nullptr) noexcept;
     void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
     unique_ptr(const unique_ptr&) = delete;
     unique_ptr& operator=(const unique_ptr&) = delete;
 ```
 A specialization for array types is provided with a slightly altered
 interface.
+- Conversions between different types of `unique_ptr<T[], D>` that would
+ be disallowed for the corresponding pointer-to-array types, and
+ conversions to or from the non-array forms of `unique_ptr`, produce an
+  ill-formed program.
 - Pointers to types derived from `T` are rejected by the constructors,
   and by `reset`.
 - The observers `operator*` and `operator->` are not provided.
 - The indexing observer `operator[]` is provided.
 - The default deleter will call `delete[]`.
+Descriptions are provided below only for members that differ from the
+primary template.
 The template argument `T` shall be a complete type.
 ##### `unique_ptr` constructors <a id="unique.ptr.runtime.ctor">[[unique.ptr.runtime.ctor]]</a>
 ``` cpp
+template <class U> explicit unique_ptr(U p) noexcept;
 ```
+This constructor behaves the same as the constructor in the primary
+template that takes a single parameter of type `pointer` except that it
+additionally shall not participate in overload resolution unless
+- `U` is the same type as `pointer`, or
+- `pointer` is the same type as `element_type*`, `U` is a pointer type
+  `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
+``` cpp
+template <class U> unique_ptr(U p, see below d) noexcept;
+template <class U> unique_ptr(U p, see below d) noexcept;
+```
+These constructors behave the same as the constructors in the primary
+template that take a parameter of type `pointer` and a second parameter
+except that they shall not participate in overload resolution unless
+either
+- `U` is the same type as `pointer`,
+- `U` is `nullptr_t`, or
+- `pointer` is the same type as `element_type*`, `U` is a pointer type
+  `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
+``` cpp
+template <class U, class E>
+  unique_ptr(unique_ptr<U, E>&& u) noexcept;
+```
+This constructor behaves the same as in the primary template, except
+that it shall not participate in overload resolution unless all of the
+following conditions hold, where `UP` is `unique_ptr<U, E>`:
+- `U` is an array type, and
+- `pointer` is the same type as `element_type*`, and
+- `UP::pointer` is the same type as `UP::element_type*`, and
+- `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
+- either `D` is a reference type and `E` is the same type as `D`, or `D`
+  is not a reference type and `E` is implicitly convertible to `D`.
+[*Note 1*: This replaces the overload-resolution specification of the
+primary template — *end note*]
+##### `unique_ptr` assignment <a id="unique.ptr.runtime.asgn">[[unique.ptr.runtime.asgn]]</a>
+``` cpp
+template <class U, class E>
+  unique_ptr& operator=(unique_ptr<U, E>&& u)noexcept;
+```
+This operator behaves the same as in the primary template, except that
+it shall not participate in overload resolution unless all of the
+following conditions hold, where `UP` is `unique_ptr<U, E>`:
+- `U` is an array type, and
+- `pointer` is the same type as `element_type*`, and
+- `UP::pointer` is the same type as `UP::element_type*`, and
+- `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
+- `is_assignable_v<D&, E&&>` is `true`.
+[*Note 2*: This replaces the overload-resolution specification of the
+primary template — *end note*]
 ##### `unique_ptr` observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
 T& operator[](size_t i) const;
 *Returns:* `get()[i]`.
 ##### `unique_ptr` modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
+void reset(nullptr_t p = nullptr) noexcept;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
+``` cpp
+template <class U> void reset(U p) noexcept;
+```
+This function behaves the same as the `reset` member of the primary
+template, except that it shall not participate in overload resolution
+unless either
+- `U` is the same type as `pointer`, or
+- `pointer` is the same type as `element_type*`, `U` is a pointer type
+  `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 #### `unique_ptr` creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
 template <class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
 ```
 ``` cpp
 template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 ```
+*Remarks:* This function shall not participate in overload resolution
+unless `is_swappable_v<D>` is `true`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template <class T1, class D1, class T2, class D2>
   bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ``` cpp
 template <class T1, class D1, class T2, class D2>
   bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
+*Requires:* Let *`CT`* denote
+``` cpp
+common_type_t<typename unique_ptr<T1, D1>::pointer,
+              typename unique_ptr<T2, D2>::pointer>
+```
+Then the specialization `less<`*`CT`*`>` shall be a function object
+type ([[function.objects]]) that induces a strict weak
+ordering ([[alg.sorting]]) on the pointer values.
+*Returns:* `less<`*`CT`*`>()(x.get(), y.get())`.
 *Remarks:* If `unique_ptr<T1, D1>::pointer` is not implicitly
+convertible to *`CT`* or `unique_ptr<T2, D2>::pointer` is not implicitly
+convertible to *`CT`*, the program is ill-formed.
 ``` cpp
 template <class T1, class D1, class T2, class D2>
   bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* The first function template returns `!(x < nullptr)`. The
 second function template returns `!(nullptr < x)`.
 ### 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