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

Files changed (1) hide show

tmp/tmprai9vegl/{from.md → to.md} +17 -28

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

@@ -38,12 +38,13 @@ namespace std {
     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:
- explicit list(const Allocator& = Allocator());
-    explicit list(size_type n);
     list(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
       list(InputIterator first, InputIterator last, const Allocator& = Allocator());
     list(const list& x);
     list(list&& x);
@@ -160,24 +161,25 @@ namespace std {
 ```
 #### `list` constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
-explicit list(const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty list, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit list(size_type n);
 ```
-*Effects:* Constructs a `list` with `n` value-initialized elements.
-*Requires:* `T` shall be `DefaultConstructible`.
 *Complexity:* Linear in `n`.
 ``` cpp
 list(size_type n, const T& value,
@@ -199,40 +201,26 @@ list(InputIterator first, InputIterator last,
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
-``` cpp
-template <class InputIterator>
-  void assign(InputIterator first, InputIterator last);
-```
-*Effects:* Replaces the contents of the list with the range
-`[first, last)`.
-``` cpp
-void assign(size_type n, const T& t);
-```
-*Effects:* Replaces the contents of the list with `n` copies of `t`.
 #### `list` capacity <a id="list.capacity">[[list.capacity]]</a>
 ``` cpp
 void resize(size_type sz);
 ```
-*Effects:* If `size() < sz`, appends `sz - size()` value-initialized
 elements to the sequence. If `sz <= size()`, equivalent to
 ``` cpp
 list<T>::iterator it = begin();
 advance(it, sz);
 erase(it, end());
 ```
-*Requires:* `T` shall be `DefaultConstructible`.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
@@ -377,11 +365,11 @@ iterator `i` for which the following conditions hold:
 references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by `*i == value` or
 `pred(*i) != false`.
-*Remarks:* Stable.
 *Complexity:* Exactly `size()` applications of the corresponding
 predicate.
 ``` cpp
@@ -394,11 +382,11 @@ of equal elements referred to by the iterator `i` in the range
 \[`first + 1`, `last`) for which `*i == *(i-1)` (for the version of
 `unique` with no arguments) or `pred(*i, *(i - 1))` (for the version of
 `unique` with a predicate argument) holds. Invalidates only the
 iterators and references to the erased elements.
-*Throws:* Nothing unless an exception in thrown by `*i == *(i-1)` or
 `pred(*i, *(i - 1))`
 *Complexity:* If the range `[first, last)` is not empty, exactly
 `(last - first) - 1` applications of the corresponding predicate,
 otherwise no applications of the predicate.
@@ -423,13 +411,14 @@ according to the ordering defined by `comp`; that is, for every iterator
 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. 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.
@@ -452,11 +441,11 @@ 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.
 *Complexity:* Approximately N log(N) comparisons, where `N == size()`.
 #### `list` specialized algorithms <a id="list.special">[[list.special]]</a>

     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>
       list(InputIterator first, InputIterator last, const Allocator& = Allocator());
     list(const list& x);
     list(list&& x);
 ```
 #### `list` constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
+explicit list(const Allocator&);
 ```
 *Effects:* Constructs an empty list, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
+explicit list(size_type n, const Allocator& = Allocator());
 ```
+*Effects:* Constructs a `list` with `n` default-inserted elements using
+the specified allocator.
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 list(size_type n, const T& value,
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
 #### `list` capacity <a id="list.capacity">[[list.capacity]]</a>
 ``` 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());
 ```
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
 references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by `*i == value` or
 `pred(*i) != false`.
+*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Exactly `size()` applications of the corresponding
 predicate.
 ``` cpp
 \[`first + 1`, `last`) for which `*i == *(i-1)` (for the version of
 `unique` with no arguments) or `pred(*i, *(i - 1))` (for the version of
 `unique` with a predicate argument) holds. Invalidates only the
 iterators and references to the erased elements.
+*Throws:* Nothing unless an exception is thrown by `*i == *(i-1)` or
 `pred(*i, *(i - 1))`
 *Complexity:* If the range `[first, last)` is not empty, exactly
 `(last - first) - 1` applications of the corresponding predicate,
 otherwise no applications of the predicate.
 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.
 *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>

Diff to HTML by rtfpessoa