[forward.list.overview] (original) (raw)

A forward_list is a container that supports forward iterators and allows constant time insert and erase operations anywhere within the sequence, with storage management handled automatically.

Fast random access to list elements is not supported.

[Note 1:

It is intended that forward_list have zero space or time overhead relative to a hand-written C-style singly linked list.

Features that would conflict with that goal have been omitted.

— _end note_]

A forward_list meets all of the requirements of a container ([container.reqmts]), except that the size() member function is not provided andoperator== has linear complexity.

A forward_list also meets all of the requirements for an allocator-aware container ([container.alloc.reqmts]).

In addition, a forward_listprovides the assign member functions and several of the optional sequence container requirements ([sequence.reqmts]).

Descriptions are provided here only for operations onforward_list that are not described in that table or for operations where there is additional semantic information.

namespace std { template<class T, class Allocator = allocator<T>> class forward_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; constexpr forward_list() : forward_list(Allocator()) { } constexpr explicit forward_list(const Allocator&);constexpr explicit forward_list(size_type n, const Allocator& = Allocator());constexpr forward_list(size_type n, const T& value, const Allocator& = Allocator());template<class InputIterator> constexpr forward_list(InputIterator first, InputIterator last,const Allocator& = Allocator());template<container-compatible-range<T> R> constexpr forward_list(from_range_t, R&& rg, const Allocator& = Allocator());constexpr forward_list(const forward_list& x);constexpr forward_list(forward_list&& x);constexpr forward_list(const forward_list& x, const type_identity_t<Allocator>&);constexpr forward_list(forward_list&& x, const type_identity_t<Allocator>&);constexpr forward_list(initializer_list<T>, const Allocator& = Allocator());constexpr ~forward_list();constexpr forward_list& operator=(const forward_list& x);constexpr forward_list& operator=(forward_list&& x) noexcept(allocator_traits<Allocator>::is_always_equal::value);constexpr forward_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 before_begin() noexcept;constexpr const_iterator before_begin() const noexcept;constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr const_iterator cbegin() const noexcept;constexpr const_iterator cbefore_begin() const noexcept;constexpr const_iterator cend() const noexcept;constexpr bool empty() const noexcept;constexpr size_type max_size() const noexcept;constexpr reference front();constexpr const_reference front() const;template<class... Args> constexpr reference emplace_front(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();template<class... Args> constexpr iterator emplace_after(const_iterator position, Args&&... args);constexpr iterator insert_after(const_iterator position, const T& x);constexpr iterator insert_after(const_iterator position, T&& x);constexpr iterator insert_after(const_iterator position, size_type n, const T& x);template<class InputIterator> constexpr iterator insert_after(const_iterator position, InputIterator first, InputIterator last);constexpr iterator insert_after(const_iterator position, initializer_list<T> il);template<container-compatible-range<T> R> constexpr iterator insert_range_after(const_iterator position, R&& rg);constexpr iterator erase_after(const_iterator position);constexpr iterator erase_after(const_iterator position, const_iterator last);constexpr void swap(forward_list&) noexcept(allocator_traits<Allocator>::is_always_equal::value);constexpr void resize(size_type sz);constexpr void resize(size_type sz, const value_type& c);constexpr void clear() noexcept;constexpr void splice_after(const_iterator position, forward_list& x);constexpr void splice_after(const_iterator position, forward_list&& x);constexpr void splice_after(const_iterator position, forward_list& x, const_iterator i);constexpr void splice_after(const_iterator position, forward_list&& x, const_iterator i);constexpr void splice_after(const_iterator position, forward_list& x, const_iterator first, const_iterator last);constexpr void splice_after(const_iterator position, forward_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); size_type unique();template<class BinaryPredicate> constexpr size_type unique(BinaryPredicate binary_pred);constexpr void merge(forward_list& x);constexpr void merge(forward_list&& x);template<class Compare> constexpr void merge(forward_list& x, Compare comp);template<class Compare> constexpr void merge(forward_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>>> forward_list(InputIterator, InputIterator, Allocator = Allocator()) -> forward_list<_iter-value-type_<InputIterator>, Allocator>;template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>> forward_list(from_range_t, R&&, Allocator = Allocator()) -> forward_list<ranges::range_value_t<R>, Allocator>;}

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