[list] (original) (raw)

23 Containers library [containers]

23.3 Sequence containers [sequences]

23.3.11 Class template list [list]

23.3.11.1 Overview [list.overview]

Alistis a sequence container that supports bidirectional iterators and allows constant time insert and erase operations anywhere within the sequence, with storage management handled automatically.

Unlike vectors and deques, fast random access to list elements is not supported, but many algorithms only need sequential access anyway.

The exceptions are theoperator[]andatmember functions, which are not provided.196

Descriptions are provided here only for operations onlistthat are not described in one of these tables or for operations where there is additional semantic information.

namespace std { template<class T, class Allocator = allocator<T>> class list { public: using value_type = T;using allocator_type = Allocator;using pointer = typename allocator_traits<Allocator>::pointer;using const_pointer = typename allocator_traits<Allocator>::const_pointer;using reference = value_type&;using const_reference = const value_type&;using size_type = implementation-defined; using difference_type = implementation-defined; using iterator = implementation-defined; using const_iterator = implementation-defined; using reverse_iterator = std::reverse_iterator<iterator>;using const_reverse_iterator = std::reverse_iterator<const_iterator>;constexpr list() : list(Allocator()) { } constexpr explicit list(const Allocator&);constexpr explicit list(size_type n, const Allocator& = Allocator());constexpr list(size_type n, const T& value, const Allocator& = Allocator());template<class InputIterator> constexpr list(InputIterator first, InputIterator last, const Allocator& = Allocator());template<container-compatible-range<T> R> constexpr list(from_range_t, R&& rg, const Allocator& = Allocator());constexpr list(const list& x);constexpr list(list&& x);constexpr list(const list&, const type_identity_t<Allocator>&);constexpr list(list&&, const type_identity_t<Allocator>&);constexpr list(initializer_list<T>, const Allocator& = Allocator());constexpr ~list();constexpr list& operator=(const list& x);constexpr list& operator=(list&& x) noexcept(allocator_traits<Allocator>::is_always_equal::value);constexpr list& operator=(initializer_list<T>);template<class InputIterator> constexpr void assign(InputIterator first, InputIterator last);template<container-compatible-range<T> R> constexpr void assign_range(R&& rg);constexpr void assign(size_type n, const T& t);constexpr void assign(initializer_list<T>);constexpr allocator_type get_allocator() const noexcept;constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr reverse_iterator rbegin() noexcept;constexpr const_reverse_iterator rbegin() const noexcept;constexpr reverse_iterator rend() noexcept;constexpr const_reverse_iterator rend() const noexcept;constexpr const_iterator cbegin() const noexcept;constexpr const_iterator cend() const noexcept;constexpr const_reverse_iterator crbegin() const noexcept;constexpr const_reverse_iterator crend() const noexcept;constexpr bool empty() const noexcept;constexpr size_type size() const noexcept;constexpr size_type max_size() const noexcept;constexpr void resize(size_type sz);constexpr void resize(size_type sz, const T& c);constexpr reference front();constexpr const_reference front() const;constexpr reference back();constexpr const_reference back() const;template<class... Args> constexpr reference emplace_front(Args&&... args);template<class... Args> constexpr reference emplace_back(Args&&... args);constexpr void push_front(const T& x);constexpr void push_front(T&& x);template<container-compatible-range<T> R> constexpr void prepend_range(R&& rg);constexpr void pop_front();constexpr void push_back(const T& x);constexpr void push_back(T&& x);template<container-compatible-range<T> R> constexpr void append_range(R&& rg);constexpr void pop_back();template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);constexpr iterator insert(const_iterator position, const T& x);constexpr iterator insert(const_iterator position, T&& x);constexpr iterator insert(const_iterator position, size_type n, const T& x);template<class InputIterator> constexpr iterator insert(const_iterator position, InputIterator first, InputIterator last);template<container-compatible-range<T> R> constexpr iterator insert_range(const_iterator position, R&& rg);constexpr iterator insert(const_iterator position, initializer_list<T> il);constexpr iterator erase(const_iterator position);constexpr iterator erase(const_iterator position, const_iterator last);constexpr void swap(list&) noexcept(allocator_traits<Allocator>::is_always_equal::value);constexpr void clear() noexcept;constexpr void splice(const_iterator position, list& x);constexpr void splice(const_iterator position, list&& x);constexpr void splice(const_iterator position, list& x, const_iterator i);constexpr void splice(const_iterator position, list&& x, const_iterator i);constexpr void splice(const_iterator position, list& x, const_iterator first, const_iterator last);constexpr void splice(const_iterator position, list&& x, const_iterator first, const_iterator last);constexpr size_type remove(const T& value);template<class Predicate> constexpr size_type remove_if(Predicate pred);constexpr size_type unique();template<class BinaryPredicate> constexpr size_type unique(BinaryPredicate binary_pred);constexpr void merge(list& x);constexpr void merge(list&& x);template<class Compare> constexpr void merge(list& x, Compare comp);template<class Compare> constexpr void merge(list&& x, Compare comp);constexpr void sort();template<class Compare> constexpr void sort(Compare comp);constexpr void reverse() noexcept;};template<class InputIterator, class Allocator = allocator<_iter-value-type_<InputIterator>>> list(InputIterator, InputIterator, Allocator = Allocator()) -> list<_iter-value-type_<InputIterator>, Allocator>;template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>> list(from_range_t, R&&, Allocator = Allocator()) -> list<ranges::range_value_t<R>, Allocator>;}

T shall be complete before any member of the resulting specialization of list is referenced.

23.3.11.2 Constructors, copy, and assignment [list.cons]

constexpr explicit list(const Allocator&);

Effects: Constructs an empty list, using the specified allocator.

constexpr explicit list(size_type n, const Allocator& = Allocator());

Preconditions: T is Cpp17DefaultInsertable into list.

Effects: Constructs a list withn default-inserted elements using the specified allocator.

constexpr list(size_type n, const T& value, const Allocator& = Allocator());

Preconditions: T is Cpp17CopyInsertable into list.

Effects: Constructs alistwithncopies ofvalue, using the specified allocator.

template<class InputIterator> constexpr list(InputIterator first, InputIterator last, const Allocator& = Allocator());

Effects: Constructs alistequal to the range [first, last).

Complexity: Linear indistance(first, last).

Effects: Constructs a list object with the elements of the range rg.

Complexity: Linear in ranges​::​distance(rg).

23.3.11.3 Capacity [list.capacity]

constexpr void resize(size_type sz);

Preconditions: T is Cpp17DefaultInsertable into list.

Effects: If size() < sz, appends sz - size() default-inserted elements to the sequence.

If sz <= size(), equivalent to:list<T>::iterator it = begin(); advance(it, sz); erase(it, end());

constexpr void resize(size_type sz, const T& c);

Preconditions: T is Cpp17CopyInsertable into list.

Effects: As if by:if (sz > size()) insert(end(), sz-size(), c);else if (sz < size()) { iterator i = begin(); advance(i, sz); erase(i, end());} else ;

23.3.11.4 Modifiers [list.modifiers]

constexpr iterator insert(const_iterator position, const T& x);constexpr iterator insert(const_iterator position, T&& x);constexpr iterator insert(const_iterator position, size_type n, const T& x);template<class InputIterator> constexpr iterator insert(const_iterator position, InputIterator first, InputIterator last);template<[_container-compatible-range_](container.intro.reqmts#concept:container-compatible-range "23.2.2.1 Introduction [container.intro.reqmts]")<T> R> constexpr iterator insert_range(const_iterator position, R&& rg);constexpr iterator insert(const_iterator position, initializer_list<T>);template<class... Args> constexpr reference emplace_front(Args&&... args);template<class... Args> constexpr reference emplace_back(Args&&... args);template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);constexpr void push_front(const T& x);constexpr void push_front(T&& x);template<[_container-compatible-range_](container.intro.reqmts#concept:container-compatible-range "23.2.2.1 Introduction [container.intro.reqmts]")<T> R> constexpr void prepend_range(R&& rg);constexpr void push_back(const T& x);constexpr void push_back(T&& x);template<[_container-compatible-range_](container.intro.reqmts#concept:container-compatible-range "23.2.2.1 Introduction [container.intro.reqmts]")<T> R> constexpr void append_range(R&& rg);

Complexity: Insertion of a single element into a list takes constant time and exactly one call to a constructor ofT.

Insertion of multiple elements into a list is linear in the number of elements inserted, and the number of calls to the copy constructor or move constructor of T is exactly equal to the number of elements inserted.

Remarks: Does not affect the validity of iterators and references.

If an exception is thrown, there are no effects.

constexpr iterator erase(const_iterator position);constexpr iterator erase(const_iterator first, const_iterator last);constexpr void pop_front();constexpr void pop_back();constexpr void clear() noexcept;

Effects: Invalidates only the iterators and references to the erased elements.

Complexity: Erasing a single element is a constant time operation with a single call to the destructor ofT.

Erasing a range in a list is linear time in the size of the range and the number of calls to the destructor of typeTis exactly equal to the size of the range.

23.3.11.5 Operations [list.ops]

Since lists allow fast insertion and erasing from the middle of a list, certain operations are provided specifically for them.197

In this subclause, arguments for a template parameter named Predicate or BinaryPredicateshall 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.

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().

constexpr void splice(const_iterator position, list& x);constexpr void splice(const_iterator position, list&& x);

Preconditions: addressof(x) != this is true.

Effects: Inserts the contents ofxbeforepositionandxbecomes empty.

Pointers and references to the moved elements ofxnow 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: Constant time.

constexpr void splice(const_iterator position, list& x, const_iterator i);constexpr void splice(const_iterator position, list&& x, const_iterator i);

Preconditions: i is a valid dereferenceable iterator of x.

Effects: Inserts an element pointed to byifrom listxbefore position and removes the element fromx.

The result is unchanged ifposition == iorposition == ++i.

Pointers and references to*icontinue to refer to this same element but as a member of*this.

Iterators to*i(includingiitself) continue to refer to the same element, but now behave as iterators into*this, not intox.

Complexity: Constant time.

constexpr void splice(const_iterator position, list& x, const_iterator first, const_iterator last);constexpr void splice(const_iterator position, list&& x, const_iterator first, const_iterator last);

Preconditions: [first, last) is a valid range in x.

position is not an iterator in the range [first, last).

Effects: Inserts elements in the range [first, last) beforepositionand removes the elements fromx.

Pointers and references to the moved elements ofxnow 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: Constant time ifaddressof(x) == this; otherwise, linear time.

constexpr size_type remove(const T& value);template<class Predicate> constexpr 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, pred(*i) != false.

Invalidates only the iterators and references to the erased elements.

Returns: The number of elements erased.

Throws: Nothing unless an exception is thrown by*i == valueorpred(*i) != false.

Complexity: Exactlysize()applications of the corresponding predicate.

constexpr size_type unique();template<class BinaryPredicate> constexpr size_type unique(BinaryPredicate binary_pred);

Let binary_pred be equal_to<>{} for the first overload.

Preconditions: binary_pred is an equivalence relation.

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.

Returns: The number of elements erased.

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

Complexity: If empty() is false, exactly size() - 1 applications of the corresponding predicate, otherwise no applications of the predicate.

constexpr void merge(list& x);constexpr void merge(list&& x);template<class Compare> constexpr void merge(list& x, Compare comp);template<class Compare> constexpr void merge(list&& x, Compare comp);

Let comp be less<> for the first two overloads.

Preconditions: *this and x are both sorted with respect to the comparator comp, andget_allocator() == x.get_allocator() is true.

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

Complexity: At most size() + x.size() - 1 comparisons if addressof(x) != this; otherwise, no comparisons are performed.

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.

constexpr void reverse() noexcept;

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

Does not affect the validity of iterators and references.

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

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.

Complexity: Approximatelycomparisons, whereN == size().

23.3.11.6 Erasure [list.erasure]

template<class T, class Allocator, class U = T> typename list<T, Allocator>::size_typeconstexpr erase(list<T, Allocator>& c, const U& value);

Effects: Equivalent to: return erase_if(c, [&](const auto& elem) -> bool { return elem == value; });

template<class T, class Allocator, class Predicate> typename list<T, Allocator>::size_typeconstexpr erase_if(list<T, Allocator>& c, Predicate pred);

Effects: Equivalent to: return c.remove_if(pred);