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

Files changed (1) hide show

tmp/tmpmnj87b_u/{from.md → to.md} +110 -54

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

@@ -50,10 +50,14 @@ namespace std {
   template<class T> struct default_delete<T[]>;
   template<class T, class D = default_delete<T>> class unique_ptr;
   template<class T, class D> class unique_ptr<T[], D>;
   template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
   template<class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
@@ -185,11 +189,11 @@ namespace std {
     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.single.observers], observers
- typename add_lvalue_reference<T>::type operator*() const;
     pointer operator->() const noexcept;
     pointer get() const noexcept;
     deleter_type& get_deleter() noexcept;
     const deleter_type& get_deleter() const noexcept;
     explicit operator bool() const noexcept;
@@ -215,16 +219,14 @@ 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<D>::type::pointer` exists, then
-`unique_ptr<T,
-D>::pointer` shall be a synonym for
-`remove_reference<D>::type::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`,
@@ -420,18 +422,17 @@ 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<D>::type` shall satisfy the `CopyAssignable`
-requirements and assignment of the deleter from an lvalue of type `D`
-shall not throw an exception.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
-`reset(u.release())` followed by an assignment from
-`std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
@@ -448,12 +449,12 @@ 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 an assignment from
-`std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
@@ -466,11 +467,11 @@ unique_ptr& operator=(nullptr_t) noexcept;
 *Returns:* `*this`.
 ##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
-typename add_lvalue_reference<T>::type operator*() const;
 ```
 *Requires:* `get() != nullptr`.
 *Returns:* `*get()`.
@@ -629,18 +630,41 @@ stored pointer points.
 *Returns:* `get()[i]`.
 ##### `unique_ptr` modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
-void reset(pointer p = pointer()) noexcept;
 void reset(nullptr_t p) noexcept;
 ```
-*Effects:* If `get() == nullptr` there are no effects. Otherwise
-`get_deleter()(get())`.
-`get() == p`.
 #### `unique_ptr` specialized algorithms <a id="unique.ptr.special">[[unique.ptr.special]]</a>
 ``` cpp
 template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
@@ -802,12 +826,12 @@ namespace std {
     // [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;
@@ -934,11 +958,11 @@ races.
 constexpr shared_ptr() noexcept;
 ```
 *Effects:* Constructs an *empty* `shared_ptr` object.
-*Postconditions:* `use_count() == 0 && get() == 0`.
 ``` cpp
 template<class Y> explicit shared_ptr(Y* p);
 ```
@@ -992,19 +1016,19 @@ template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept;
 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;
 ```
-*Requires:* The second constructor shall not participate in the 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`.
@@ -1019,11 +1043,11 @@ 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() == 0.`
 ``` cpp
 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
 ```
@@ -1047,11 +1071,11 @@ 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() == 0`.
 *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.
@@ -1204,11 +1228,11 @@ 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() == 0`.
 ``` cpp
 explicit operator bool() const noexcept;
 ```
@@ -1254,13 +1278,13 @@ 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 are encouraged, but not required, to 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>
@@ -1274,11 +1298,11 @@ template<class T, class U> bool operator==(const shared_ptr<T>& a, const shared_
 ``` 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 ([[expr.rel]]) of `T*` and `U*`.
 Defining a comparison operator allows `shared_ptr` objects to be used as
 keys in associative containers.
 ``` cpp
@@ -1411,14 +1435,14 @@ undefined behavior, attempting to delete the same object twice.
 ``` 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 `0`. 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
@@ -1445,29 +1469,33 @@ namespace std {
     // [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;
     // [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;
     // [util.smartptr.weak.mod], modifiers
     void swap(weak_ptr& r) noexcept;
     void reset() noexcept;
     // [util.smartptr.weak.obs], observers
     long use_count() const noexcept;
     bool expired() const noexcept;
     shared_ptr<T> lock() const noexcept;
-    template<class U> bool owner_before(shared_ptr<U> const& b);
-    template<class U> bool owner_before(weak_ptr<U> const& b);
   };
   // [util.smartptr.weak.spec], specialized algorithms
   template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 } // namespace std
@@ -1491,19 +1519,32 @@ constexpr weak_ptr() noexcept;
 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;
 ```
-*Requires:* The second and third constructors shall not participate in
-the 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()`.
 ##### `weak_ptr` destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
 ``` cpp
 ~weak_ptr();
 ```
@@ -1522,10 +1563,21 @@ template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 *Effects:* Equivalent to `weak_ptr(r).swap(*this)`.
 *Remarks:* The implementation may meet the effects (and the implied
 guarantees) via different means, without creating a temporary.
 ##### `weak_ptr` modifiers <a id="util.smartptr.weak.mod">[[util.smartptr.weak.mod]]</a>
 ``` cpp
 void swap(weak_ptr& r) noexcept;
 ```
@@ -1559,15 +1611,16 @@ bool expired() const noexcept;
 ``` cpp
 shared_ptr<T> lock() const noexcept;
 ```
-*Returns:* `expired() ? shared_ptr<T>() : shared_ptr<T>(*this)`.
 ``` cpp
-template<class U> bool owner_before(shared_ptr<U> const& b);
-template<class U> bool owner_before(weak_ptr<U> const& b);
 ```
 *Returns:* An unspecified value such that
 - `x.owner_before(y)` defines a strict weak ordering as defined
@@ -1583,11 +1636,11 @@ template<class U> bool owner_before(weak_ptr<U> const& b);
 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
@@ -1814,11 +1867,11 @@ template<class T>
 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.
 *Returns:*
 `atomic_compare_exchange_weak_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)`.
 *Throws:* Nothing.
@@ -1841,11 +1894,11 @@ 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.
 *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
@@ -1867,20 +1920,23 @@ See  [[atomics.types.operations]].
 ``` cpp
 template <class T, class D> struct hash<unique_ptr<T, D> >;
 ```
-*Requires:* 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())`. The
-specialization `hash<typename UP::pointer>` shall be well-formed.
 ``` cpp
 template <class T> struct hash<shared_ptr<T> >;
 ```
-*Requires:* 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())`.

   template<class T> struct default_delete<T[]>;
   template<class T, class D = default_delete<T>> class unique_ptr;
   template<class T, class D> class unique_ptr<T[], D>;
+  template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
+  template<class T> unique_ptr<T> make_unique(size_t n);
+  template<class T, class... Args> unspecified make_unique(Args&&...) = delete;
   template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
   template<class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
     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.single.observers], observers
+ add_lvalue_reference_t<T> operator*() const;
     pointer operator->() const noexcept;
     pointer get() const noexcept;
     deleter_type& get_deleter() noexcept;
     const deleter_type& get_deleter() const noexcept;
     explicit operator bool() const noexcept;
 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`,
 ```
 *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.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
+`reset(u.release())` followed by
+`get_deleter() = std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 - `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())`.
 *Returns:* `*this`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 *Returns:* `*this`.
 ##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
+add_lvalue_reference_t<T> operator*() const;
 ```
 *Requires:* `get() != nullptr`.
 *Returns:* `*get()`.
 *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);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `T` is not an array.
+*Returns:* `unique_ptr<T>(new T(std::forward<Args>(args)...))`.
+``` cpp
+template <class T> unique_ptr<T> make_unique(size_t n);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `T` is an array of unknown bound.
+*Returns:* `unique_ptr<T>(new remove_extent_t<T>[n]())`.
+``` cpp
+template <class T, class... Args> unspecified make_unique(Args&&...) = delete;
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `T` is an array of known bound.
 #### `unique_ptr` specialized algorithms <a id="unique.ptr.special">[[unique.ptr.special]]</a>
 ``` cpp
 template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
     // [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;
 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);
 ```
 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`.
 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);
 ```
 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.
 *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;
 ```
 *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:* `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
 ``` 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
     // [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;
     void reset() noexcept;
     // [util.smartptr.weak.obs], observers
     long use_count() const noexcept;
     bool expired() const noexcept;
     shared_ptr<T> lock() const noexcept;
+    template<class U> bool owner_before(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
 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();
 ```
 *Effects:* Equivalent to `weak_ptr(r).swap(*this)`.
 *Remarks:* The implementation may meet the effects (and the implied
 guarantees) via different means, without creating a temporary.
+*Returns:* `*this`.
+``` cpp
+weak_ptr& operator=(weak_ptr&& r) noexcept;
+template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
+```
+*Effects:* Equivalent to `weak_ptr(std::move(r)).swap(*this)`.
+*Returns:* `*this`.
 ##### `weak_ptr` modifiers <a id="util.smartptr.weak.mod">[[util.smartptr.weak.mod]]</a>
 ``` cpp
 void swap(weak_ptr& r) noexcept;
 ```
 ``` 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
 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
 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.
   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
 ``` 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())`.

Diff to HTML by rtfpessoa