[util.smartptr.shared.const]

Files changed (1) hide show

tmp/tmpa321_hbn/{from.md → to.md} +15 -14

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

@@ -1,6 +1,6 @@
-#### 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>*`
@@ -24,18 +24,18 @@ constexpr shared_ptr() noexcept;
 ``` cpp
 template<class Y> explicit shared_ptr(Y* p);
 ```
-*Mandates:* `Y` is a complete type.
 *Constraints:* When `T` is an array type, 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, the expression `delete p` is well-formed and `Y*` is
 convertible to `T*`.
 *Preconditions:* The expression `delete[] p`, when `T` is an array type,
 or `delete p`, when `T` is not an array type, has well-defined behavior,
 and does not throw exceptions.
 *Effects:* When `T` is not an array type, constructs a `shared_ptr`
@@ -46,11 +46,11 @@ with `p`. If an exception is thrown, `delete p` is called when `T` is
 not an array type, `delete[] p` otherwise.
 *Ensures:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
-resource other than memory could not be obtained.
 ``` 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);
@@ -66,22 +66,23 @@ well-formed expression. For the first two overloads:
 - If `T` is not an array type, then `Y*` is convertible to `T*`.
 *Preconditions:* Construction of `d` and a deleter of type `D`
 initialized with `std::move(d)` do not throw exceptions. The expression
 `d(p)` has well-defined behavior and does not throw exceptions. `A`
-meets the *Cpp17Allocator* requirements ([[cpp17.allocator]]).
 *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.
 *Ensures:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
-resource other than memory could not be obtained.
 ``` cpp
 template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
 template<class Y> shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
 ```
@@ -90,13 +91,13 @@ template<class Y> shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
 ownership with the initial value of `r`.
 *Ensures:* `get() == p`. For the second overload, `r` is empty and
 `r.get() == nullptr`.
-[*Note 1*: To avoid the possibility of a dangling pointer, the user of
-this constructor should 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
@@ -119,12 +120,12 @@ template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
 *Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `shared_ptr` instance from `r`.
-*Ensures:* `*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);
 ```
@@ -145,9 +146,9 @@ template<class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
 *Constraints:* `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.

+##### 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>*`
 ``` cpp
 template<class Y> explicit shared_ptr(Y* p);
 ```
 *Constraints:* When `T` is an array type, 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, the expression `delete p` is well-formed and `Y*` is
 convertible to `T*`.
+*Mandates:* `Y` is a complete type.
 *Preconditions:* The expression `delete[] p`, when `T` is an array type,
 or `delete p`, when `T` is not an array type, has well-defined behavior,
 and does not throw exceptions.
 *Effects:* When `T` is not an array type, constructs a `shared_ptr`
 not an array type, `delete[] p` otherwise.
 *Ensures:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
+resource other than memory cannot be obtained.
 ``` 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);
 - If `T` is not an array type, then `Y*` is convertible to `T*`.
 *Preconditions:* Construction of `d` and a deleter of type `D`
 initialized with `std::move(d)` do not throw exceptions. The expression
 `d(p)` has well-defined behavior and does not throw exceptions. `A`
+meets the *Cpp17Allocator*
+requirements [[allocator.requirements.general]].
 *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.
 *Ensures:* `use_count() == 1 && get() == p`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
+resource other than memory cannot be obtained.
 ``` cpp
 template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
 template<class Y> shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
 ```
 ownership with the initial value of `r`.
 *Ensures:* `get() == p`. For the second overload, `r` is empty and
 `r.get() == nullptr`.
+[*Note 1*: Use of this constructor leads to a dangling pointer unless
+`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
 *Constraints:* For the second constructor, `Y*` is compatible with `T*`.
 *Effects:* Move constructs a `shared_ptr` instance from `r`.
+*Ensures:* `*this` contains the old value of `r`. `r` is empty, and
+`r.get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
 ```
 *Constraints:* `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(), std::move(r.get_deleter()))`. Otherwise,
+equivalent to `shared_ptr(r.release(), ref(r.get_deleter()))`. If an
+exception is thrown, the constructor has no effect.

Diff to HTML by rtfpessoa