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

Files changed (1) hide show

tmp/tmp2yl0oiwq/{from.md → to.md} +66 -61

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

@@ -10,23 +10,23 @@ access to list elements is not supported. It is intended that
 hand-written C-style singly linked list. Features that would conflict
 with that goal have been omitted.
 A `forward_list` satisfies all of the requirements of a container
 (Table  [[tab:containers.container.requirements]]), except that the
-`size()` member function is not provided. A `forward_list` also
-satisfies all of the requirements for an allocator-aware container
-(Table  [[tab:containers.allocatoraware]]). In addition, a
-`forward_list` provides the `assign` member functions (Table
-[[tab:containers.sequence.requirements]]) and several of the optional
-container requirements (Table  [[tab:containers.sequence.optional]]).
-Descriptions are provided here only for operations on `forward_list`
-that are not described in that table or for operations where there is
-additional semantic information.
 Modifying any list requires access to the element preceding the first
 element of interest, but in a `forward_list` there is no constant-time
-way to acess a preceding element. For this reason, ranges that are
 modified, such as those supplied to `erase` and `splice`, must be open
 at the beginning.
 ``` cpp
 namespace std {
@@ -44,12 +44,13 @@ namespace std {
     typedef Allocator allocator_type;
     typedef typename allocator_traits<Allocator>::pointer         pointer;
     typedef typename allocator_traits<Allocator>::const_pointer   const_pointer;
     // [forwardlist.cons], construct/copy/destroy:
- explicit forward_list(const Allocator& = Allocator());
-    explicit forward_list(size_type n);
     forward_list(size_type n, const T& value,
                  const Allocator& = Allocator());
     template <class InputIterator>
       forward_list(InputIterator first, InputIterator last,
                    const Allocator& = Allocator());
@@ -161,26 +162,26 @@ namespace std {
 ```
 #### `forward_list` constructors, copy, assignment <a id="forwardlist.cons">[[forwardlist.cons]]</a>
 ``` cpp
-explicit forward_list(const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `forward_list` object using the specified
 allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit forward_list(size_type n);
 ```
-*Effects:* Constructs a `forward_list` object with `n` value-initialized
-elements.
-*Requires:* `T` shall be `DefaultConstructible`.
 *Complexity:* Linear in `n`.
 ``` cpp
 forward_list(size_type n, const T& value, const Allocator& = Allocator());
@@ -201,23 +202,10 @@ template <class InputIterator>
 *Effects:* Constructs a `forward_list` object equal to the range
 \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
-``` cpp
-template <class InputIterator>
-  void assign(InputIterator first, InputIterator last);
-```
-*Effects:* `clear(); insert_after(before_begin(), first, last);`
-``` cpp
-void assign(size_type n, const T& t);
-```
-*Effects:* `clear(); insert_after(before_begin(), n, t);`
 #### `forward_list` iterators <a id="forwardlist.iter">[[forwardlist.iter]]</a>
 ``` cpp
 iterator before_begin() noexcept;
 const_iterator before_begin() const noexcept;
@@ -316,11 +304,11 @@ iterator insert_after(const_iterator position, initializer_list<T> il);
 ```
 *Effects:* `insert_after(p, il.begin(), il.end())`.
 *Returns:* An iterator pointing to the last inserted element or
-`position` if `i1` is empty.
 ``` cpp
 template <class... Args>
   iterator emplace_after(const_iterator position, Args&&... args);
 ```
@@ -360,21 +348,31 @@ dereferenceable.
 *Throws:* Nothing.
 ``` cpp
 void resize(size_type sz);
 void resize(size_type sz, const value_type& c);
 ```
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
-inserts `sz - distance(begin(), end())` elements at the end of the list.
-For the first signature the inserted elements are value-initialized, and
-for the second signature they are copies of `c`.
-*Requires:* `T` shall be `DefaultConstructible` for the first form and
-it shall be `CopyInsertable` into `*this` for the second form.
 ``` cpp
 void clear() noexcept;
 ```
@@ -388,11 +386,12 @@ void clear() noexcept;
 void splice_after(const_iterator position, forward_list& x);
 void splice_after(const_iterator position, forward_list&& x);
 ```
 *Requires:* `position` is `before_begin()` or is a dereferenceable
-iterator in the range \[`begin()`, `end()`). `&x != this`.
 *Effects:* Inserts the contents of `x` after `position`, and `x` becomes
 empty. 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
@@ -408,17 +407,18 @@ void splice_after(const_iterator position, forward_list&& x, const_iterator i);
 ```
 *Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). The iterator following `i`
 is a dereferenceable iterator in `x`.
 *Effects:* Inserts the element following `i` into `*this`, following
 `position`, and removes it from `x`. The result is unchanged if
-`position == i` or `position == ++i`. Pointers and references to `*i`
 continue to refer to the 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:* 𝑂(1)
@@ -431,11 +431,11 @@ void splice_after(const_iterator position, forward_list&& x,
 *Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). (`first`, `last`) is a
 valid range in `x`, and all iterators in the range (`first`, `last`) are
 dereferenceable. `position` is not an iterator in the range (`first`,
-`last`).
 *Effects:* Inserts elements in the range (`first`, `last`) after
 `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
@@ -449,18 +449,18 @@ void remove(const T& value);
 template <class Predicate> void remove_if(Predicate pred);
 ```
 *Effects:* Erases all the elements in the list referred by a list
 iterator `i` for which the following conditions hold: `*i == value` (for
-`remove()`), `pred(*i)` is true (for `remove_if()`). This operation
-shall be stable: the relative order of the elements that are not removed
-is the same as their relative order in the original list. Invalidates
-only the iterators and references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by the equality
 comparison or the predicate.
 *Complexity:* Exactly `distance(begin(), end())` applications of the
 corresponding predicate.
 ``` cpp
 void unique();
@@ -482,28 +482,32 @@ comparison or the predicate.
 otherwise no applications of the predicate.
 ``` cpp
 void merge(forward_list& x);
 void merge(forward_list&& x);
-template <class Compare> void merge(forward_list& x, Compare comp)
-template <class Compare> void merge(forward_list&& x, Compare comp)
 ```
 *Requires:* `comp` defines a strict weak ordering ([[alg.sorting]]),
 and `*this` and `x` are both sorted according to this ordering.
-*Effects:* Merges `x` into `*this`. This operation shall be stable: for
-equivalent elements in the two lists, the elements from `*this` shall
-always precede the elements from `x`. `x` is empty after the merge. If
-an exception is thrown other than by a comparison there are no effects.
-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`.
-*Complexity:* At most distance(begin(), end()) + distance(x.begin(),
-x.end()) - 1 comparisons.
 ``` cpp
 void sort();
 template <class Compare> void sort(Compare comp);
 ```
@@ -511,14 +515,15 @@ template <class Compare> void sort(Compare comp);
 *Requires:* `operator<` (for the version with no arguments) or `comp`
 (for the version with a comparison argument) defines a strict weak
 ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or the `comp`
-function object. This operation shall be stable: the relative order of
-the equivalent elements is preserved. If an exception is thrown the
-order of the elements in `*this` is unspecified. Does not affect the
-validity of iterators and references.
 *Complexity:* Approximately N log N comparisons, where N is
 `distance(begin(), end())`.
 ``` cpp

 hand-written C-style singly linked list. Features that would conflict
 with that goal have been omitted.
 A `forward_list` satisfies all of the requirements of a container
 (Table  [[tab:containers.container.requirements]]), except that the
+`size()` member function is not provided and `operator==` has linear
+complexity. A `forward_list` also satisfies all of the requirements for
+an allocator-aware container (Table  [[tab:containers.allocatoraware]]).
+In addition, a `forward_list` provides the `assign` member functions
+(Table  [[tab:containers.sequence.requirements]]) and several of the
+optional container requirements (Table
+[[tab:containers.sequence.optional]]). Descriptions are provided here
+only for operations on `forward_list` that are not described in that
+table or for operations where there is additional semantic information.
 Modifying any list requires access to the element preceding the first
 element of interest, but in a `forward_list` there is no constant-time
+way to access a preceding element. For this reason, ranges that are
 modified, such as those supplied to `erase` and `splice`, must be open
 at the beginning.
 ``` cpp
 namespace std {
     typedef Allocator allocator_type;
     typedef typename allocator_traits<Allocator>::pointer         pointer;
     typedef typename allocator_traits<Allocator>::const_pointer   const_pointer;
     // [forwardlist.cons], construct/copy/destroy:
+    forward_list() : forward_list(Allocator()) { }
+    explicit forward_list(const Allocator&);
+    explicit forward_list(size_type n, const Allocator& = Allocator());
     forward_list(size_type n, const T& value,
                  const Allocator& = Allocator());
     template <class InputIterator>
       forward_list(InputIterator first, InputIterator last,
                    const Allocator& = Allocator());
 ```
 #### `forward_list` constructors, copy, assignment <a id="forwardlist.cons">[[forwardlist.cons]]</a>
 ``` cpp
+explicit forward_list(const Allocator&);
 ```
 *Effects:* Constructs an empty `forward_list` object using the specified
 allocator.
 *Complexity:* Constant.
 ``` cpp
+explicit forward_list(size_type n, const Allocator& = Allocator());
 ```
+*Effects:* Constructs a `forward_list` object with `n` default-inserted
+elements using the specified allocator.
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 forward_list(size_type n, const T& value, const Allocator& = Allocator());
 *Effects:* Constructs a `forward_list` object equal to the range
 \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
 #### `forward_list` iterators <a id="forwardlist.iter">[[forwardlist.iter]]</a>
 ``` cpp
 iterator before_begin() noexcept;
 const_iterator before_begin() const noexcept;
 ```
 *Effects:* `insert_after(p, il.begin(), il.end())`.
 *Returns:* An iterator pointing to the last inserted element or
+`position` if `il` is empty.
 ``` cpp
 template <class... Args>
   iterator emplace_after(const_iterator position, Args&&... args);
 ```
 *Throws:* Nothing.
 ``` cpp
 void resize(size_type sz);
+```
+*Effects:* If `sz < distance(begin(), end())`, erases the last
+`distance(begin(), end()) - sz` elements from the list. Otherwise,
+inserts `sz - distance(begin(), end())` default-inserted elements at the
+end of the list.
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
+``` cpp
 void resize(size_type sz, const value_type& c);
 ```
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
+inserts `sz - distance(begin(), end())` elements at the end of the list
+such that each new element, `e`, is initialized by a method equivalent
+to calling
+`allocator_traits<allocator_type>::construct(get_allocator(), std::addressof(e), c)`.
+*Requires:* `T` shall be `CopyInsertable` into `*this`.
 ``` cpp
 void clear() noexcept;
 ```
 void splice_after(const_iterator position, forward_list& x);
 void splice_after(const_iterator position, forward_list&& x);
 ```
 *Requires:* `position` is `before_begin()` or is a dereferenceable
+iterator in the range \[`begin()`, `end()`).
+`get_allocator() == x.get_allocator()`. `&x != this`.
 *Effects:* Inserts the contents of `x` after `position`, and `x` becomes
 empty. 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
 ```
 *Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). The iterator following `i`
 is a dereferenceable iterator in `x`.
+`get_allocator() == x.get_allocator()`.
 *Effects:* Inserts the element following `i` into `*this`, following
 `position`, and removes it from `x`. The result is unchanged if
+`position == i` or `position == ++i`. Pointers and references to `*++i`
 continue to refer to the same element but as a member of `*this`.
+Iterators to `*++i` continue to refer to the same element, but now
+behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* 𝑂(1)
 *Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). (`first`, `last`) is a
 valid range in `x`, and all iterators in the range (`first`, `last`) are
 dereferenceable. `position` is not an iterator in the range (`first`,
+`last`). `get_allocator() == x.get_allocator()`.
 *Effects:* Inserts elements in the range (`first`, `last`) after
 `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
 template <class Predicate> void remove_if(Predicate pred);
 ```
 *Effects:* Erases all the elements in the list referred by a list
 iterator `i` for which the following conditions hold: `*i == value` (for
+`remove()`), `pred(*i)` is true (for `remove_if()`). Invalidates only
+the iterators and references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by the equality
 comparison or the predicate.
+*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Exactly `distance(begin(), end())` applications of the
 corresponding predicate.
 ``` cpp
 void unique();
 otherwise no applications of the predicate.
 ``` cpp
 void merge(forward_list& x);
 void merge(forward_list&& x);
+template <class Compare> void merge(forward_list& x, Compare comp);
+template <class Compare> void merge(forward_list&& x, Compare comp);
 ```
 *Requires:* `comp` defines a strict weak ordering ([[alg.sorting]]),
 and `*this` and `x` are both sorted according to this ordering.
+`get_allocator() == x.get_allocator()`.
+*Effects:* Merges the two sorted ranges `[begin(), end())` and
+`[x.begin(), x.end())`. `x` is empty after the merge. If an exception is
+thrown other than by a comparison there are no effects. 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]]). The behavior is undefined if
+`this->get_allocator() != x.get_allocator()`.
+*Complexity:* At most
+`distance(begin(), end()) + distance(x.begin(), x.end()) - 1`
+comparisons.
 ``` cpp
 void sort();
 template <class Compare> void sort(Compare comp);
 ```
 *Requires:* `operator<` (for the version with no arguments) or `comp`
 (for the version with a comparison argument) defines a strict weak
 ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or the `comp`
+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 is
 `distance(begin(), end())`.
 ``` cpp

Diff to HTML by rtfpessoa