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

Files changed (1) hide show

tmp/tmppbpvy1z8/{from.md → to.md} +66 -34

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

@@ -37,12 +37,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;
@@ -169,11 +169,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);
 ```
@@ -227,19 +227,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`.
@@ -254,11 +254,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);
 ```
@@ -282,11 +282,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.
@@ -439,11 +439,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;
 ```
@@ -489,13 +489,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>
@@ -509,11 +509,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
@@ -646,14 +646,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
@@ -680,29 +680,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
@@ -726,19 +730,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();
 ```
@@ -757,10 +774,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;
 ```
@@ -794,15 +822,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
@@ -818,11 +847,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
@@ -1049,11 +1078,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.
@@ -1076,11 +1105,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
@@ -1102,20 +1131,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())`.

     // [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