A forward_list - это контейнер, который поддерживает прямые итераторы и позволяет выполнять операции вставки и стирания с постоянным временем в любом месте последовательности с автоматическим управлением хранилищем. Быстрый произвольный доступ к элементам списка не поддерживается. [ Note: Предполагается, что forward_list у него нулевые объемные или временные накладные расходы по сравнению с рукописным односвязным списком в стиле C. Функции, которые противоречили бы этой цели, были опущены. ] — end note
A forward_list удовлетворяет всем требованиям a container, за исключением того, что size() функция-член не предоставляется и operator== имеет линейную сложность. A forward_list также удовлетворяет всем требованиям для allocator-aware container. Кроме того, a forward_list предоставляет assign функции-члены (таблица 87) и некоторые из optional container requirements. Здесь приведены описания только для операций forward_list , не описанных в этой таблице, или для операций, для которых имеется дополнительная семантическая информация.
[ Note: Изменение любого списка требует доступа к элементу, предшествующему первому интересующему элементу, но в a forward_list нет постоянного способа доступа к предыдущему элементу. По этой причине изменяемые диапазоны, например диапазоны, предоставленные для erase и splice, должны быть открыты в начале. ] — end note
namespace std { template <class T, class Allocator = allocator<T>> class forward_list { public: // types: 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; // see [container.requirements] using difference_type = implementation-defined; // see [container.requirements] using iterator = implementation-defined; // see [container.requirements] using const_iterator = implementation-defined; // see [container.requirements] // [forwardlist.cons], construct/copy/destroy forward_list() : forward_list(Allocator()) { } explicit forward_list(const Allocator&); explicit forward_list(size_type n, const Allocator& = Allocator()); forward_list(size_type n, const T& value, const Allocator& = Allocator()); template <class InputIterator> forward_list(InputIterator first, InputIterator last, const Allocator& = Allocator()); forward_list(const forward_list& x); forward_list(forward_list&& x); forward_list(const forward_list& x, const Allocator&); forward_list(forward_list&& x, const Allocator&); forward_list(initializer_list<T>, const Allocator& = Allocator()); ~forward_list(); forward_list& operator=(const forward_list& x); forward_list& operator=(forward_list&& x) noexcept(allocator_traits<Allocator>::is_always_equal::value); forward_list& operator=(initializer_list<T>); template <class InputIterator> void assign(InputIterator first, InputIterator last); void assign(size_type n, const T& t); void assign(initializer_list<T>); allocator_type get_allocator() const noexcept; // [forwardlist.iter], iterators iterator before_begin() noexcept; const_iterator before_begin() const noexcept; iterator begin() noexcept; const_iterator begin() const noexcept; iterator end() noexcept; const_iterator end() const noexcept; const_iterator cbegin() const noexcept; const_iterator cbefore_begin() const noexcept; const_iterator cend() const noexcept; // capacity: bool empty() const noexcept; size_type max_size() const noexcept; // [forwardlist.access], element access reference front(); const_reference front() const; // [forwardlist.modifiers], modifiers template <class... Args> reference emplace_front(Args&&... args); void push_front(const T& x); void push_front(T&& x); void pop_front(); template <class... Args> iterator emplace_after(const_iterator position, Args&&... args); iterator insert_after(const_iterator position, const T& x); iterator insert_after(const_iterator position, T&& x); iterator insert_after(const_iterator position, size_type n, const T& x); template <class InputIterator> iterator insert_after(const_iterator position, InputIterator first, InputIterator last); iterator insert_after(const_iterator position, initializer_list<T> il); iterator erase_after(const_iterator position); iterator erase_after(const_iterator position, const_iterator last); void swap(forward_list&) noexcept(allocator_traits<Allocator>::is_always_equal::value); void resize(size_type sz); void resize(size_type sz, const value_type& c); void clear() noexcept; // [forwardlist.ops], forward_list operations void splice_after(const_iterator position, forward_list& x); void splice_after(const_iterator position, forward_list&& 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); 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); void remove(const T& value); template <class Predicate> void remove_if(Predicate pred); void unique(); template <class BinaryPredicate> void unique(BinaryPredicate binary_pred); 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); void sort(); template <class Compare> void sort(Compare comp); void reverse() noexcept; }; template<class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> forward_list(InputIterator, InputIterator, Allocator = Allocator()) -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>; template <class T, class Allocator> bool operator==(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y); template <class T, class Allocator> bool operator< (const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y); template <class T, class Allocator> bool operator!=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y); template <class T, class Allocator> bool operator> (const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y); template <class T, class Allocator> bool operator>=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y); template <class T, class Allocator> bool operator<=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y); // [forwardlist.spec], specialized algorithms template <class T, class Allocator> void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y) noexcept(noexcept(x.swap(y))); }
Неполный тип T может использоваться при forward_list создании экземпляра, если распределитель удовлетворяет требованиям allocator completeness requirements. T заполняется до того, как будет сделана forward_list ссылка на какой-либо член результирующей специализации .