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

Files changed (1) hide show

tmp/tmpuzkue9ru/{from.md → to.md} +87 -96

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

@@ -2,26 +2,23 @@
 ``` 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
@@ -35,11 +32,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
@@ -49,149 +46,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
@@ -216,42 +212,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>
@@ -259,11 +243,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.
@@ -284,12 +268,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())`.
@@ -297,13 +283,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>
@@ -321,11 +307,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;
 ```
@@ -348,29 +335,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;
 ```

 ``` 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;
 ```

Diff to HTML by rtfpessoa