[unique.ptr.single] - C++17 → C++20

Files changed (1) hide show

tmp/tmp1zha6m98/{from.md → to.md} +111 -128

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

@@ -21,11 +21,12 @@ namespace std {
     // [unique.ptr.single.dtor], destructor
     ~unique_ptr();
     // [unique.ptr.single.asgn], 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.single.observers], observers
     add_lvalue_reference_t<T> operator*() const;
     pointer operator->() const noexcept;
@@ -45,126 +46,107 @@ 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  [[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
 ```
@@ -172,142 +154,144 @@ unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object comb
 ``` 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
-lvalue deleter.
 ``` cpp
 template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
-*Requires:* If `E` is not a reference type, construction of the deleter
-from an rvalue of type `E` shall be well formed and shall not throw an
-exception. Otherwise, `E` is a reference type and construction of the
-deleter from an lvalue of type `E` shall be well formed and shall not
-throw an exception.
-*Remarks:* This constructor shall not participate in overload resolution
-unless:
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
 - `U` is not an array 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`.
-*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.
-*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;
 ```
-*Requires:* If `E` is not a reference type, assignment of the deleter
-from an rvalue of type `E` shall be well-formed and shall not throw an
-exception. Otherwise, `E` is a reference type and assignment of the
-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, 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())`.
 *Returns:* `*this`.
 ``` 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>
 ``` cpp
 add_lvalue_reference_t<T> operator*() const;
 ```
-*Requires:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
 pointer operator->() const noexcept;
 ```
-*Requires:* `get() != nullptr`.
 *Returns:* `get()`.
 [*Note 4*: The use of this function typically requires that `T` be a
 complete type. — *end note*]
@@ -329,46 +313,45 @@ const deleter_type& get_deleter() const noexcept;
 explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
-##### `unique_ptr` modifiers <a id="unique.ptr.single.modifiers">[[unique.ptr.single.modifiers]]</a>
 ``` 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;
 ```
-*Requires:* `get_deleter()` shall be
-swappable ([[swappable.requirements]]) and shall not throw an exception
-under `swap`.
 *Effects:* Invokes `swap` on the stored pointers and on the stored
 deleters of `*this` and `u`.

     // [unique.ptr.single.dtor], destructor
     ~unique_ptr();
     // [unique.ptr.single.asgn], 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.single.observers], observers
     add_lvalue_reference_t<T> operator*() const;
     pointer operator->() const noexcept;
   };
 }
 ```
 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 meet the
+*Cpp17Destructible* requirements ([[cpp17.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 meet the *Cpp17NullablePointer* requirements (
+[[cpp17.nullablepointer]]).
+[*Example 1*: Given an allocator type `X` ([[cpp17.allocator]]) 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*]
+##### Constructors <a id="unique.ptr.single.ctor">[[unique.ptr.single.ctor]]</a>
 ``` cpp
 constexpr unique_ptr() noexcept;
 constexpr unique_ptr(nullptr_t) noexcept;
 ```
+*Preconditions:* `D` meets the *Cpp17DefaultConstructible* requirements
+([[cpp17.defaultconstructible]]), and that construction does not throw
+an exception.
+*Constraints:* `is_pointer_v<deleter_type>` is `false` and
+`is_default_constructible_v<deleter_type>` is `true`.
 *Effects:* Constructs a `unique_ptr` object that owns nothing,
 value-initializing the stored pointer and the stored deleter.
+*Ensures:* `get() == nullptr`. `get_deleter()` returns a reference to
+the stored deleter.
 ``` cpp
 explicit unique_ptr(pointer p) noexcept;
 ```
+*Constraints:* `is_pointer_v<deleter_type>` is `false` and
+`is_default_constructible_v<deleter_type>` is `true`.
+*Mandates:* This constructor is not selected by class template argument
+deduction [[over.match.class.deduct]].
+*Preconditions:* `D` meets the *Cpp17DefaultConstructible* requirements
+([[cpp17.defaultconstructible]]), and that construction does not throw
+an exception.
 *Effects:* Constructs a `unique_ptr` which owns `p`, initializing the
 stored pointer with `p` and value-initializing the stored deleter.
+*Ensures:* `get() == p`. `get_deleter()` returns a reference to the
+stored deleter.
 ``` cpp
+unique_ptr(pointer p, const D& d) noexcept;
+unique_ptr(pointer p, remove_reference_t<D>&& d) noexcept;
 ```
+*Constraints:* `is_constructible_v<D, decltype(d)>` is `true`.
+*Mandates:* These constructors are not selected by class template
+argument deduction [[over.match.class.deduct]].
+*Preconditions:* For the first constructor, if `D` is not a reference
+type, `D` meets the *Cpp17CopyConstructible* requirements and such
+construction does not exit via an exception. For the second constructor,
+if `D` is not a reference type, `D` meets the *Cpp17MoveConstructible*
+requirements and such construction does not exit via an exception.
 *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)`.
+*Ensures:* `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 `D` is a reference type, the second constructor is defined
+as deleted.
 [*Example 1*:
 ``` cpp
 D d;
+unique_ptr<int, D> p1(new int, D());        // D must be Cpp17MoveConstructible
+unique_ptr<int, D> p2(new int, d);          // D must be Cpp17CopyConstructible
 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;
 ```
+*Constraints:* `is_move_constructible_v<D>` is `true`.
+*Preconditions:* If `D` is not a reference type, `D` meets the
+*Cpp17MoveConstructible* requirements ([[cpp17.moveconstructible]]).
+Construction of the deleter from an rvalue of type `D` does not throw an
+exception.
+*Effects:* Constructs a `unique_ptr` from `u`. 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 construction of the deleter can be implemented with
 `std::forward<D>`. — *end note*]
+*Ensures:* `get()` yields the value `u.get()` yielded before the
+construction. `u.get() == nullptr`. `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 lvalue deleter.
 ``` cpp
 template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
+*Constraints:*
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
 - `U` is not an array 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`.
+*Preconditions:* If `E` is not a reference type, construction of the
+deleter from an rvalue of type `E` is well-formed and does not throw an
+exception. Otherwise, `E` is a reference type and construction of the
+deleter from an lvalue of type `E` is well-formed and does not throw an
+exception.
+*Effects:* Constructs a `unique_ptr` from `u`. 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*]
+*Ensures:* `get()` yields the value `u.get()` yielded before the
+construction. `u.get() == nullptr`. `get_deleter()` returns a reference
+to the stored deleter that was constructed from `u.get_deleter()`.
+##### Destructor <a id="unique.ptr.single.dtor">[[unique.ptr.single.dtor]]</a>
 ``` cpp
 ~unique_ptr();
 ```
+*Preconditions:* The expression `get_deleter()(get())` is well-formed,
+has well-defined behavior, and does 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())`.
+##### Assignment <a id="unique.ptr.single.asgn">[[unique.ptr.single.asgn]]</a>
 ``` cpp
 unique_ptr& operator=(unique_ptr&& u) noexcept;
 ```
+*Constraints:* `is_move_assignable_v<D>` is `true`.
+*Preconditions:* If `D` is not a reference type, `D` meets the
+*Cpp17MoveAssignable* requirements ([[cpp17.moveassignable]]) and
+assignment of the deleter from an rvalue of type `D` does not throw an
 exception. Otherwise, `D` is a reference type; `remove_reference_t<D>`
+meets the *Cpp17CopyAssignable* requirements and assignment of the
+deleter from an lvalue of type `D` does not throw an exception.
+*Effects:* Calls `reset(u.release())` followed by
 `get_deleter() = std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
+*Ensures:* `u.get() == nullptr`.
 ``` cpp
 template<class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 ```
+*Constraints:*
 - `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`.
+*Preconditions:* If `E` is not a reference type, assignment of the
+deleter from an rvalue of type `E` is well-formed and does not throw an
+exception. Otherwise, `E` is a reference type and assignment of the
+deleter from an lvalue of type `E` is well-formed and does not throw an
+exception.
+*Effects:* Calls `reset(u.release())` followed by
 `get_deleter() = std::forward<E>(u.get_deleter())`.
 *Returns:* `*this`.
+*Ensures:* `u.get() == nullptr`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 ```
 *Effects:* As if by `reset()`.
+*Ensures:* `get() == nullptr`.
 *Returns:* `*this`.
+##### Observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
 add_lvalue_reference_t<T> operator*() const;
 ```
+*Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
 pointer operator->() const noexcept;
 ```
+*Preconditions:* `get() != nullptr`.
 *Returns:* `get()`.
 [*Note 4*: The use of this function typically requires that `T` be a
 complete type. — *end note*]
 explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
+##### Modifiers <a id="unique.ptr.single.modifiers">[[unique.ptr.single.modifiers]]</a>
 ``` cpp
 pointer release() noexcept;
 ```
+*Ensures:* `get() == nullptr`.
 *Returns:* The value `get()` had at the start of the call to `release`.
 ``` cpp
 void reset(pointer p = pointer()) noexcept;
 ```
+*Preconditions:* The expression `get_deleter()(get())` is well-formed,
+has well-defined behavior, and does 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*]
+*Ensures:* `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;
 ```
+*Preconditions:* `get_deleter()` is swappable [[swappable.requirements]]
+and does not throw an exception under `swap`.
 *Effects:* Invokes `swap` on the stored pointers and on the stored
 deleters of `*this` and `u`.

Diff to HTML by rtfpessoa