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

Files changed (1) hide show

tmp/tmpwwhtsxbz/{from.md → to.md} +44 -20

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

@@ -48,10 +48,14 @@ namespace std {
   template<class T> struct default_delete<T[]>;
   template<class T, class D = default_delete<T>> class unique_ptr;
   template<class T, class D> class unique_ptr<T[], D>;
   template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
   template<class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
@@ -183,11 +187,11 @@ namespace std {
     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
- typename add_lvalue_reference<T>::type 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;
@@ -213,16 +217,14 @@ 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<D>::type::pointer` exists, then
-`unique_ptr<T,
-D>::pointer` shall be a synonym for
-`remove_reference<D>::type::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`,
@@ -418,18 +420,17 @@ 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<D>::type` shall satisfy the `CopyAssignable`
-requirements and assignment of the deleter from an lvalue of type `D`
-shall not throw an exception.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
-`reset(u.release())` followed by an assignment from
-`std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
@@ -446,12 +447,12 @@ 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 an assignment from
-`std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
@@ -464,11 +465,11 @@ unique_ptr& operator=(nullptr_t) noexcept;
 *Returns:* `*this`.
 ##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
-typename add_lvalue_reference<T>::type operator*() const;
 ```
 *Requires:* `get() != nullptr`.
 *Returns:* `*get()`.
@@ -627,18 +628,41 @@ stored pointer points.
 *Returns:* `get()[i]`.
 ##### `unique_ptr` modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
-void reset(pointer p = pointer()) noexcept;
 void reset(nullptr_t p) noexcept;
 ```
-*Effects:* If `get() == nullptr` there are no effects. Otherwise
-`get_deleter()(get())`.
-`get() == p`.
 #### `unique_ptr` 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;

   template<class T> struct default_delete<T[]>;
   template<class T, class D = default_delete<T>> class unique_ptr;
   template<class T, class D> class unique_ptr<T[], D>;
+  template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
+  template<class T> unique_ptr<T> make_unique(size_t n);
+  template<class T, class... Args> unspecified make_unique(Args&&...) = delete;
   template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
   template<class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
     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;
 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`,
 ```
 *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.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
+`reset(u.release())` followed by
+`get_deleter() = std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 - `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())`.
 *Returns:* `*this`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 *Returns:* `*this`.
 ##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
+add_lvalue_reference_t<T> operator*() const;
 ```
 *Requires:* `get() != nullptr`.
 *Returns:* `*get()`.
 *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);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `T` is not an array.
+*Returns:* `unique_ptr<T>(new T(std::forward<Args>(args)...))`.
+``` cpp
+template <class T> unique_ptr<T> make_unique(size_t n);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `T` is an array of unknown bound.
+*Returns:* `unique_ptr<T>(new remove_extent_t<T>[n]())`.
+``` cpp
+template <class T, class... Args> unspecified make_unique(Args&&...) = delete;
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `T` is an array of known bound.
 #### `unique_ptr` 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;

Diff to HTML by rtfpessoa