23 Containers library [containers]

23.3 Sequence containers [sequences]

23.3.9 Class template list [list]

23.3.9.5 Operations [list.ops]

1
#
Since lists allow fast insertion and erasing from the middle of a list, certain operations are provided specifically for them.199
In this subclause, arguments for a template parameter named Predicate or BinaryPredicate shall meet the corresponding requirements in [algorithms.requirements].
The semantics of i + n and i - n, where i is an iterator into the list and n is an integer, are the same as those of next(i, n) and prev(i, n), respectively.
For merge and sort, the definitions and requirements in [alg.sorting] apply.
2
#
list provides three splice operations that destructively move elements from one list to another.
The behavior of splice operations is undefined if get_allocator() != x.get_allocator().
🔗
void splice(const_iterator position, list& x); void splice(const_iterator position, list&& x);
3
#
Preconditions: addressof(x) != this is true.
4
#
Effects: Inserts the contents of x before 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.
5
#
Throws: Nothing.
6
#
Complexity: Constant time.
🔗
void splice(const_iterator position, list& x, const_iterator i); void splice(const_iterator position, list&& x, const_iterator i);
7
#
Preconditions: i is a valid dereferenceable iterator of x.
8
#
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.
9
#
Throws: Nothing.
10
#
Complexity: Constant time.
🔗
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);
11
#
Preconditions: [first, last) is a valid range in x.
position is not an iterator in the range [first, last).
12
#
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.
13
#
Throws: Nothing.
14
#
Complexity: Constant time if addressof(x) == this; otherwise, linear time.
🔗
size_type remove(const T& value); template<class Predicate> size_type remove_if(Predicate pred);
15
#
Effects: Erases all the elements in the list referred to by a list iterator i for which the following conditions hold: *i == value, pred(*i) != false.
Invalidates only the iterators and references to the erased elements.
16
#
Returns: The number of elements erased.
17
#
Throws: Nothing unless an exception is thrown by *i == value or pred(*i) != false.
18
#
Complexity: Exactly size() applications of the corresponding predicate.
19
#
Remarks: Stable.
🔗
size_type unique(); template<class BinaryPredicate> size_type unique(BinaryPredicate binary_pred);
20
#
Let binary_pred be equal_to<>{} for the first overload.
21
#
Preconditions: binary_pred is an equivalence relation.
22
#
Effects: Erases all but the first element from every consecutive group of equivalent elements.
That is, for a nonempty list, erases all elements referred to by the iterator i in the range [begin() + 1, end()) for which binary_pred(*i, *(i - 1)) is true.
Invalidates only the iterators and references to the erased elements.
23
#
Returns: The number of elements erased.
24
#
Throws: Nothing unless an exception is thrown by the predicate.
25
#
Complexity: If empty() is false, exactly size() - 1 applications of the corresponding predicate, otherwise no applications of the predicate.
🔗
void merge(list& x); void merge(list&& x); template<class Compare> void merge(list& x, Compare comp); template<class Compare> void merge(list&& x, Compare comp);
26
#
Let comp be less<> for the first two overloads.
27
#
Preconditions: *this and x are both sorted with respect to the comparator comp, and get_allocator() == x.get_allocator() is true.
28
#
Effects: If addressof(x) == this, there are no effects.
Otherwise, merges the two sorted ranges [begin(), end()) and [x.begin(), x.end()).
The result is a range that is sorted with respect to the comparator comp.
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.
29
#
Complexity: At most size() + x.size() - 1 comparisons if addressof(x) != this; otherwise, no comparisons are performed.
30
#
Remarks: Stable ([algorithm.stable]).
If addressof(x) != this, x is empty after the merge.
No elements are copied by this operation.
If an exception is thrown other than by a comparison, there are no effects.
🔗
void reverse() noexcept;
31
#
Effects: Reverses the order of the elements in the list.
Does not affect the validity of iterators and references.
32
#
Complexity: Linear time.
🔗
void sort(); template<class Compare> void sort(Compare comp);
33
#
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.
34
#
Complexity: Approximately comparisons, where N == size().
35
#
Remarks: Stable.
199)199)
As specified in [allocator.requirements], the requirements in this Clause apply only to lists whose allocators compare equal.
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy