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(). 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 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);
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.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);
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 continue to refer to their elements, but they now
behave as iterators into
*this, not into
x.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())
. 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
. void unique();
template <class BinaryPredicate> void 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
.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);
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. The behavior is undefined if
get_allocator() != x.get_allocator(). Complexity: At most
distance(begin(),
end()) + distance(x.begin(), x.end()) - 1 comparisons
. 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
.Complexity: Approximately comparisons, where
N is
distance(begin(), end()). void reverse() noexcept;
Effects: Reverses the order of the elements in the list
. Does not affect the validity of iterators and references
.