[forwardlist.ops] (original) (raw)

22 Containers library [containers]

22.3 Sequence containers [sequences]

22.3.9 Class template forward_­list [forwardlist]

22.3.9.6 Operations [forwardlist.ops]

In this subclause, arguments for a template parameter named Predicate or BinaryPredicateshall meet the corresponding requirements in [algorithms.requirements].

For merge and sort, the definitions and requirements in [alg.sorting] apply.

void splice_after(const_iterator position, forward_list& x);void splice_after(const_iterator position, forward_list&& x);

Preconditions: position is before_­begin() or is a dereferenceable iterator in the range [begin(), end()).

get_­allocator() == x.get_­allocator() is true.

addressof(x) != this is true.

Effects:Inserts the contents of x afterposition, 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 now behave as iterators into *this, not into x.

void splice_after(const_iterator position, forward_list& x, const_iterator i);void splice_after(const_iterator position, forward_list&& x, const_iterator i);

Preconditions: 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() is true.

Effects:Inserts the element following i into *this, followingposition, 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.

void splice_after(const_iterator position, forward_list& x, const_iterator first, const_iterator last);void splice_after(const_iterator position, forward_list&& x, const_iterator first, const_iterator last);

Preconditions: 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() is true.

Effects:Inserts elements in the range (first, last) after position and removes the elements from x.

Pointers and references to the moved elements ofx 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.

size_type remove(const T& value);template<class Predicate> size_type remove_if(Predicate pred);

Effects:Erases all the elements in the list referred to 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.

Returns:The number of elements erased.

Throws:Nothing unless an exception is thrown by the equality comparison or the predicate.

Complexity:Exactly distance(begin(), end()) applications of the corresponding predicate.

size_type unique();template<class BinaryPredicate> size_type unique(BinaryPredicate pred);

Effects:Erases all but the first element from every consecutive group of equal elements referred to by the iterator i in the range [first + 1, last) for which *i == *(i-1) (for the version with no arguments) or pred(*i,*(i - 1)) (for the version with a predicate argument) holds.

Invalidates only the iterators and references to the erased elements.

Returns:The number of elements erased.

Throws:Nothing unless an exception is thrown by the equality comparison or the predicate.

Complexity:If the range [first, last) is not empty, exactly (last - first) - 1 applications of the corresponding predicate, otherwise no applications of the predicate.

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);

Preconditions: *this and x are both sorted with respect to the comparator operator< (for the first two overloads) orcomp (for the last two overloads), andget_­allocator() == x.get_­allocator() is true.

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 intox.

Complexity:At most distance(begin(), end()) + distance(x.begin(), x.end()) - 1 comparisons.

void sort();template<class Compare> void sort(Compare comp);

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.

Complexity:Approximately comparisons, where N is distance(begin(), end()).

Effects:Reverses the order of the elements in the list.

Does not affect the validity of iterators and references.