# Standard library header <forward_list>

From cppreference.com
< cpp‎ | header

This header is part of the containers library.

### Includes
`<initializer_list>`(C++11)
### Classes
forward_list (C++11) | singly-linked list (class template)
### Functions
operator==operator!=operator<operator<=operator>operator>= | lexicographically compares the values in the forward_list (function template)
std::swap(std::forward_list) (C++11) | specializes the std::swap algorithm (function template)

### Synopsis

    #include <initializer_list>

    namespace std {

    template <class T, class Allocator = allocator<T> > class forward_list;

    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);

    template <class T, class Allocator>
        void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);

    }

#### Class std::forward_list

    template <class T, class Allocator = allocator<T> >
    class forward_list {
    public:
        // types:
        typedef value_type&                                         reference;
        typedef const value_type&                                   const_reference;
        typedef /*implementation-defined*/                          iterator;
        typedef /*implementation-defined*/                          const_iterator;
        typedef /*implementation-defined*/                          size_type;
        typedef /*implementation-defined*/                          difference_type;
        typedef T                                                   value_type;
        typedef Allocator                                           allocator_type;
        typedef typename allocator_traits<Allocator>::pointer       pointer;
        typedef typename allocator_traits<Allocator>::const_pointer const_pointer;

        // construct/copy/destroy:
        explicit forward_list(const Allocator& = Allocator());
        explicit forward_list(size_type n);
        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<T,Allocator>& x);
        forward_list(forward_list&&);
        forward_list(const forward_list&, const Allocator&);
        forward_list(forward_list&&, const Allocator&);
        forward_list(initializer_list<T>, const Allocator& = Allocator());

        ~forward_list();
        forward_list<T,Allocator>& operator=(const forward_list<T,Allocator>& x);
        forward_list<T,Allocator>& operator=(forward_list<T,Allocator>&& x);
        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;

        // 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() noexcept;
        const_iterator          cbefore_begin() const noexcept;
        const_iterator          cend() noexcept;

        // capacity:
        size_type max_size() const noexcept;
        bool      empty() const noexcept;

        // element access:
        reference       front();
        const_reference front() const;

        // modifiers:
        template <class... Args> void 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, iterator last);
        void swap(forward_list<T,Allocator>&);

        void resize(size_type sz);
        void resize(size_type sz, const value_type& c);
        void clear() noexcept;

        // forward_list operations:
        void splice_after(const_iterator position, forward_list<T,Allocator>& x);
        void splice_after(const_iterator position, forward_list<T,Allocator>&& x);
        void splice_after(const_iterator position, forward_list<T,Allocator>& x,
                        const_iterator i);
        void splice_after(const_iterator position, forward_list<T,Allocator>&& x,
                        const_iterator i);
        void splice_after(const_iterator position, forward_list<T,Allocator>& x,
                        const_iterator first, const_iterator last);
        void splice_after(const_iterator position, forward_list<T,Allocator>&& 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<T,Allocator>& x);
        void merge(forward_list<T,Allocator>&& x);
        template <class Compare> void merge(forward_list<T,Allocator>& x, Compare comp);
        template <class Compare> void merge(forward_list<T,Allocator>&& x, Compare comp);

        void sort();
        template <class Compare> void sort(Compare comp);
        void reverse() noexcept;
    };

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/forward_list&oldid=106348"