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

Files changed (1) hide show

tmp/tmppxk80745/{from.md → to.md} +17 -17

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

@@ -15,12 +15,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;
@@ -147,11 +147,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);
 ```
@@ -205,19 +205,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`.
@@ -232,11 +232,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);
 ```
@@ -260,11 +260,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.
@@ -417,11 +417,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;
 ```
@@ -467,13 +467,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>
@@ -487,11 +487,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
@@ -624,14 +624,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

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

Diff to HTML by rtfpessoa