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

Files changed (1) hide show

tmp/tmpzht9g5wq/{from.md → to.md} +60 -64

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

@@ -1,46 +1,48 @@
 #### `unique_ptr` for single objects <a id="unique.ptr.single">[[unique.ptr.single]]</a>
 ``` cpp
 namespace std {
   template<class T, class D = default_delete<T>> class unique_ptr {
   public:
     using pointer      = see below;
     using element_type = T;
     using deleter_type = D;
     // [unique.ptr.single.ctor], constructors
     constexpr unique_ptr() noexcept;
-    explicit unique_ptr(pointer p) noexcept;
-    unique_ptr(pointer p, see below d1) noexcept;
-    unique_ptr(pointer p, see below d2) noexcept;
-    unique_ptr(unique_ptr&& u) noexcept;
     constexpr unique_ptr(nullptr_t) noexcept;
     template<class U, class E>
-      unique_ptr(unique_ptr<U, E>&& u) noexcept;
     // [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;
-    pointer get() const noexcept;
-    deleter_type& get_deleter() noexcept;
-    const deleter_type& get_deleter() const noexcept;
-    explicit operator bool() const noexcept;
     // [unique.ptr.single.modifiers], modifiers
-    pointer release() noexcept;
-    void reset(pointer p = pointer()) noexcept;
-    void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
     unique_ptr(const unique_ptr&) = delete;
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
@@ -64,46 +66,43 @@ 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
@@ -111,19 +110,16 @@ 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.
@@ -151,11 +147,11 @@ unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object comb
 ```
 — *end example*]
 ``` 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
@@ -175,11 +171,11 @@ 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`,
@@ -205,26 +201,25 @@ 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
@@ -235,16 +230,17 @@ 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`,
@@ -259,16 +255,16 @@ 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`.
@@ -276,79 +272,79 @@ unique_ptr& operator=(nullptr_t) noexcept;
 *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*]
 ``` cpp
-pointer get() const noexcept;
 ```
 *Returns:* The stored pointer.
 ``` cpp
-deleter_type& get_deleter() noexcept;
-const deleter_type& get_deleter() const noexcept;
 ```
 *Returns:* A reference to the stored deleter.
 ``` cpp
-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`.

 #### `unique_ptr` for single objects <a id="unique.ptr.single">[[unique.ptr.single]]</a>
+##### General <a id="unique.ptr.single.general">[[unique.ptr.single.general]]</a>
 ``` cpp
 namespace std {
   template<class T, class D = default_delete<T>> class unique_ptr {
   public:
     using pointer      = see below;
     using element_type = T;
     using deleter_type = D;
     // [unique.ptr.single.ctor], constructors
     constexpr unique_ptr() noexcept;
+ constexpr explicit unique_ptr(type_identity_t<pointer> p) noexcept;
+ constexpr unique_ptr(type_identity_t<pointer> p, see below d1) noexcept;
+ constexpr unique_ptr(type_identity_t<pointer> p, see below d2) noexcept;
+ constexpr unique_ptr(unique_ptr&& u) noexcept;
     constexpr unique_ptr(nullptr_t) noexcept;
     template<class U, class E>
+ constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;
     // [unique.ptr.single.dtor], destructor
+ constexpr ~unique_ptr();
     // [unique.ptr.single.asgn], assignment
+ constexpr unique_ptr& operator=(unique_ptr&& u) noexcept;
     template<class U, class E>
+ constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
+ constexpr unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.single.observers], observers
+ constexpr add_lvalue_reference_t<T> operator*() const noexcept(see below);
+ constexpr pointer operator->() const noexcept;
+ constexpr pointer get() const noexcept;
+ constexpr deleter_type& get_deleter() noexcept;
+ constexpr const deleter_type& get_deleter() const noexcept;
+ constexpr explicit operator bool() const noexcept;
     // [unique.ptr.single.modifiers], modifiers
+ constexpr pointer release() noexcept;
+ constexpr void reset(pointer p = pointer()) noexcept;
+ constexpr void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
     unique_ptr(const unique_ptr&) = delete;
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
 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`
+[[allocator.requirements.general]] 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;
 ```
+*Constraints:* `is_pointer_v<deleter_type>` is `false` and
+`is_default_constructible_v<deleter_type>` is `true`.
 *Preconditions:* `D` meets the *Cpp17DefaultConstructible* requirements
 ([[cpp17.defaultconstructible]]), and that construction does not throw
 an exception.
 *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
+constexpr explicit unique_ptr(type_identity_t<pointer> p) noexcept;
 ```
 *Constraints:* `is_pointer_v<deleter_type>` is `false` and
 `is_default_constructible_v<deleter_type>` is `true`.
 *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
 *Ensures:* `get() == p`. `get_deleter()` returns a reference to the
 stored deleter.
 ``` cpp
+constexpr unique_ptr(type_identity_t<pointer> p, const D& d) noexcept;
+constexpr unique_ptr(type_identity_t<pointer> p, remove_reference_t<D>&& d) noexcept;
 ```
 *Constraints:* `is_constructible_v<D, decltype(d)>` is `true`.
 *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.
 ```
 — *end example*]
 ``` cpp
+constexpr 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
 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> constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
 *Constraints:*
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
 to the stored deleter that was constructed from `u.get_deleter()`.
 ##### Destructor <a id="unique.ptr.single.dtor">[[unique.ptr.single.dtor]]</a>
 ``` cpp
+constexpr ~unique_ptr();
 ```
+*Effects:* Equivalent to: `if (get()) get_deleter()(get());`
 [*Note 3*: The use of `default_delete` requires `T` to be a complete
 type. — *end note*]
+*Remarks:* The behavior is undefined if the evaluation of
+`get_deleter()(get())` throws an exception.
 ##### Assignment <a id="unique.ptr.single.asgn">[[unique.ptr.single.asgn]]</a>
 ``` cpp
+constexpr 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
 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())`.
+*Ensures:* If `this != addressof(u)`, `u.get() == nullptr`, otherwise
+`u.get()` is unchanged.
 *Returns:* `*this`.
 ``` cpp
+template<class U, class E> constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 ```
 *Constraints:*
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer`,
 exception.
 *Effects:* Calls `reset(u.release())` followed by
 `get_deleter() = std::forward<E>(u.get_deleter())`.
 *Ensures:* `u.get() == nullptr`.
+*Returns:* `*this`.
 ``` cpp
+constexpr 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
+constexpr add_lvalue_reference_t<T> operator*() const noexcept(noexcept(*declval<pointer>()));
 ```
 *Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
+constexpr 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*]
 ``` cpp
+constexpr pointer get() const noexcept;
 ```
 *Returns:* The stored pointer.
 ``` cpp
+constexpr deleter_type& get_deleter() noexcept;
+constexpr const deleter_type& get_deleter() const noexcept;
 ```
 *Returns:* A reference to the stored deleter.
 ``` cpp
+constexpr explicit operator bool() const noexcept;
 ```
 *Returns:* `get() != nullptr`.
 ##### Modifiers <a id="unique.ptr.single.modifiers">[[unique.ptr.single.modifiers]]</a>
 ``` cpp
+constexpr pointer release() noexcept;
 ```
 *Ensures:* `get() == nullptr`.
 *Returns:* The value `get()` had at the start of the call to `release`.
 ``` cpp
+constexpr void reset(pointer p = pointer()) noexcept;
 ```
+*Effects:* Assigns `p` to the stored pointer, and then, with the old
+value of the stored pointer, `old_p`, evaluates
+`if (old_p) get_deleter()(old_p);`
 [*Note 5*: The order of these operations is significant because the
+call to `get_deleter()` might 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*]
+*Remarks:* The behavior is undefined if the evaluation of
+`get_deleter()(old_p)` throws an exception.
 ``` cpp
+constexpr void swap(unique_ptr& u) noexcept;
 ```
 *Preconditions:* `get_deleter()` is swappable [[swappable.requirements]]
 and does not throw an exception under `swap`.

Diff to HTML by rtfpessoa