Standard library header - cppreference.com (original) (raw)

This header is part of the containers library.

[edit] Synopsis

#include #include   namespace std { // class template list template<class T, class Allocator = allocator> class list;   template<class T, class Allocator> bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y); template<class T, class Allocator> /synth-three-way-result/ operator<=>(const list<T, Allocator>& x, const list<T, Allocator>& y);   template<class T, class Allocator> void swap(list<T, Allocator>& x, list<T, Allocator>& y) noexcept(noexcept(x.swap(y)));   // erasure template<class T, class Allocator, class U = T> typename list<T, Allocator>::size_type erase(list<T, Allocator>& c, const U& value); template<class T, class Allocator, class Predicate> typename list<T, Allocator>::size_type erase_if(list<T, Allocator>& c, Predicate pred);   namespace pmr { template using list = std::list<T, polymorphic_allocator>; } }

[edit] Class template std::list

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