[unique.ptr] - C++14 → C++17

Files changed (1) hide show

tmp/tmpbes1c021/{from.md → to.md} +224 -139

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

@@ -25,24 +25,26 @@ postconditions hold:
 - if the pre-transfer *u.d* maintained state, such state has been
   transferred to *u2.d*.
 As in the case of a reset, *u2* must properly dispose of its
 pre-transfer owned object via the pre-transfer associated deleter before
-the ownership transfer is considered complete. A deleter’s state need
-never be copied, only moved or swapped as ownership is transferred.
 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 `MoveConstructible` and `MoveAssignable`,
 but is not `CopyConstructible` nor `CopyAssignable`. The template
 parameter `T` of `unique_ptr` may be an incomplete type.
-The uses of `unique_ptr` include providing exception safety for
-dynamically allocated memory, passing ownership of dynamically allocated
-memory to a function, and returning dynamically allocated memory from a
-function.
 ``` cpp
 namespace std {
   template<class T> struct default_delete;
   template<class T> struct default_delete<T[]>;
@@ -131,56 +133,65 @@ unless `U*` is implicitly convertible to `T*`.
 ``` cpp
 void operator()(T* ptr) const;
 ```
-*Effects:* calls `delete` on `ptr`.
 *Remarks:* If `T` is an incomplete type, the program is ill-formed.
 ##### `default_delete<T[]>` <a id="unique.ptr.dltr.dflt1">[[unique.ptr.dltr.dflt1]]</a>
 ``` cpp
 namespace std {
   template <class T> struct default_delete<T[]> {
     constexpr default_delete() noexcept = default;
- void operator()(T*) const;
-    template <class U> void operator()(U*) const = delete;
   };
 }
 ```
 ``` cpp
-void operator()(T* ptr) const;
 ```
-*Effects:* calls `delete[]` on `ptr`.
-*Remarks:* If T is an incomplete type, the program is ill-formed.
 #### `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:
- typedef see below pointer;
- typedef T element_type;
- typedef D deleter_type;
     // [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
-      : unique_ptr() { }
     template <class U, class E>
       unique_ptr(unique_ptr<U, E>&& u) noexcept;
-    template <class U>
-      unique_ptr(auto_ptr<U>&& u) noexcept;
     // [unique.ptr.single.dtor], destructor
     ~unique_ptr();
     // [unique.ptr.single.asgn], assignment
@@ -194,11 +205,11 @@ namespace std {
     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
@@ -208,149 +219,148 @@ 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  [[destructible]]).
-If the type `remove_reference_t<D>::pointer` exists, 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 `T*`. The
-type `unique_ptr<T,
 D>::pointer` shall satisfy the requirements of `NullablePointer` (
 [[nullablepointer.requirements]]).
-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`.
 ##### `unique_ptr` constructors <a id="unique.ptr.single.ctor">[[unique.ptr.single.ctor]]</a>
 ``` cpp
 constexpr unique_ptr() noexcept;
 ```
 *Requires:* `D` shall satisfy the requirements of `DefaultConstructible`
-(Table  [[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 this constructor is instantiated with a pointer type or
-reference type for the template argument `D`, the program is ill-formed.
 ``` cpp
 explicit unique_ptr(pointer p) noexcept;
 ```
 *Requires:* `D` shall satisfy the requirements of `DefaultConstructible`
-(Table  [[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 this constructor is instantiated with a pointer type or
-reference type for the template argument `D`, 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 non-reference type `A`, then the signatures
 are:
 ``` cpp
-unique_ptr(pointer p, const A& d);
-unique_ptr(pointer p, A&& d);
 ```
-If `D` is an lvalue-reference type `A&`, then the signatures are:
 ``` cpp
-unique_ptr(pointer p, A& d);
-unique_ptr(pointer p, A&& d);
 ```
-If `D` is an lvalue-reference type `const A&`, then the signatures are:
 ``` cpp
-unique_ptr(pointer p, const A& d);
-unique_ptr(pointer p, const A&& d);
 ```
-*Requires:*
-- If `D` is not an lvalue-reference type then
-  - If `d` is an lvalue or `const` rvalue then the first constructor of
-    this pair will be selected. `D` shall satisfy the requirements of
-    `CopyConstructible` (Table  [[copyconstructible]]), and the copy
-    constructor of `D` shall not throw an exception. This `unique_ptr`
-    will hold a copy of `d`.
-  - Otherwise, `d` is a non-const rvalue and the second constructor of
-    this pair will be selected. `D` shall satisfy the requirements of
-    `MoveConstructible` (Table  [[moveconstructible]]), and the move
-    constructor of `D` shall not throw an exception. This `unique_ptr`
-    will hold a value move constructed from `d`.
-- Otherwise `D` is an lvalue-reference type. `d` shall be
-  reference-compatible with one of the constructors. If `d` is an
-  rvalue, it will bind to the second constructor of this pair and the
-  program is ill-formed. The diagnostic could be implemented using a
-  `static_assert` which assures that `D` is not a reference type. Else
-  `d` is an lvalue and will bind to the first constructor of this pair.
-  The type which `D` references need not be `CopyConstructible` nor
-  `MoveConstructible`. This `unique_ptr` will hold a `D` which refers to
-  the lvalue `d`. `D` may not be an rvalue-reference type.
 *Effects:* Constructs a `unique_ptr` object which owns `p`, initializing
-the stored pointer with `p` and initializing the deleter as described
-above.
 *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`.
 ``` 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
 ```
 ``` cpp
 unique_ptr(unique_ptr&& u) noexcept;
 ```
 *Requires:* If `D` is not a reference type, `D` shall satisfy the
-requirements of `MoveConstructible` (Table  [[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. The deleter constructor can be implemented with
-`std::forward<D>`.
 *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
@@ -375,42 +385,30 @@ unless:
   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. The deleter constructor can be implemented with
-`std::forward<E>`.
 *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()`.
-``` cpp
-template <class U>
-  unique_ptr(auto_ptr<U>&& u) noexcept;
-```
-*Effects:* Constructs a `unique_ptr` object, initializing the stored
-pointer with `u.release()` and value-initializing the stored deleter.
-*Postconditions:* `get()` yields the value `u.get()` yielded before the
-construction. `u.get() == nullptr`. `get_deleter()` returns a reference
-to the stored deleter.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `U*` is implicitly convertible to `T*` and `D` is the same type
-as `default_delete<T>`.
 ##### `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. The
-use of `default_delete` requires `T` to be a complete type.
 *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>
@@ -418,11 +416,11 @@ use of `default_delete` requires `T` to be a complete type.
 ``` cpp
 unique_ptr& operator=(unique_ptr&& u) noexcept;
 ```
 *Requires:* If `D` is not a reference type, `D` shall satisfy the
-requirements of `MoveAssignable` (Table  [[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.
@@ -443,12 +441,14 @@ 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.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
 `reset(u.release())` followed by
 `get_deleter() = std::forward<E>(u.get_deleter())`.
@@ -456,13 +456,13 @@ unless:
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 ```
-*Effects:* `reset()`.
-`get() == nullptr`
 *Returns:* `*this`.
 ##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
@@ -480,11 +480,12 @@ pointer operator->() const noexcept;
 *Requires:* `get() != nullptr`.
 *Returns:* `get()`.
-*Note:* use typically requires that `T` be a complete type.
 ``` cpp
 pointer get() const noexcept;
 ```
@@ -507,29 +508,33 @@ explicit operator bool() const noexcept;
 ``` cpp
 pointer release() noexcept;
 ```
-`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 the old value
-of the stored pointer, `old_p`, was not equal to `nullptr`, calls
-`get_deleter()(old_p)`. The order of these operations is significant
-because the call to `get_deleter()` may destroy `*this`.
-*Postconditions:* `get() == p`. The postcondition does not hold if the
-call to `get_deleter()` destroys `*this` since `this->get()` is no
-longer a valid expression.
 ``` cpp
 void swap(unique_ptr& u) noexcept;
 ```
@@ -544,41 +549,44 @@ deleters of `*this` and `u`.
 ``` cpp
 namespace std {
   template <class T, class D> class unique_ptr<T[], D> {
   public:
- typedef see below pointer;
- typedef T element_type;
- typedef D deleter_type;
     // [unique.ptr.runtime.ctor], constructors
     constexpr unique_ptr() noexcept;
-    explicit unique_ptr(pointer p) noexcept;
-    unique_ptr(pointer p, see below d) noexcept;
-    unique_ptr(pointer p, see below d) noexcept;
     unique_ptr(unique_ptr&& u) noexcept;
- constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
     // destructor
     ~unique_ptr();
     // assignment
     unique_ptr& operator=(unique_ptr&& 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;
-    void reset(pointer p = pointer()) noexcept;
-    void reset(nullptr_t) noexcept;
-    template <class U> void reset(U) = delete;
     void swap(unique_ptr& u) noexcept;
     // disable copy from lvalue
     unique_ptr(const unique_ptr&) = delete;
     unique_ptr& operator=(const unique_ptr&) = delete;
@@ -587,36 +595,92 @@ namespace std {
 ```
 A specialization for array types is provided with a slightly altered
 interface.
-- Conversions between different types of `unique_ptr<T[], D>` or to or
- from the non-array forms of `unique_ptr` produce an ill-formed
- program.
 - Pointers to types derived from `T` are rejected by the constructors,
   and by `reset`.
 - The observers `operator*` and `operator->` are not provided.
 - The indexing observer `operator[]` is provided.
 - The default deleter will call `delete[]`.
-Descriptions are provided below only for member functions that have
-behavior different from the primary template.
 The template argument `T` shall be a complete type.
 ##### `unique_ptr` constructors <a id="unique.ptr.runtime.ctor">[[unique.ptr.runtime.ctor]]</a>
 ``` cpp
-explicit unique_ptr(pointer p) noexcept;
-unique_ptr(pointer p, see below d) noexcept;
-unique_ptr(pointer p, see below d) noexcept;
 ```
-These constructors behave the same as in the primary template except
-that they do not accept pointer types which are convertible to
-`pointer`. One implementation technique is to create private templated
-overloads of these members.
 ##### `unique_ptr` observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
 T& operator[](size_t i) const;
@@ -628,15 +692,27 @@ stored pointer points.
 *Returns:* `get()[i]`.
 ##### `unique_ptr` modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
-void reset(nullptr_t p) noexcept;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
 #### `unique_ptr` creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
 template <class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
 ```
@@ -666,10 +742,13 @@ unless `T` is an array of known bound.
 ``` cpp
 template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 ```
 *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);
@@ -687,20 +766,26 @@ template <class T1, class D1, class T2, class D2>
 ``` cpp
 template <class T1, class D1, class T2, class D2>
   bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
-*Requires:* Let `CT` be `common_type<unique_ptr<T1, D1>::pointer,`
-`unique_ptr<T2, D2>::pointer>::type`. Then the specialization `less<CT>`
-shall be a function object type ([[function.objects]]) that induces a
-strict weak ordering ([[alg.sorting]]) on the pointer values.
-*Returns:* `less<CT>()(x.get(), y.get()).`
 *Remarks:* If `unique_ptr<T1, D1>::pointer` is not implicitly
-convertible to `CT` or `unique_ptr<T2, D2>::pointer` is not implicitly
-convertible to `CT`, the program is ill-formed.
 ``` cpp
 template <class T1, class D1, class T2, class D2>
   bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```

 - if the pre-transfer *u.d* maintained state, such state has been
   transferred to *u2.d*.
 As in the case of a reset, *u2* must properly dispose of its
 pre-transfer owned object via the pre-transfer associated deleter before
+the ownership transfer is considered complete.
+[*Note 1*: A deleter’s state need never be copied, only moved or
+swapped as ownership is transferred. — *end note*]
 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 `MoveConstructible` and `MoveAssignable`,
 but is not `CopyConstructible` nor `CopyAssignable`. The template
 parameter `T` of `unique_ptr` may be an incomplete type.
+[*Note 2*: The uses of `unique_ptr` include providing exception safety
+for dynamically allocated memory, passing ownership of dynamically
+allocated memory to a function, and returning dynamically allocated
+memory from a function. — *end note*]
 ``` cpp
 namespace std {
   template<class T> struct default_delete;
   template<class T> struct default_delete<T[]>;
 ``` cpp
 void operator()(T* ptr) const;
 ```
+*Effects:* Calls `delete` on `ptr`.
 *Remarks:* If `T` is an incomplete type, the program is ill-formed.
 ##### `default_delete<T[]>` <a id="unique.ptr.dltr.dflt1">[[unique.ptr.dltr.dflt1]]</a>
 ``` 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;
 ```
+*Effects:* constructs a `default_delete` object from another
+`default_delete<U[]>` object.
+*Remarks:* This constructor shall not participate in overload resolution
+unless `U(*)[]` is convertible to `T(*)[]`.
+``` cpp
+template <class U> void operator()(U* ptr) const;
+```
+*Effects:* Calls `delete[]` on `ptr`.
+*Remarks:* If `U` is an incomplete type, the program is ill-formed. This
+function shall not participate in overload resolution unless `U(*)[]` is
+convertible to `T(*)[]`.
 #### `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
     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
 }
 ```
 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
 ```
+— *end example*]
 ``` 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
   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.
 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())`.
 ``` 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>
 *Requires:* `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;
 ```
 ``` 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;
 ```
 ``` 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;
 ```
 A specialization for array types is provided with a slightly altered
 interface.
+- Conversions between different types of `unique_ptr<T[], D>` that would
+ be disallowed for the corresponding pointer-to-array types, and
+ conversions to or from the non-array forms of `unique_ptr`, produce an
+  ill-formed program.
 - Pointers to types derived from `T` are rejected by the constructors,
   and by `reset`.
 - The observers `operator*` and `operator->` are not provided.
 - The indexing observer `operator[]` is provided.
 - The default deleter will call `delete[]`.
+Descriptions are provided below only for members that differ from the
+primary template.
 The template argument `T` shall be a complete type.
 ##### `unique_ptr` 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` except that it
+additionally shall not participate in overload resolution unless
+- `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
+except that they shall not participate in overload resolution unless
+either
+- `U` is the same type as `pointer`,
+- `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, except
+that it shall not participate in overload resolution unless all of the
+following conditions hold, where `UP` is `unique_ptr<U, E>`:
+- `U` is an array type, and
+- `pointer` is the same type as `element_type*`, and
+- `UP::pointer` is the same type as `UP::element_type*`, and
+- `UP::element_type(*)[]` is convertible to `element_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`.
+[*Note 1*: This replaces the overload-resolution specification of the
+primary template — *end note*]
+##### `unique_ptr` 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, except that
+it shall not participate in overload resolution unless all of the
+following conditions hold, where `UP` is `unique_ptr<U, E>`:
+- `U` is an array type, and
+- `pointer` is the same type as `element_type*`, and
+- `UP::pointer` is the same type as `UP::element_type*`, and
+- `UP::element_type(*)[]` is convertible to `element_type(*)[]`, and
+- `is_assignable_v<D&, E&&>` is `true`.
+[*Note 2*: This replaces the overload-resolution specification of the
+primary template — *end note*]
 ##### `unique_ptr` observers <a id="unique.ptr.runtime.observers">[[unique.ptr.runtime.observers]]</a>
 ``` cpp
 T& operator[](size_t i) const;
 *Returns:* `get()[i]`.
 ##### `unique_ptr` 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, except that it shall not participate in overload resolution
+unless either
+- `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(*)[]`.
 #### `unique_ptr` creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
 ``` cpp
 template <class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
 ```
 ``` cpp
 template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 ```
+*Remarks:* This function shall not participate in overload resolution
+unless `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);
 ``` cpp
 template <class T1, class D1, class T2, class D2>
   bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
+*Requires:* Let *`CT`* denote
+``` cpp
+common_type_t<typename unique_ptr<T1, D1>::pointer,
+              typename unique_ptr<T2, D2>::pointer>
+```
+Then the specialization `less<`*`CT`*`>` shall be a function object
+type ([[function.objects]]) that induces a strict weak
+ordering ([[alg.sorting]]) on the pointer values.
+*Returns:* `less<`*`CT`*`>()(x.get(), y.get())`.
 *Remarks:* If `unique_ptr<T1, D1>::pointer` is not implicitly
+convertible to *`CT`* or `unique_ptr<T2, D2>::pointer` is not implicitly
+convertible to *`CT`*, the program is ill-formed.
 ``` cpp
 template <class T1, class D1, class T2, class D2>
   bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```

Diff to HTML by rtfpessoa