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

Files changed (1) hide show

tmp/tmph0acd5_a/{from.md → to.md} +18 -8

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

@@ -31,11 +31,11 @@ for dynamically allocated memory, passing ownership of dynamically
 allocated memory to a function, and returning dynamically allocated
 memory from a function. — *end note*]
 #### Default deleters <a id="unique.ptr.dltr">[[unique.ptr.dltr]]</a>
-##### In general <a id="unique.ptr.dltr.general">[[unique.ptr.dltr.general]]</a>
 The class template `default_delete` serves as the default deleter
 (destruction policy) for the class template `unique_ptr`.
 The template parameter `T` of `default_delete` may be an incomplete
@@ -150,10 +150,16 @@ namespace std {
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
 }
 ```
 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)`
@@ -378,11 +384,15 @@ constexpr unique_ptr& operator=(nullptr_t) noexcept;
 ``` cpp
 constexpr add_lvalue_reference_t<T> operator*() const noexcept(noexcept(*declval<pointer>()));
 ```
-*Preconditions:* `get() != nullptr`.
 *Returns:* `*get()`.
 ``` cpp
 constexpr pointer operator->() const noexcept;
@@ -608,11 +618,11 @@ 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.
@@ -685,11 +695,11 @@ template<class T1, class D1, class T2, class D2>
 *Returns:* `x.get() == y.get()`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
-  bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 Let `CT` denote
 ``` cpp
@@ -708,34 +718,34 @@ ordering [[alg.sorting]] on the pointer values.
 *Returns:* `less<CT>()(x.get(), y.get())`.
 ``` 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:* `y < x`.
 ``` 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:* `!(y < x)`.
 ``` 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 < y)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   requires three_way_comparable_with<typename unique_ptr<T1, D1>::pointer,
                                      typename unique_ptr<T2, D2>::pointer>
-  compare_three_way_result_t<typename unique_ptr<T1, D1>::pointer,
                                        typename unique_ptr<T2, D2>::pointer>
     operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `compare_three_way()(x.get(), y.get())`.

 allocated memory to a function, and returning dynamically allocated
 memory from a function. — *end note*]
 #### Default deleters <a id="unique.ptr.dltr">[[unique.ptr.dltr]]</a>
+##### General <a id="unique.ptr.dltr.general">[[unique.ptr.dltr.general]]</a>
 The class template `default_delete` serves as the default deleter
 (destruction policy) for the class template `unique_ptr`.
 The template parameter `T` of `default_delete` may be an incomplete
     unique_ptr& operator=(const unique_ptr&) = delete;
   };
 }
 ```
+A program that instantiates the definition of `unique_ptr<T, D>` is
+ill-formed if `T*` is an invalid type.
+[*Note 1*: This prevents the instantiation of specializations such as
+`unique_ptr<T&, D>` and `unique_ptr<int() const, D>`. — *end note*]
 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)`
 ``` cpp
 constexpr add_lvalue_reference_t<T> operator*() const noexcept(noexcept(*declval<pointer>()));
 ```
+*Mandates:*
+`reference_converts_from_temporary_v<add_lvalue_reference_t<T>, decltype(*declval<pointer>())>`
+is `false`.
+*Preconditions:* `get() != nullptr` is `true`.
 *Returns:* `*get()`.
 ``` cpp
 constexpr pointer operator->() const noexcept;
 ```
 *Effects:* Equivalent to `reset(pointer())`.
 ``` cpp
+template<class U> constexpr void reset(U p) noexcept;
 ```
 This function behaves the same as the `reset` member of the primary
 template.
 *Returns:* `x.get() == y.get()`.
 ``` 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);
 ```
 Let `CT` denote
 ``` cpp
 *Returns:* `less<CT>()(x.get(), y.get())`.
 ``` 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:* `y < x`.
 ``` 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:* `!(y < x)`.
 ``` 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 < y)`.
 ``` cpp
 template<class T1, class D1, class T2, class D2>
   requires three_way_comparable_with<typename unique_ptr<T1, D1>::pointer,
                                      typename unique_ptr<T2, D2>::pointer>
+ constexpr compare_three_way_result_t<typename unique_ptr<T1, D1>::pointer,
                                        typename unique_ptr<T2, D2>::pointer>
     operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 ```
 *Returns:* `compare_three_way()(x.get(), y.get())`.

Diff to HTML by rtfpessoa