[memory] - C++11 → C++14

Files changed (1) hide show

tmp/tmp0mp1540v/{from.md → to.md} +52 -40

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

@@ -2,20 +2,20 @@
 ### In general <a id="memory.general">[[memory.general]]</a>
 This subclause describes the contents of the header `<memory>` (
 [[memory.syn]]) and some of the contents of the C headers `<cstdlib>`
-and `cstring>` ([[c.malloc]]).
 ### Header `<memory>` synopsis <a id="memory.syn">[[memory.syn]]</a>
 The header `<memory>` defines several types and function templates that
 describe properties of pointers and pointer-like types, manage memory
 for containers and other template types, and construct multiple objects
 in uninitialized memory buffers ([[pointer.traits]]–
 [[specialized.algorithms]]). The header also defines the templates
-`unique_ptr`, `shared_ptr`, `weak_ptr`, and various template functions
 that operate on objects of these types ([[smartptr]]).
 ``` cpp
 namespace std {
   // [pointer.traits], pointer traits
@@ -34,11 +34,11 @@ namespace std {
   void* align(std::size_t alignment, std::size_t size,
     void*& ptr, std::size_t& space);
   // [allocator.tag], allocator argument tag
   struct allocator_arg_t { };
-  constexpr allocator_arg_t allocator_arg = allocator_arg_t();
   // [allocator.uses], uses_allocator
   template <class T, class Alloc> struct uses_allocator;
   // [allocator.traits], allocator traits
@@ -79,10 +79,16 @@ namespace std {
   template <class T> struct default_delete;
   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 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>
     bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template <class T1, class D1, class T2, class D2>
@@ -123,10 +129,15 @@ namespace std {
   class bad_weak_ptr;
   // [util.smartptr.shared], class template shared_ptr:
   template<class T> class shared_ptr;
   // [util.smartptr.shared.cmp], shared_ptr comparisons:
   template<class T, class U>
     bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
   template<class T, class U>
     bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
@@ -300,18 +311,18 @@ arguments; otherwise, the instantiation of `rebind` is ill-formed.
 ``` cpp
 static pointer pointer_traits::pointer_to(see below r);
 static pointer pointer_traits<T*>::pointer_to(see below r) noexcept;
 ```
-if `element_type` is (possibly cv-qualified) `void`, the type of `r` is
 unspecified; otherwise, it is `element_type&`.
-*Returns:* The first member function returns a dereferenceable pointer
-to `r` obtained by calling `Ptr::pointer_to(r)`; an instantiation of
-this function is ill-formed if `Ptr` does not have a matching
-`pointer_to` static member function. The second member function returns
-`std::addressof(r)`.
 ### Pointer safety <a id="util.dynamic.safety">[[util.dynamic.safety]]</a>
 A complete object is *declared reachable* while the number of calls to
 `declare_reachable` with an argument referencing the object exceeds the
@@ -362,15 +373,15 @@ object must be live until the corresponding `undeclare_no_pointers()`
 call. In a garbage-collecting implementation, the fact that a region in
 an object is registered with `declare_no_pointers()` should not prevent
 the object from being collected.
 *Effects:* The `n` bytes starting at `p` no longer contain traceable
-pointer locations, independent of their type. Hence pointers located
-there may not be dereferenced if the object they point to was created by
-global `operator new` and not previously declared reachable. This may be
-used to inform a garbage collector or leak detector that this region of
-memory need not be traced.
 *Throws:* Nothing.
 Under some conditions implementations may need to allocate memory.
 However, the request can be ignored if memory allocation fails.
@@ -427,11 +438,11 @@ arguments for the same buffer.
 ### Allocator argument tag <a id="allocator.tag">[[allocator.tag]]</a>
 ``` cpp
 namespace std {
   struct allocator_arg_t { };
-  constexpr allocator_arg_t allocator_arg = allocator_arg_t();
 }
 ```
 The `allocator_arg_t` struct is an empty structure type used as a unique
 type to disambiguate constructor and function overloading. Specifically,
@@ -525,11 +536,11 @@ namespace std {
       static void construct(Alloc& a, T* p, Args&&... args);
     template <class T>
       static void destroy(Alloc& a, T* p);
-    static size_type max_size(const Alloc& a);
     static Alloc select_on_container_copy_construction(const Alloc& rhs);
   };
 }
 ```
@@ -574,11 +585,11 @@ typedef see below difference_type;
 ``` cpp
 typedef see below size_type;
 ```
 *Type:* `Alloc::size_type` if such a type exists; otherwise,
-`make_unsigned<difference_type>::type`.
 ``` cpp
 typedef see below propagate_on_container_copy_assignment;
 ```
@@ -647,11 +658,11 @@ template <class T>
 *Effects:* calls `a.destroy(p)` if that call is well-formed; otherwise,
 invokes `p->~T()`.
 ``` cpp
-static size_type max_size(Alloc& a);
 ```
 *Returns:* `a.max_size()` if that expression is well-formed; otherwise,
 `numeric_limits<size_type>::max()`.
@@ -686,10 +697,11 @@ namespace std {
     typedef const T*  const_pointer;
     typedef T&        reference;
     typedef const T&  const_reference;
     typedef T         value_type;
     template <class U> struct rebind { typedef allocator<U> other; };
     allocator() noexcept;
     allocator(const allocator&) noexcept;
     template <class U> allocator(const allocator<U>&) noexcept;
    ~allocator();
@@ -761,11 +773,12 @@ void deallocate(pointer p, size_type n);
 shall equal the value passed as the first argument to the invocation of
 allocate which returned `p`.
 *Effects:* Deallocates the storage referenced by `p` .
-*Remarks:* Uses `::operator delete(void*)` ([[new.delete]]), but it is
 unspecified when this function is called.
 ``` cpp
 size_type max_size() const noexcept;
 ```
@@ -804,11 +817,11 @@ template <class T1, class T2>
 *Returns:* `false`.
 ### Raw storage iterator <a id="storage.iterator">[[storage.iterator]]</a>
 `raw_storage_iterator` is provided to enable algorithms to store their
-results into uninitialized memory. The formal template parameter
 `OutputIterator` is required to have its `operator*` return an object
 for which `operator&` is defined and returns a pointer to `T`, and is
 also required to satisfy the requirements of an output iterator (
 [[output.iterators]]).
@@ -818,14 +831,14 @@ namespace std {
   class raw_storage_iterator
     : public iterator<output_iterator_tag,void,void,void,void> {
   public:
     explicit raw_storage_iterator(OutputIterator x);
-    raw_storage_iterator<OutputIterator,T>& operator*();
-    raw_storage_iterator<OutputIterator,T>& operator=(const T& element);
-    raw_storage_iterator<OutputIterator,T>& operator++();
-    raw_storage_iterator<OutputIterator,T>  operator++(int);
   };
 }
 ```
 ``` cpp
@@ -834,33 +847,33 @@ explicit raw_storage_iterator(OutputIterator x);
 *Effects:* Initializes the iterator to point to the same value to which
 `x` points.
 ``` cpp
-raw_storage_iterator<OutputIterator,T>& operator*();
 ```
 *Returns:* `*this`
 ``` cpp
-raw_storage_iterator<OutputIterator,T>& operator=(const T& element);
 ```
 *Effects:* Constructs a value from `element` at the location to which
 the iterator points.
 *Returns:* A reference to the iterator.
 ``` cpp
-raw_storage_iterator<OutputIterator,T>& operator++();
 ```
 *Effects:* Pre-increment: advances the iterator and returns a reference
 to the updated iterator.
 ``` cpp
-raw_storage_iterator<OutputIterator,T> operator++(int);
 ```
 *Effects:* Post-increment: advances the iterator and returns the old
 value of the iterator.
@@ -888,22 +901,21 @@ template <class T> void return_temporary_buffer(T* p);
 *Requires:* The buffer shall have been previously allocated by
 `get_temporary_buffer`.
 ### Specialized algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
-All the iterators that are used as formal template parameters in the
-following algorithms are required to have their `operator*` return an
-object for which `operator&` is defined and returns a pointer to `T`. In
-the algorithm `uninitialized_copy`, the formal template parameter
-`InputIterator` is required to satisfy the requirements of an input
-iterator ([[input.iterators]]). In all of the following algorithms, the
-formal template parameter `ForwardIterator` is required to satisfy the
-requirements of a forward iterator ([[forward.iterators]]), and is
-required to have the property that no exceptions are thrown from
-increment, assignment, comparison, or dereference of valid iterators. In
-the following algorithms, if an exception is thrown there are no
-effects.
 #### `addressof` <a id="specialized.addressof">[[specialized.addressof]]</a>
 ``` cpp
 template <class T> T* addressof(T& r) noexcept;

 ### In general <a id="memory.general">[[memory.general]]</a>
 This subclause describes the contents of the header `<memory>` (
 [[memory.syn]]) and some of the contents of the C headers `<cstdlib>`
+and `<cstring>` ([[c.malloc]]).
 ### Header `<memory>` synopsis <a id="memory.syn">[[memory.syn]]</a>
 The header `<memory>` defines several types and function templates that
 describe properties of pointers and pointer-like types, manage memory
 for containers and other template types, and construct multiple objects
 in uninitialized memory buffers ([[pointer.traits]]–
 [[specialized.algorithms]]). The header also defines the templates
+`unique_ptr`, `shared_ptr`, `weak_ptr`, and various function templates
 that operate on objects of these types ([[smartptr]]).
 ``` cpp
 namespace std {
   // [pointer.traits], pointer traits
   void* align(std::size_t alignment, std::size_t size,
     void*& ptr, std::size_t& space);
   // [allocator.tag], allocator argument tag
   struct allocator_arg_t { };
+  constexpr allocator_arg_t allocator_arg{};
   // [allocator.uses], uses_allocator
   template <class T, class Alloc> struct uses_allocator;
   // [allocator.traits], allocator traits
   template <class T> struct default_delete;
   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>
     bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template <class T1, class D1, class T2, class D2>
   class bad_weak_ptr;
   // [util.smartptr.shared], class template shared_ptr:
   template<class T> class shared_ptr;
+  // [util.smartptr.shared.create], shared_ptr creation
+  template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);
+  template<class T, class A, class... Args>
+    shared_ptr<T> allocate_shared(const A& a, Args&&... args);
   // [util.smartptr.shared.cmp], shared_ptr comparisons:
   template<class T, class U>
     bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
   template<class T, class U>
     bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
 ``` cpp
 static pointer pointer_traits::pointer_to(see below r);
 static pointer pointer_traits<T*>::pointer_to(see below r) noexcept;
 ```
+If `element_type` is (possibly cv-qualified) `void`, the type of `r` is
 unspecified; otherwise, it is `element_type&`.
+*Returns:* The first member function returns a pointer to `r` obtained
+by calling `Ptr::pointer_to(r)` through which indirection is valid; an
+instantiation of this function is ill-formed if `Ptr` does not have a
+matching `pointer_to` static member function. The second member function
+returns `std::addressof(r)`.
 ### Pointer safety <a id="util.dynamic.safety">[[util.dynamic.safety]]</a>
 A complete object is *declared reachable* while the number of calls to
 `declare_reachable` with an argument referencing the object exceeds the
 call. In a garbage-collecting implementation, the fact that a region in
 an object is registered with `declare_no_pointers()` should not prevent
 the object from being collected.
 *Effects:* The `n` bytes starting at `p` no longer contain traceable
+pointer locations, independent of their type. Hence indirection through
+a pointer located there is undefined if the object it points to was
+created by global `operator new` and not previously declared reachable.
+This may be used to inform a garbage collector or leak detector that
+this region of memory need not be traced.
 *Throws:* Nothing.
 Under some conditions implementations may need to allocate memory.
 However, the request can be ignored if memory allocation fails.
 ### Allocator argument tag <a id="allocator.tag">[[allocator.tag]]</a>
 ``` cpp
 namespace std {
   struct allocator_arg_t { };
+  constexpr allocator_arg_t allocator_arg{};
 }
 ```
 The `allocator_arg_t` struct is an empty structure type used as a unique
 type to disambiguate constructor and function overloading. Specifically,
       static void construct(Alloc& a, T* p, Args&&... args);
     template <class T>
       static void destroy(Alloc& a, T* p);
+    static size_type max_size(const Alloc& a) noexcept;
     static Alloc select_on_container_copy_construction(const Alloc& rhs);
   };
 }
 ```
 ``` cpp
 typedef see below size_type;
 ```
 *Type:* `Alloc::size_type` if such a type exists; otherwise,
+`make_unsigned_t<difference_type>`.
 ``` cpp
 typedef see below propagate_on_container_copy_assignment;
 ```
 *Effects:* calls `a.destroy(p)` if that call is well-formed; otherwise,
 invokes `p->~T()`.
 ``` cpp
+static size_type max_size(const Alloc& a) noexcept;
 ```
 *Returns:* `a.max_size()` if that expression is well-formed; otherwise,
 `numeric_limits<size_type>::max()`.
     typedef const T*  const_pointer;
     typedef T&        reference;
     typedef const T&  const_reference;
     typedef T         value_type;
     template <class U> struct rebind { typedef allocator<U> other; };
+    typedef true_type propagate_on_container_move_assignment;
     allocator() noexcept;
     allocator(const allocator&) noexcept;
     template <class U> allocator(const allocator<U>&) noexcept;
    ~allocator();
 shall equal the value passed as the first argument to the invocation of
 allocate which returned `p`.
 *Effects:* Deallocates the storage referenced by `p` .
+*Remarks:* Uses
+`::operator delete(void*, std::size_t)` ([[new.delete]]), but it is
 unspecified when this function is called.
 ``` cpp
 size_type max_size() const noexcept;
 ```
 *Returns:* `false`.
 ### Raw storage iterator <a id="storage.iterator">[[storage.iterator]]</a>
 `raw_storage_iterator` is provided to enable algorithms to store their
+results into uninitialized memory. The template parameter
 `OutputIterator` is required to have its `operator*` return an object
 for which `operator&` is defined and returns a pointer to `T`, and is
 also required to satisfy the requirements of an output iterator (
 [[output.iterators]]).
   class raw_storage_iterator
     : public iterator<output_iterator_tag,void,void,void,void> {
   public:
     explicit raw_storage_iterator(OutputIterator x);
+    raw_storage_iterator& operator*();
+    raw_storage_iterator& operator=(const T& element);
+    raw_storage_iterator& operator++();
+    raw_storage_iterator  operator++(int);
   };
 }
 ```
 ``` cpp
 *Effects:* Initializes the iterator to point to the same value to which
 `x` points.
 ``` cpp
+raw_storage_iterator& operator*();
 ```
 *Returns:* `*this`
 ``` cpp
+raw_storage_iterator& operator=(const T& element);
 ```
 *Effects:* Constructs a value from `element` at the location to which
 the iterator points.
 *Returns:* A reference to the iterator.
 ``` cpp
+raw_storage_iterator& operator++();
 ```
 *Effects:* Pre-increment: advances the iterator and returns a reference
 to the updated iterator.
 ``` cpp
+raw_storage_iterator operator++(int);
 ```
 *Effects:* Post-increment: advances the iterator and returns the old
 value of the iterator.
 *Requires:* The buffer shall have been previously allocated by
 `get_temporary_buffer`.
 ### Specialized algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
+All the iterators that are used as template parameters in the following
+algorithms are required to have their `operator*` return an object for
+which `operator&` is defined and returns a pointer to `T`. In the
+algorithm `uninitialized_copy`, the template parameter `InputIterator`
+is required to satisfy the requirements of an input iterator (
+[[input.iterators]]). In all of the following algorithms, the template
+parameter `ForwardIterator` is required to satisfy the requirements of a
+forward iterator ([[forward.iterators]]), and is required to have the
+property that no exceptions are thrown from increment, assignment,
+comparison, or indirection through valid iterators. In the following
+algorithms, if an exception is thrown there are no effects.
 #### `addressof` <a id="specialized.addressof">[[specialized.addressof]]</a>
 ``` cpp
 template <class T> T* addressof(T& r) noexcept;

Diff to HTML by rtfpessoa