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

Files changed (1) hide show

tmp/tmplqu9v8b9/{from.md → to.md} +124 -120

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

@@ -1,6 +1,8 @@
-### Class template `unique_ptr` <a id="unique.ptr">[[unique.ptr]]</a>
 A *unique pointer* is an object that owns another object and manages
 that other object through a pointer. More precisely, a unique pointer is
 an object *u* that stores a pointer to a second object *p* and will
 dispose of *p* when *u* is itself destroyed (e.g., when leaving block
@@ -15,11 +17,11 @@ denote the associated deleter. Upon request, *u* can *reset* (replace)
 *u.p* and *u.d* with another pointer and deleter, but properly disposes
 of its owned object via the associated deleter before such replacement
 is considered completed.
 Each object of a type `U` instantiated from the `unique_ptr` template
-specified in this subclause has the strict ownership semantics,
 specified above, of a unique pointer. In partial satisfaction of these
 semantics, each such `U` is *Cpp17MoveConstructible* and
 *Cpp17MoveAssignable*, but is not *Cpp17CopyConstructible* nor
 *Cpp17CopyAssignable*. The template parameter `T` of `unique_ptr` may be
 an incomplete type.
@@ -43,27 +45,27 @@ type.
 ``` cpp
 namespace std {
   template<class T> struct default_delete {
     constexpr default_delete() noexcept = default;
-    template<class U> default_delete(const default_delete<U>&) noexcept;
-    void operator()(T*) const;
   };
 }
 ```
 ``` cpp
-template<class U> default_delete(const default_delete<U>& other) noexcept;
 ```
 *Constraints:* `U*` is implicitly convertible to `T*`.
 *Effects:* Constructs a `default_delete` object from another
 `default_delete<U>` object.
 ``` cpp
-void operator()(T* ptr) const;
 ```
 *Mandates:* `T` is a complete type.
 *Effects:* Calls `delete` on `ptr`.
@@ -72,76 +74,78 @@ void operator()(T* ptr) const;
 ``` cpp
 namespace std {
   template<class T> struct default_delete<T[]> {
     constexpr default_delete() noexcept = default;
-    template<class U> default_delete(const default_delete<U[]>&) noexcept;
-    template<class U> void operator()(U* ptr) const;
   };
 }
 ```
 ``` cpp
-template<class U> default_delete(const default_delete<U[]>& other) noexcept;
 ```
 *Constraints:* `U(*)[]` is convertible to `T(*)[]`.
 *Effects:* Constructs a `default_delete` object from another
 `default_delete<U[]>` object.
 ``` cpp
-template<class U> void operator()(U* ptr) const;
 ```
 *Mandates:* `U` is a complete type.
-*Constraints:* `U(*)[]` is convertible to `T(*)[]`.
 *Effects:* Calls `delete[]` on `ptr`.
 #### `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;
   };
@@ -165,46 +169,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
@@ -212,19 +213,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.
@@ -252,11 +250,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
@@ -276,11 +274,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`,
@@ -306,26 +304,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
@@ -336,16 +333,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`,
@@ -360,16 +358,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`.
@@ -377,128 +375,130 @@ 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`.
 *Effects:* Invokes `swap` on the stored pointers and on the stored
 deleters of `*this` and `u`.
 #### `unique_ptr` for array objects with a runtime length <a id="unique.ptr.runtime">[[unique.ptr.runtime]]</a>
 ``` cpp
 namespace std {
   template<class T, class D> class unique_ptr<T[], D> {
   public:
     using pointer      = see below;
     using element_type = T;
     using deleter_type = D;
     // [unique.ptr.runtime.ctor], constructors
     constexpr unique_ptr() noexcept;
-    template<class U> explicit unique_ptr(U p) noexcept;
-    template<class U> unique_ptr(U p, see below d) noexcept;
-    template<class U> unique_ptr(U p, see below d) noexcept;
-    unique_ptr(unique_ptr&& u) noexcept;
     template<class U, class E>
-      unique_ptr(unique_ptr<U, E>&& u) noexcept;
     constexpr unique_ptr(nullptr_t) noexcept;
     // destructor
-    ~unique_ptr();
     // 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.runtime.observers], observers
-    T& operator[](size_t i) const;
-    pointer get() const noexcept;
-    deleter_type& get_deleter() noexcept;
-    const deleter_type& get_deleter() const noexcept;
-    explicit operator bool() const noexcept;
     // [unique.ptr.runtime.modifiers], modifiers
-    pointer release() noexcept;
-    template<class U> void reset(U p) noexcept;
-    void reset(nullptr_t = nullptr) noexcept;
-    void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
     unique_ptr(const unique_ptr&) = delete;
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
@@ -524,11 +524,11 @@ primary template.
 The template argument `T` shall be a complete type.
 ##### Constructors <a id="unique.ptr.runtime.ctor">[[unique.ptr.runtime.ctor]]</a>
 ``` cpp
-template<class U> explicit unique_ptr(U p) noexcept;
 ```
 This constructor behaves the same as the constructor in the primary
 template that takes a single parameter of type `pointer`.
@@ -537,12 +537,12 @@ template that takes a single parameter of type `pointer`.
 - `U` is the same type as `pointer`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 ``` cpp
-template<class U> unique_ptr(U p, see below d) noexcept;
-template<class U> unique_ptr(U p, see below d) noexcept;
 ```
 These constructors behave the same as the constructors in the primary
 template that take a parameter of type `pointer` and a second parameter.
@@ -552,11 +552,11 @@ template that take a parameter of type `pointer` and a second parameter.
 - `U` is `nullptr_t`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 ``` cpp
-template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
 This constructor behaves the same as in the primary template.
 *Constraints:* Where `UP` is `unique_ptr<U, E>`:
@@ -572,11 +572,11 @@ This constructor behaves the same as in the primary template.
 primary template. — *end note*]
 ##### Assignment <a id="unique.ptr.runtime.asgn">[[unique.ptr.runtime.asgn]]</a>
 ``` cpp
-template<class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u)noexcept;
 ```
 This operator behaves the same as in the primary template.
 *Constraints:* Where `UP` is `unique_ptr<U, E>`:
@@ -591,28 +591,28 @@ This operator behaves the same as in the primary template.
 primary template. — *end note*]
 ##### Observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
-T& operator[](size_t i) const;
 ```
 *Preconditions:* `i` < the number of elements in the array to which the
 stored pointer points.
 *Returns:* `get()[i]`.
 ##### Modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
-void reset(nullptr_t p = nullptr) noexcept;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
 ``` cpp
-template<class U> void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
 template.
@@ -623,19 +623,19 @@ template.
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 #### Creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
-template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
 ```
 *Constraints:* `T` is not an array type.
 *Returns:* `unique_ptr<T>(new T(std::forward<Args>(args)...))`.
 ``` cpp
-template<class T> unique_ptr<T> make_unique(size_t n);
 ```
 *Constraints:* `T` is an array of unknown bound.
 *Returns:* `unique_ptr<T>(new remove_extent_t<T>[n]())`.
@@ -645,19 +645,19 @@ template<class T, class... Args> unspecified make_unique(Args&&...) = delete;
 ```
 *Constraints:* `T` is an array of known bound.
 ``` cpp
-template<class T> unique_ptr<T> make_unique_for_overwrite();
 ```
 *Constraints:* `T` is not an array type.
 *Returns:* `unique_ptr<T>(new T)`.
 ``` cpp
-template<class T> unique_ptr<T> make_unique_for_overwrite(size_t n);
 ```
 *Constraints:* `T` is an array of unknown bound.
 *Returns:* `unique_ptr<T>(new remove_extent_t<T>[n])`.
@@ -669,20 +669,20 @@ template<class T, class... Args> unspecified make_unique_for_overwrite(Args&&...
 *Constraints:* `T` is an array of known bound.
 #### Specialized algorithms <a id="unique.ptr.special">[[unique.ptr.special]]</a>
 ``` cpp
-template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 ```
 *Constraints:* `is_swappable_v<D>` is `true`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
-  bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `x.get() == y.get()`.
 ``` cpp
@@ -740,20 +740,20 @@ template<class T1, class D1, class T2, class D2>
 *Returns:* `compare_three_way()(x.get(), y.get())`.
 ``` cpp
 template<class T, class D>
-  bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
 ```
 *Returns:* `!x`.
 ``` cpp
 template<class T, class D>
-  bool operator<(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
-  bool operator<(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Preconditions:* The specialization `less<unique_ptr<T, D>::pointer>` is
 a function object type [[function.objects]] that induces a strict weak
 ordering [[alg.sorting]] on the pointer values.
@@ -770,46 +770,50 @@ The second function template returns
 less<unique_ptr<T, D>::pointer>()(nullptr, x.get())
 ```
 ``` cpp
 template<class T, class D>
-  bool operator>(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
-  bool operator>(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Returns:* The first function template returns `nullptr < x`. The second
 function template returns `x < nullptr`.
 ``` cpp
 template<class T, class D>
-  bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
-  bool operator<=(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Returns:* The first function template returns `!(nullptr < x)`. The
 second function template returns `!(x < nullptr)`.
 ``` cpp
 template<class T, class D>
-  bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
-  bool operator>=(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Returns:* The first function template returns `!(x < nullptr)`. The
 second function template returns `!(nullptr < x)`.
 ``` cpp
 template<class T, class D>
-  requires three_way_comparable_with<typename unique_ptr<T, D>::pointer, nullptr_t>
-  compare_three_way_result_t<typename unique_ptr<T, D>::pointer, nullptr_t>
     operator<=>(const unique_ptr<T, D>& x, nullptr_t);
 ```
-*Returns:* `compare_three_way()(x.get(), nullptr)`.
 #### I/O <a id="unique.ptr.io">[[unique.ptr.io]]</a>
 ``` cpp
 template<class E, class T, class Y, class D>

+### Unique-ownership pointers <a id="unique.ptr">[[unique.ptr]]</a>
+#### General <a id="unique.ptr.general">[[unique.ptr.general]]</a>
 A *unique pointer* is an object that owns another object and manages
 that other object through a pointer. More precisely, a unique pointer is
 an object *u* that stores a pointer to a second object *p* and will
 dispose of *p* when *u* is itself destroyed (e.g., when leaving block
 *u.p* and *u.d* with another pointer and deleter, but properly disposes
 of its owned object via the associated deleter before such replacement
 is considered completed.
 Each object of a type `U` instantiated from the `unique_ptr` template
+specified in [[unique.ptr]] has the strict ownership semantics,
 specified above, of a unique pointer. In partial satisfaction of these
 semantics, each such `U` is *Cpp17MoveConstructible* and
 *Cpp17MoveAssignable*, but is not *Cpp17CopyConstructible* nor
 *Cpp17CopyAssignable*. The template parameter `T` of `unique_ptr` may be
 an incomplete type.
 ``` cpp
 namespace std {
   template<class T> struct default_delete {
     constexpr default_delete() noexcept = default;
+    template<class U> constexpr default_delete(const default_delete<U>&) noexcept;
+ constexpr void operator()(T*) const;
   };
 }
 ```
 ``` cpp
+template<class U> constexpr default_delete(const default_delete<U>& other) noexcept;
 ```
 *Constraints:* `U*` is implicitly convertible to `T*`.
 *Effects:* Constructs a `default_delete` object from another
 `default_delete<U>` object.
 ``` cpp
+constexpr void operator()(T* ptr) const;
 ```
 *Mandates:* `T` is a complete type.
 *Effects:* Calls `delete` on `ptr`.
 ``` cpp
 namespace std {
   template<class T> struct default_delete<T[]> {
     constexpr default_delete() noexcept = default;
+    template<class U> constexpr default_delete(const default_delete<U[]>&) noexcept;
+    template<class U> constexpr void operator()(U* ptr) const;
   };
 }
 ```
 ``` cpp
+template<class U> constexpr default_delete(const default_delete<U[]>& other) noexcept;
 ```
 *Constraints:* `U(*)[]` is convertible to `T(*)[]`.
 *Effects:* Constructs a `default_delete` object from another
 `default_delete<U[]>` object.
 ``` cpp
+template<class U> constexpr void operator()(U* ptr) const;
 ```
+*Constraints:* `U(*)[]` is convertible to `T(*)[]`.
 *Mandates:* `U` is a complete type.
 *Effects:* Calls `delete[]` on `ptr`.
 #### `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`.
 *Effects:* Invokes `swap` on the stored pointers and on the stored
 deleters of `*this` and `u`.
 #### `unique_ptr` for array objects with a runtime length <a id="unique.ptr.runtime">[[unique.ptr.runtime]]</a>
+##### General <a id="unique.ptr.runtime.general">[[unique.ptr.runtime.general]]</a>
 ``` cpp
 namespace std {
   template<class T, class D> class unique_ptr<T[], D> {
   public:
     using pointer      = see below;
     using element_type = T;
     using deleter_type = D;
     // [unique.ptr.runtime.ctor], constructors
     constexpr unique_ptr() noexcept;
+    template<class U> constexpr explicit unique_ptr(U p) noexcept;
+    template<class U> constexpr unique_ptr(U p, see below d) noexcept;
+    template<class U> constexpr unique_ptr(U p, see below d) noexcept;
+ constexpr unique_ptr(unique_ptr&& u) noexcept;
     template<class U, class E>
+ constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;
     constexpr unique_ptr(nullptr_t) noexcept;
     // destructor
+ constexpr ~unique_ptr();
     // 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.runtime.observers], observers
+ constexpr T& operator[](size_t i) const;
+ 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.runtime.modifiers], modifiers
+ constexpr pointer release() noexcept;
+    template<class U> constexpr void reset(U p) noexcept;
+ constexpr void reset(nullptr_t = nullptr) 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;
   };
 The template argument `T` shall be a complete type.
 ##### Constructors <a id="unique.ptr.runtime.ctor">[[unique.ptr.runtime.ctor]]</a>
 ``` cpp
+template<class U> constexpr explicit unique_ptr(U p) noexcept;
 ```
 This constructor behaves the same as the constructor in the primary
 template that takes a single parameter of type `pointer`.
 - `U` is the same type as `pointer`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 ``` cpp
+template<class U> constexpr unique_ptr(U p, see below d) noexcept;
+template<class U> constexpr unique_ptr(U p, see below d) noexcept;
 ```
 These constructors behave the same as the constructors in the primary
 template that take a parameter of type `pointer` and a second parameter.
 - `U` is `nullptr_t`, or
 - `pointer` is the same type as `element_type*`, `U` is a pointer type
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 ``` cpp
+template<class U, class E> constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;
 ```
 This constructor behaves the same as in the primary template.
 *Constraints:* Where `UP` is `unique_ptr<U, E>`:
 primary template. — *end note*]
 ##### Assignment <a id="unique.ptr.runtime.asgn">[[unique.ptr.runtime.asgn]]</a>
 ``` cpp
+template<class U, class E> constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 ```
 This operator behaves the same as in the primary template.
 *Constraints:* Where `UP` is `unique_ptr<U, E>`:
 primary template. — *end note*]
 ##### Observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
+constexpr T& operator[](size_t i) const;
 ```
 *Preconditions:* `i` < the number of elements in the array to which the
 stored pointer points.
 *Returns:* `get()[i]`.
 ##### Modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
+constexpr void reset(nullptr_t p = nullptr) noexcept;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
 ``` cpp
+constexpr template<class U> void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
 template.
   `V*`, and `V(*)[]` is convertible to `element_type(*)[]`.
 #### Creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
+template<class T, class... Args> constexpr unique_ptr<T> make_unique(Args&&... args);
 ```
 *Constraints:* `T` is not an array type.
 *Returns:* `unique_ptr<T>(new T(std::forward<Args>(args)...))`.
 ``` cpp
+template<class T> constexpr unique_ptr<T> make_unique(size_t n);
 ```
 *Constraints:* `T` is an array of unknown bound.
 *Returns:* `unique_ptr<T>(new remove_extent_t<T>[n]())`.
 ```
 *Constraints:* `T` is an array of known bound.
 ``` cpp
+template<class T> constexpr unique_ptr<T> make_unique_for_overwrite();
 ```
 *Constraints:* `T` is not an array type.
 *Returns:* `unique_ptr<T>(new T)`.
 ``` cpp
+template<class T> constexpr unique_ptr<T> make_unique_for_overwrite(size_t n);
 ```
 *Constraints:* `T` is an array of unknown bound.
 *Returns:* `unique_ptr<T>(new remove_extent_t<T>[n])`.
 *Constraints:* `T` is an array of known bound.
 #### Specialized algorithms <a id="unique.ptr.special">[[unique.ptr.special]]</a>
 ``` cpp
+template<class T, class D> constexpr void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 ```
 *Constraints:* `is_swappable_v<D>` is `true`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
+ constexpr bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `x.get() == y.get()`.
 ``` cpp
 *Returns:* `compare_three_way()(x.get(), y.get())`.
 ``` cpp
 template<class T, class D>
+ constexpr bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
 ```
 *Returns:* `!x`.
 ``` cpp
 template<class T, class D>
+ constexpr bool operator<(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
+ constexpr bool operator<(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Preconditions:* The specialization `less<unique_ptr<T, D>::pointer>` is
 a function object type [[function.objects]] that induces a strict weak
 ordering [[alg.sorting]] on the pointer values.
 less<unique_ptr<T, D>::pointer>()(nullptr, x.get())
 ```
 ``` cpp
 template<class T, class D>
+ constexpr bool operator>(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
+ constexpr bool operator>(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Returns:* The first function template returns `nullptr < x`. The second
 function template returns `x < nullptr`.
 ``` cpp
 template<class T, class D>
+ constexpr bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
+ constexpr bool operator<=(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Returns:* The first function template returns `!(nullptr < x)`. The
 second function template returns `!(x < nullptr)`.
 ``` cpp
 template<class T, class D>
+ constexpr bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
 template<class T, class D>
+ constexpr bool operator>=(nullptr_t, const unique_ptr<T, D>& x);
 ```
 *Returns:* The first function template returns `!(x < nullptr)`. The
 second function template returns `!(nullptr < x)`.
 ``` cpp
 template<class T, class D>
+  requires three_way_comparable<typename unique_ptr<T, D>::pointer>
+ constexpr compare_three_way_result_t<typename unique_ptr<T, D>::pointer>
     operator<=>(const unique_ptr<T, D>& x, nullptr_t);
 ```
+*Returns:*
+``` cpp
+compare_three_way()(x.get(), static_cast<typename unique_ptr<T, D>::pointer>(nullptr)).
+```
 #### I/O <a id="unique.ptr.io">[[unique.ptr.io]]</a>
 ``` cpp
 template<class E, class T, class Y, class D>

Diff to HTML by rtfpessoa