[list] - C++14 → C++17

Files changed (1) hide show

tmp/tmppignvwo4/{from.md → to.md} +62 -52

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

@@ -24,24 +24,24 @@ information.
 namespace std {
   template <class T, class Allocator = allocator<T>>
   class list {
   public:
     // types:
- typedef value_type&                                             reference;
- typedef const value_type&                                       const_reference;
- typedef implementation-defined iterator;       // see [container.requirements]
- typedef implementation-defined                const_iterator; // see [container.requirements]
- typedef implementation-defined                size_type;      // see [container.requirements]
- typedef implementation-defined                difference_type;// see [container.requirements]
- typedef T                                     value_type;
- typedef Allocator                             allocator_type;
- typedef typename allocator_traits<Allocator>::pointer           pointer;
- typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
- typedef std::reverse_iterator<iterator>       reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-    // [list.cons], construct/copy/destroy:
     list() : list(Allocator()) { }
     explicit list(const Allocator&);
     explicit list(size_type n, const Allocator& = Allocator());
     list(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
@@ -51,11 +51,12 @@ namespace std {
     list(const list&, const Allocator&);
     list(list&&, const Allocator&);
     list(initializer_list<T>, const Allocator& = Allocator());
     ~list();
     list& operator=(const list& x);
-    list& operator=(list&& x);
     list& operator=(initializer_list<T>);
     template <class InputIterator>
       void assign(InputIterator first, InputIterator last);
     void assign(size_type n, const T& t);
     void assign(initializer_list<T>);
@@ -74,11 +75,11 @@ namespace std {
     const_iterator         cbegin() const noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
-    // [list.capacity], capacity:
     bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
@@ -87,16 +88,16 @@ namespace std {
     reference       front();
     const_reference front() const;
     reference       back();
     const_reference back() const;
-    // [list.modifiers], modifiers:
-    template <class... Args> void emplace_front(Args&&... args);
- void pop_front();
-    template <class... Args> void emplace_back(Args&&... args);
     void push_front(const T& x);
     void push_front(T&& x);
     void push_back(const T& x);
     void push_back(T&& x);
     void pop_back();
     template <class... Args> iterator emplace(const_iterator position, Args&&... args);
@@ -108,14 +109,15 @@ namespace std {
                       InputIterator last);
     iterator insert(const_iterator position, initializer_list<T> il);
     iterator erase(const_iterator position);
     iterator erase(const_iterator position, const_iterator last);
-    void     swap(list&);
     void     clear() noexcept;
-    // [list.ops], list operations:
     void splice(const_iterator position, list& x);
     void splice(const_iterator position, list&& x);
     void splice(const_iterator position, list& x, const_iterator i);
     void splice(const_iterator position, list&& x, const_iterator i);
     void splice(const_iterator position, list& x,
@@ -139,10 +141,15 @@ namespace std {
     template <class Compare> void sort(Compare comp);
     void reverse() noexcept;
   };
   template <class T, class Allocator>
     bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
@@ -152,16 +159,22 @@ namespace std {
   template <class T, class Allocator>
     bool operator>=(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const list<T, Allocator>& x, const list<T, Allocator>& y);
-  // specialized algorithms:
   template <class T, class Allocator>
-    void swap(list<T,Allocator>& x, list<T,Allocator>& y);
 }
 ```
 #### `list` constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
 explicit list(const Allocator&);
 ```
@@ -180,12 +193,11 @@ the specified allocator.
 *Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
-list(size_type n, const T& value,
-     const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` with `n` copies of `value`, using the
 specified allocator.
@@ -193,12 +205,11 @@ specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template <class InputIterator>
-list(InputIterator first, InputIterator last,
-     const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
@@ -208,11 +219,11 @@ list(InputIterator first, InputIterator last,
 ``` cpp
 void resize(size_type sz);
 ```
 *Effects:* If `size() < sz`, appends `sz - size()` default-inserted
-elements to the sequence. If `sz <= size()`, equivalent to
 ``` cpp
 list<T>::iterator it = begin();
 advance(it, sz);
 erase(it, end());
@@ -222,11 +233,11 @@ erase(it, end());
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
-*Effects:*
 ``` cpp
 if (sz > size())
   insert(end(), sz-size(), c);
 else if (sz < size()) {
@@ -249,12 +260,12 @@ iterator insert(const_iterator position, size_type n, const T& x);
 template <class InputIterator>
   iterator insert(const_iterator position, InputIterator first,
                   InputIterator last);
 iterator insert(const_iterator position, initializer_list<T>);
-template <class... Args> void emplace_front(Args&&... args);
-template <class... Args> void emplace_back(Args&&... args);
 template <class... Args> iterator emplace(const_iterator position, Args&&... args);
 void push_front(const T& x);
 void push_front(T&& x);
 void push_back(const T& x);
 void push_back(T&& x);
@@ -318,19 +329,19 @@ now behave as iterators into `*this`, not into `x`.
 ``` cpp
 void splice(const_iterator position, list& x, const_iterator i);
 void splice(const_iterator position, list&& x, const_iterator i);
 ```
 *Effects:* Inserts an element pointed to by `i` from list `x` before
 `position` and removes the element from `x`. The result is unchanged if
 `position == i` or `position == ++i`. Pointers and references to `*i`
 continue to refer to this same element but as a member of `*this`.
 Iterators to `*i` (including `i` itself) continue to refer to the same
 element, but now behave as iterators into `*this`, not into `x`.
-*Requires:* `i` is a valid dereferenceable iterator of `x`.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
@@ -338,19 +349,20 @@ void splice(const_iterator position, list& x, const_iterator first,
             const_iterator last);
 void splice(const_iterator position, list&& x, const_iterator first,
             const_iterator last);
 ```
 *Effects:* Inserts elements in the range \[`first`, `last`) before
-`position` and removes the elements from `x`.
-*Requires:* `[first, last)` is a valid range in `x`. The result is
-undefined if `position` is an iterator in the range \[`first`, `last`).
-Pointers and references to the moved elements of `x` now refer to those
-same elements but as members of `*this`. Iterators referring to the
-moved elements will continue to refer to their elements, but they now
-behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* Constant time if `&x == this`; otherwise, linear time.
@@ -405,20 +417,20 @@ shall be sorted according to this ordering.
 *Effects:* If `(&x == this)` does nothing; otherwise, merges the two
 sorted ranges `[begin(), end())` and `[x.begin(), x.end())`. The result
 is a range in which the elements will be sorted in non-decreasing order
 according to the ordering defined by `comp`; that is, for every iterator
 `i`, in the range other than the first, the condition
-`comp(*i, *(i - 1))` will be false. Pointers and references to the moved
-elements of `x` now refer to those same elements but as members of
 `*this`. Iterators referring to the moved elements will continue to
 refer to their elements, but they now behave as iterators into `*this`,
 not into `x`.
 *Remarks:* Stable ([[algorithm.stable]]). If `(&x != this)` the range
 `[x.begin(), x.end())` is empty after the merge. No elements are copied
 by this operation. The behavior is undefined if
-`this->get_allocator() != x.get_allocator()`.
 *Complexity:* At most `size() + x.size() - 1` applications of `comp` if
 `(&x != this)`; otherwise, no applications of `comp` are performed. If
 an exception is thrown other than by a comparison there are no effects.
@@ -438,25 +450,23 @@ template <class Compare> void sort(Compare comp);
 *Requires:* `operator<` (for the first version) or `comp` (for the
 second version) shall define a strict weak ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
-function object. Does not affect the validity of iterators and
 references.
 *Remarks:* Stable ([[algorithm.stable]]).
-*Complexity:* Approximately N log(N) comparisons, where `N == size()`.
 #### `list` specialized algorithms <a id="list.special">[[list.special]]</a>
 ``` cpp
 template <class T, class Allocator>
-  void swap(list<T,Allocator>& x, list<T,Allocator>& y);
 ```
-*Effects:*
-``` cpp
-x.swap(y);
-```

 namespace std {
   template <class T, class Allocator = allocator<T>>
   class list {
   public:
     // types:
+ using value_type             = T;
+ using allocator_type         = Allocator;
+ using pointer = typename allocator_traits<Allocator>::pointer;
+ using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
+ using reference              = value_type&;
+ using const_reference        = const value_type&;
+ using size_type              = implementation-defined; // see [container.requirements]
+ using difference_type        = implementation-defined; // see [container.requirements]
+ using iterator               = implementation-defined  // type of list::iterator; // see [container.requirements]
+ using const_iterator         = implementation-defined  // type of list::const_iterator; // see [container.requirements]
+ using reverse_iterator       = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    // [list.cons], construct/copy/destroy
     list() : list(Allocator()) { }
     explicit list(const Allocator&);
     explicit list(size_type n, const Allocator& = Allocator());
     list(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
     list(const list&, const Allocator&);
     list(list&&, const Allocator&);
     list(initializer_list<T>, const Allocator& = Allocator());
     ~list();
     list& operator=(const list& x);
+    list& operator=(list&& x)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value);
     list& operator=(initializer_list<T>);
     template <class InputIterator>
       void assign(InputIterator first, InputIterator last);
     void assign(size_type n, const T& t);
     void assign(initializer_list<T>);
     const_iterator         cbegin() const noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
+    // [list.capacity], capacity
     bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
     reference       front();
     const_reference front() const;
     reference       back();
     const_reference back() const;
+    // [list.modifiers], modifiers
+    template <class... Args> reference emplace_front(Args&&... args);
+ template <class... Args> reference emplace_back(Args&&... args);
     void push_front(const T& x);
     void push_front(T&& x);
+    void pop_front();
     void push_back(const T& x);
     void push_back(T&& x);
     void pop_back();
     template <class... Args> iterator emplace(const_iterator position, Args&&... args);
                       InputIterator last);
     iterator insert(const_iterator position, initializer_list<T> il);
     iterator erase(const_iterator position);
     iterator erase(const_iterator position, const_iterator last);
+    void     swap(list&)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value);
     void     clear() noexcept;
+    // [list.ops], list operations
     void splice(const_iterator position, list& x);
     void splice(const_iterator position, list&& x);
     void splice(const_iterator position, list& x, const_iterator i);
     void splice(const_iterator position, list&& x, const_iterator i);
     void splice(const_iterator position, list& x,
     template <class Compare> void sort(Compare comp);
     void reverse() noexcept;
   };
+  template<class InputIterator,
+           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
+    list(InputIterator, InputIterator, Allocator = Allocator())
+      -> list<typename iterator_traits<InputIterator>::value_type, Allocator>;
   template <class T, class Allocator>
     bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
   template <class T, class Allocator>
     bool operator>=(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const list<T, Allocator>& x, const list<T, Allocator>& y);
+  // [list.special], specialized algorithms
   template <class T, class Allocator>
+    void swap(list<T, Allocator>& x, list<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
 }
 ```
+An incomplete type `T` may be used when instantiating `list` if the
+allocator satisfies the allocator completeness requirements (
+[[allocator.requirements.completeness]]). `T` shall be complete before
+any member of the resulting specialization of `list` is referenced.
 #### `list` constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
 explicit list(const Allocator&);
 ```
 *Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
+list(size_type n, const T& value, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template <class InputIterator>
+ list(InputIterator first, InputIterator last, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
 ``` cpp
 void resize(size_type sz);
 ```
 *Effects:* If `size() < sz`, appends `sz - size()` default-inserted
+elements to the sequence. If `sz <= size()`, equivalent to:
 ``` cpp
 list<T>::iterator it = begin();
 advance(it, sz);
 erase(it, end());
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
+*Effects:* As if by:
 ``` cpp
 if (sz > size())
   insert(end(), sz-size(), c);
 else if (sz < size()) {
 template <class InputIterator>
   iterator insert(const_iterator position, InputIterator first,
                   InputIterator last);
 iterator insert(const_iterator position, initializer_list<T>);
+template <class... Args> reference emplace_front(Args&&... args);
+template <class... Args> reference emplace_back(Args&&... args);
 template <class... Args> iterator emplace(const_iterator position, Args&&... args);
 void push_front(const T& x);
 void push_front(T&& x);
 void push_back(const T& x);
 void push_back(T&& x);
 ``` cpp
 void splice(const_iterator position, list& x, const_iterator i);
 void splice(const_iterator position, list&& x, const_iterator i);
 ```
+*Requires:* `i` is a valid dereferenceable iterator of `x`.
 *Effects:* Inserts an element pointed to by `i` from list `x` before
 `position` and removes the element from `x`. The result is unchanged if
 `position == i` or `position == ++i`. Pointers and references to `*i`
 continue to refer to this same element but as a member of `*this`.
 Iterators to `*i` (including `i` itself) continue to refer to the same
 element, but now behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
             const_iterator last);
 void splice(const_iterator position, list&& x, const_iterator first,
             const_iterator last);
 ```
+*Requires:* `[first, last)` is a valid range in `x`. The program has
+undefined behavior if `position` is an iterator in the range \[`first`,
+`last`).
 *Effects:* Inserts elements in the range \[`first`, `last`) before
+`position` and removes the elements from `x`. Pointers and references to
+the moved elements of `x` now refer to those same elements but as
+members of `*this`. Iterators referring to the moved elements will
+continue to refer to their elements, but they now behave as iterators
+into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* Constant time if `&x == this`; otherwise, linear time.
 *Effects:* If `(&x == this)` does nothing; otherwise, merges the two
 sorted ranges `[begin(), end())` and `[x.begin(), x.end())`. The result
 is a range in which the elements will be sorted in non-decreasing order
 according to the ordering defined by `comp`; that is, for every iterator
 `i`, in the range other than the first, the condition
+`comp(*i, *(i - 1))` will be `false`. Pointers and references to the
+moved elements of `x` now refer to those same elements but as members of
 `*this`. Iterators referring to the moved elements will continue to
 refer to their elements, but they now behave as iterators into `*this`,
 not into `x`.
 *Remarks:* Stable ([[algorithm.stable]]). If `(&x != this)` the range
 `[x.begin(), x.end())` is empty after the merge. No elements are copied
 by this operation. The behavior is undefined if
+`get_allocator() != x.get_allocator()`.
 *Complexity:* At most `size() + x.size() - 1` applications of `comp` if
 `(&x != this)`; otherwise, no applications of `comp` are performed. If
 an exception is thrown other than by a comparison there are no effects.
 *Requires:* `operator<` (for the first version) or `comp` (for the
 second version) shall define a strict weak ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
+function object. If an exception is thrown, the order of the elements in
+`*this` is unspecified. Does not affect the validity of iterators and
 references.
 *Remarks:* Stable ([[algorithm.stable]]).
+*Complexity:* Approximately N log N comparisons, where `N == size()`.
 #### `list` specialized algorithms <a id="list.special">[[list.special]]</a>
 ``` cpp
 template <class T, class Allocator>
+  void swap(list<T, Allocator>& x, list<T, Allocator>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.

Diff to HTML by rtfpessoa