forward_list< _Ty, _Alloc > Class Template Reference

Inheritance diagram for forward_list< _Ty, _Alloc >:

Public Types
typedef forward_list< _Ty, _Alloc >	_Myt
typedef _Flist_buy< _Ty, _Alloc >	_Mybase
typedef _Mybase::_Node	_Node
typedef _Mybase::_Nodeptr	_Nodeptr
typedef _Mybase::_Alty	_Alty
typedef _Alloc	allocator_type
typedef _Mybase::size_type	size_type
typedef _Mybase::difference_type	difference_type
typedef _Mybase::pointer	pointer
typedef _Mybase::const_pointer	const_pointer
typedef _Mybase::reference	reference
typedef _Mybase::const_reference	const_reference
typedef _Mybase::value_type	value_type
typedef _Mybase::const_iterator	const_iterator
typedef _Mybase::iterator	iterator
Public Types inherited from _Flist_buy< _Ty, _Alloc >
typedef _Flist_buy< _Ty, _Alloc >	_Myt
typedef _Flist_alloc< _Flist_base_types< _Ty, _Alloc > >	_Mybase
typedef _Mybase::_Alty	_Alty
typedef _Mybase::_Nodeptr	_Nodeptr
Public Types inherited from _Flist_alloc< _Flist_base_types< _Ty, _Alloc > >
typedef _Flist_alloc< _Flist_base_types< _Ty, _Alloc > >	_Myt
typedef _Flist_base_types< _Ty, _Alloc >::_Alloc	_Alloc
typedef _Flist_base_types< _Ty, _Alloc >::_Alnod_type	_Alty
typedef _Flist_base_types< _Ty, _Alloc >::_Node	_Node
typedef _Flist_base_types< _Ty, _Alloc >::_Nodeptr	_Nodeptr
typedef _Flist_base_types< _Ty, _Alloc >::_Val_types	_Val_types
typedef _Nodeptr &	_Nodepref
typedef _Val_types::value_type	value_type
typedef _Val_types::size_type	size_type
typedef _Val_types::difference_type	difference_type
typedef _Val_types::pointer	pointer
typedef _Val_types::const_pointer	const_pointer
typedef _Val_types::reference	reference
typedef _Val_types::const_reference	const_reference
typedef _Flist_const_iterator< _Flist_val< _Val_types > >	const_iterator
typedef _Flist_iterator< _Flist_val< _Val_types > >	iterator

Public Member Functions
	forward_list ()
	forward_list (_CRT_GUARDOVERFLOW size_type _Count, const _Alloc &_Al=_Alloc())
	forward_list (_CRT_GUARDOVERFLOW size_type _Count, const _Ty &_Val)
	forward_list (_CRT_GUARDOVERFLOW size_type _Count, const _Ty &_Val, const _Alloc &_Al)
	forward_list (const _Alloc &_Al)
	forward_list (const _Myt &_Right)
	forward_list (const _Myt &_Right, const _Alloc &_Al)
template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>
	forward_list (_Iter _First, _Iter _Last)
template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>
	forward_list (_Iter _First, _Iter _Last, const _Alloc &_Al)
template<class _Iter >
void	_Construct (_Iter _First, _Iter _Last)
void	_Construct_n (size_type _Count, const _Ty &_Val)
	forward_list (_Myt &&_Right)
	forward_list (_Myt &&_Right, const _Alloc &_Al)
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT_OP(_Alty
void	_Assign_rv (_Myt &&_Right, true_type)
void	_Assign_rv (_Myt &&_Right, false_type)
void	push_front (_Ty &&_Val)
iterator	insert_after (const_iterator _Where, _Ty &&_Val)
template<class... _Valty>
void	emplace_front (_Valty &&..._Val)
template<class... _Valty>
iterator	emplace_after (const_iterator _Where, _Valty &&..._Val)
template<class... _Valty>
void	_Insert_after (const_iterator _Where, _Valty &&..._Val)
	forward_list (initializer_list< _Ty > _Ilist, const _Alloc &_Al=allocator_type())
_Myt &	operator= (initializer_list< _Ty > _Ilist)
void	assign (initializer_list< _Ty > _Ilist)
iterator	insert_after (const_iterator _Where, initializer_list< _Ty > _Ilist)
	~forward_list () _NOEXCEPT
_Myt &	operator= (const _Myt &_Right)
iterator	before_begin () _NOEXCEPT
const_iterator	before_begin () const _NOEXCEPT
const_iterator	cbefore_begin () const _NOEXCEPT
iterator	begin () _NOEXCEPT
const_iterator	begin () const _NOEXCEPT
iterator	end () _NOEXCEPT
const_iterator	end () const _NOEXCEPT
iterator	_Make_iter (const_iterator _Where) const
const_iterator	cbegin () const _NOEXCEPT
const_iterator	cend () const _NOEXCEPT
void	resize (_CRT_GUARDOVERFLOW size_type _Newsize)
void	resize (_CRT_GUARDOVERFLOW size_type _Newsize, const _Ty &_Val)
size_type	max_size () const _NOEXCEPT
bool	empty () const _NOEXCEPT
allocator_type	get_allocator () const _NOEXCEPT
reference	front ()
const_reference	front () const
void	push_front (const _Ty &_Val)
void	pop_front ()
template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, void >::type	assign (_Iter _First, _Iter _Last)
void	assign (_CRT_GUARDOVERFLOW size_type _Count, const _Ty &_Val)
iterator	insert_after (const_iterator _Where, const _Ty &_Val)
iterator	insert_after (const_iterator _Where, _CRT_GUARDOVERFLOW size_type _Count, const _Ty &_Val)
template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, iterator >::type	insert_after (const_iterator _Where, _Iter _First, _Iter _Last)
template<class _Iter >
iterator	_Insert_range (const_iterator _Where, _Iter _First, _Iter _Last, input_iterator_tag)
template<class _Iter >
iterator	_Insert_range (const_iterator _Where, _Iter _First, _Iter _Last, forward_iterator_tag)
iterator	erase_after (const_iterator _Where)
iterator	erase_after (const_iterator _First, const_iterator _Last)
void	clear () _NOEXCEPT
void	swap (_Myt &_Right) _NOEXCEPT_OP(_Alty
void	splice_after (const_iterator _Where, _Myt &_Right)
void	splice_after (const_iterator _Where, _Myt &&_Right)
void	splice_after (const_iterator _Where, _Myt &_Right, const_iterator _First)
void	splice_after (const_iterator _Where, _Myt &&_Right, const_iterator _First)
void	splice_after (const_iterator _Where, _Myt &_Right, const_iterator _First, const_iterator _Last)
void	splice_after (const_iterator _Where, _Myt &&_Right, const_iterator _First, const_iterator _Last)
void	remove (const _Ty &_Val)
template<class _Pr1 >
void	remove_if (_Pr1 _Pred)
template<class _Pr1 >
void	_Remove_if (_Pr1 &_Pred)
void	unique ()
template<class _Pr2 >
void	unique (_Pr2 _Pred)
void	merge (_Myt &_Right)
void	merge (_Myt &&_Right)
template<class _Pr2 >
void	merge (_Myt &_Right, _Pr2 _Pred)
template<class _Pr2 >
void	merge (_Myt &&_Right, _Pr2 _Pred)
template<class _Pr2 >
void	_Merge1 (_Myt &_Right, _Pr2 &&_Pred)
void	sort ()
template<class _Pr2 >
void	sort (_Pr2 _Pred)
template<class _Pr2 >
void	_Sort (iterator _Before_first, iterator _Last, _Pr2 &_Pred, size_type _Size)
void	reverse () _NOEXCEPT
Public Member Functions inherited from _Flist_buy< _Ty, _Alloc >
	_Flist_buy ()
template<class _Any_alloc , class = enable_if_t<!is_same<decay_t<_Any_alloc>, _Myt>::value>>
	_Flist_buy (_Any_alloc &&_Al)
_Nodeptr	_Buynode0 (_Nodeptr _Next)
template<class... _Valty>
_Nodeptr	_Buynode (_Nodeptr _Next, _Valty &&..._Val)
void	_Freenode (_Nodeptr _Pnode)
Public Member Functions inherited from _Flist_alloc< _Flist_base_types< _Ty, _Alloc > >
	_Flist_alloc ()
	_Flist_alloc (_Any_alloc &&_Al)
	~_Flist_alloc () _NOEXCEPT
void	_Copy_alloc (const _Alty &_Al)
void	_Move_alloc (_Alty &_Al)
void	_Orphan_all ()
void	_Swap_all (_Myt &_Right)
_Alty &	_Getal () _NOEXCEPT
const _Alty &	_Getal () const _NOEXCEPT
_Flist_val< _Val_types > &	_Get_data () _NOEXCEPT
const _Flist_val< _Val_types > &	_Get_data () const _NOEXCEPT
_Nodeptr &	_Myhead () _NOEXCEPT
const _Nodeptr &	_Myhead () const _NOEXCEPT
_Nodeptr	_Before_head () const _NOEXCEPT

Private Member Functions
size_type	_Size () const
const_iterator	_Before_end () const
void	_Splice_after (const_iterator _Where, _Myt &_Right, const_iterator _First, const_iterator _Last)
void	_Splice_same_after (const_iterator _Where, _Myt &_Right, const_iterator _First, const_iterator _Last)
void	_Tidy ()
iterator	_Insert_n_after (const_iterator _Where, size_type _Count, const _Ty &_Val)

Additional Inherited Members
Static Public Member Functions inherited from _Flist_alloc< _Flist_base_types< _Ty, _Alloc > >
static _Nodepref	_Nextnode (_Nodeptr _Pnode)
static reference	_Myval (_Nodeptr _Pnode)

Member Typedef Documentation

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::_Alty forward_list< _Ty, _Alloc >::_Alty

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Flist_buy<_Ty, _Alloc> forward_list< _Ty, _Alloc >::_Mybase

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef forward_list<_Ty, _Alloc> forward_list< _Ty, _Alloc >::_Myt

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::_Node forward_list< _Ty, _Alloc >::_Node

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::_Nodeptr forward_list< _Ty, _Alloc >::_Nodeptr

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Alloc forward_list< _Ty, _Alloc >::allocator_type

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::const_iterator forward_list< _Ty, _Alloc >::const_iterator

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::const_pointer forward_list< _Ty, _Alloc >::const_pointer

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::const_reference forward_list< _Ty, _Alloc >::const_reference

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::difference_type forward_list< _Ty, _Alloc >::difference_type

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::iterator forward_list< _Ty, _Alloc >::iterator

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::pointer forward_list< _Ty, _Alloc >::pointer

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::reference forward_list< _Ty, _Alloc >::reference

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::size_type forward_list< _Ty, _Alloc >::size_type

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::value_type forward_list< _Ty, _Alloc >::value_type

Constructor & Destructor Documentation

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::forward_list ( )

inline

        : _Mybase()
        {   // construct empty list
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::forward_list ( _CRT_GUARDOVERFLOW size_type  _Count, const _Alloc &  _Al = _Alloc()  )

inlineexplicit

        : _Mybase(_Al)
        {   // construct list from _Count * _Ty(), optional allocator
        resize(_Count);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::forward_list ( _CRT_GUARDOVERFLOW size_type  _Count, const _Ty &  _Val  )

inline

        : _Mybase()
        {   // construct list from _Count * _Val
        _Construct_n(_Count, _Val);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::forward_list ( _CRT_GUARDOVERFLOW size_type  _Count, const _Ty &  _Val, const _Alloc &  _Al  )

inline

        : _Mybase(_Al)
        {   // construct list from _Count * _Val, allocator
        _Construct_n(_Count, _Val);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::forward_list ( const _Alloc &  _Al )

inlineexplicit

        : _Mybase(_Al)
        {   // construct empty list, allocator
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::forward_list ( const _Myt &  _Right )

inline

        : _Mybase(_Right._Getal().select_on_container_copy_construction())
        {   // construct list by copying _Right
        _TRY_BEGIN
        insert_after(before_begin(), _Right.begin(), _Right.end());
        _CATCH_ALL
        _Tidy();
        _RERAISE;
        _CATCH_END
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::forward_list ( const _Myt &  _Right, const _Alloc &  _Al  )

inline

        : _Mybase(_Al)
        {   // construct list by copying _Right, allocator
        _TRY_BEGIN
        insert_after(before_begin(), _Right.begin(), _Right.end());
        _CATCH_ALL
        _Tidy();
        _RERAISE;
        _CATCH_END
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>

forward_list< _Ty, _Alloc >::forward_list ( _Iter  _First, _Iter  _Last  )

inline

        : _Mybase()
        {   // construct list from [_First, _Last,
        _Construct(_First, _Last);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>

forward_list< _Ty, _Alloc >::forward_list ( _Iter  _First, _Iter  _Last, const _Alloc &  _Al  )

inline

        : _Mybase(_Al)
        {   // construct list, allocator from [_First, _Last)
        _Construct(_First, _Last);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::forward_list ( _Myt &&  _Right )

inline

        : _Mybase(_STD move(_Right._Getal()))
        {   // construct list by moving _Right
        _Assign_rv(_STD move(_Right), true_type());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::forward_list ( _Myt &&  _Right, const _Alloc &  _Al  )

inline

        : _Mybase(_Al)
        {   // construct list by moving _Right, allocator
        _Assign_rv(_STD move(_Right), false_type());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::forward_list ( initializer_list< _Ty >  _Ilist, const _Alloc &  _Al = allocator_type()  )

inline

        : _Mybase(_Al)
        {   // construct from initializer_list
        insert_after(before_begin(), _Ilist.begin(), _Ilist.end());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

forward_list< _Ty, _Alloc >::~forward_list ( )

inline

        {   // destroy the object
        _Tidy();
        }

Member Function Documentation

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::_Assign_rv ( _Myt &&  _Right, true_type    )

inline

        {   // swap with empty *this, same allocator
        this->_Swap_all(_Right);
        _Swap_adl(this->_Myhead(), _Right._Myhead());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::_Assign_rv ( _Myt &&  _Right, false_type    )

inline

        {   // move from _Right, possibly moving its contents
        if (this->_Getal() == _Right._Getal())
            _Assign_rv(_STD move(_Right), true_type());
        else
            _Construct(_STD make_move_iterator(_Right.begin()),
                _STD make_move_iterator(_Right.end()));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator forward_list< _Ty, _Alloc >::_Before_end ( ) const

inlineprivate

        {   // get iterator just before end
        const_iterator _Next = before_begin();
        for (const_iterator _Nextp = _Next; ++_Nextp != end(); )
            _Next = _Nextp;
        return (_Next);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

void forward_list< _Ty, _Alloc >::_Construct ( _Iter  _First, _Iter  _Last  )

inline

        {   // construct list from [_First, _Last), input iterators
        _TRY_BEGIN
        insert_after(before_begin(), _First, _Last);
        _CATCH_ALL
        _Tidy();
        _RERAISE;
        _CATCH_END
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::_Construct_n ( size_type  _Count, const _Ty &  _Val  )

inline

        {   // construct from _Count * _Val
        _TRY_BEGIN
        _Insert_n_after(before_begin(), _Count, _Val);
        _CATCH_ALL
        _Tidy();
        _RERAISE;
        _CATCH_END
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class... _Valty>

void forward_list< _Ty, _Alloc >::_Insert_after ( const_iterator  _Where, _Valty &&...  _Val  )

inline

        {   // insert element after _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Where._Getcont() != _STD addressof(this->_Get_data()))
            {
            _DEBUG_ERROR("forward_list insert_after iterator outside range");
            }
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        _Nodeptr _Pnode = _Where._Mynode();
        _Nodeptr _Newnode =
            this->_Buynode(this->_Nextnode(_Pnode),
                _STD forward<_Valty>(_Val)...);
        this->_Nextnode(_Pnode) = _Newnode;
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::_Insert_n_after ( const_iterator  _Where, size_type  _Count, const _Ty &  _Val  )

inlineprivate

        {   // insert _Count * _Val after _Where
        size_type _Countsave = _Count;

        _TRY_BEGIN
        for (; 0 < _Count; --_Count, (void)++_Where)
            _Insert_after(_Where, _Val);
        _CATCH_ALL
        for (; _Count < _Countsave; ++_Count)
            erase_after(_Where);
        _RERAISE;
        _CATCH_END
        return (_Make_iter(_Where));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

iterator forward_list< _Ty, _Alloc >::_Insert_range ( const_iterator  _Where, _Iter  _First, _Iter  _Last, input_iterator_tag    )

inline

        {   // insert [_First, _Last) after _Where, input iterators
        size_type _Num = 0;
        const_iterator _After = _Where;

        _TRY_BEGIN
        for (; _First != _Last; ++_After, (void)++_First, ++_Num)
            _Insert_after(_After, *_First);
        _CATCH_ALL
        for (; 0 < _Num; --_Num)
            erase_after(_Where);
        _RERAISE;
        _CATCH_END
        return (_Make_iter(_After));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

iterator forward_list< _Ty, _Alloc >::_Insert_range ( const_iterator  _Where, _Iter  _First, _Iter  _Last, forward_iterator_tag    )

inline

        {   // insert [_First, _Last) after _Where, forward iterators
        _DEBUG_RANGE(_First, _Last);
        _Iter _Next = _First;
        const_iterator _After = _Where;

        _TRY_BEGIN
        for (; _First != _Last; ++_After, (void)++_First)
            _Insert_after(_After, *_First);
        _CATCH_ALL
        for (; _Next != _First; ++_Next)
            erase_after(_Where);
        _RERAISE;
        _CATCH_END
        return (_Make_iter(_After));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::_Make_iter ( const_iterator  _Where ) const

inline

        {   // make iterator from const_iterator
        return (iterator(_Where._Ptr, _STD addressof(this->_Get_data())));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Pr2 >

void forward_list< _Ty, _Alloc >::_Merge1 ( _Myt &  _Right, _Pr2 &&  _Pred  )

inline

        {   // merge in elements from _Right, both ordered by _Pred
        if (this != _STD addressof(_Right))
            {   // safe to merge, do it
            iterator _First1 = before_begin();
            iterator _After1 = begin();
            iterator _Last1 = end();
            iterator _First2 = _Right.before_begin();
            iterator _After2 = _Right.begin();
            iterator _Last2 = _Right.end();
            _DEBUG_ORDER_PRED(_After1, _Last1, _Pred);
            _DEBUG_ORDER_PRED(_After2, _Last2, _Pred);

            for (; _After1 != _Last1 && _After2 != _Last2; ++_First1)
                if (_DEBUG_LT_PRED(_Pred, *_After2, *_After1))
                    {   // splice in an element from _Right
                    iterator _Mid2 = _After2;
                    _Splice_after(_First1, _Right, _First2, ++_Mid2);
                    _After2 = _Mid2;
                    }
                else
                    ++_After1;

            if (_After2 != _Last2)
                _Splice_after(_First1, _Right, _First2,
                    _Last2);    // splice remainder of _Right
            }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Pr1 >

void forward_list< _Ty, _Alloc >::_Remove_if ( _Pr1 &  _Pred )

inline

        {   // erase each element satisfying _Pr1
        iterator _Firstb = before_begin();

        for (iterator _First = begin(); _First != end(); )
            if (_Pred(*_First))
                _First = erase_after(_Firstb);
            else
                {   // advance iterators
                ++_Firstb;
                ++_First;
                }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

size_type forward_list< _Ty, _Alloc >::_Size ( ) const

inlineprivate

        {   // get size by counting
        size_type _Ans = 0;
        for (const_iterator _Next = begin(); _Next != end(); ++_Next)
            ++_Ans;
        return (_Ans);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Pr2 >

void forward_list< _Ty, _Alloc >::_Sort ( iterator  _Before_first, iterator  _Last, _Pr2 &  _Pred, size_type  _Size  )

inline

        {   // order (_Before_first, _Last), using _Pred
            // _Size must be number of elements in range
        if (_Size < 2)
            return; // nothing to do

        iterator _Mid = _STD next(_Before_first, 1 + _Size / 2);
        _Sort(_Before_first, _Mid, _Pred, _Size / 2);
        iterator _First = _STD next(_Before_first);

        iterator _Before_mid = _STD next(_Before_first, _Size / 2);
        _Sort(_Before_mid, _Last, _Pred, _Size - _Size / 2);
        _Mid = _STD next(_Before_mid);

        for (; ; )
            {   // [_First, _Mid) and [_Mid, _Last) are sorted and non-empty
            if (_DEBUG_LT_PRED(_Pred, *_Mid, *_First))
                {   // consume _Mid
                splice_after(_Before_first, *this, _Before_mid);
                ++_Before_first;
                _Mid = _STD next(_Before_mid);
                if (_Mid == _Last)
                    return; // exhausted [_Mid, _Last); done
                }
            else
                {   // consume _First
                ++_Before_first;
                ++_First;
                if (_First == _Mid)
                    return; // exhausted [_First, _Mid); done
                }
            }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::_Splice_after ( const_iterator  _Where, _Myt &  _Right, const_iterator  _First, const_iterator  _Last  )

inlineprivate

        {   // splice _Right (_First, _Last) just after _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Where._Getcont() != _STD addressof(this->_Get_data()) || _Where == end())
            {
            _DEBUG_ERROR("forward_list splice_after iterator outside range");
            }

        if (this->_Getal() != _Right._Getal())
            {
            _DEBUG_ERROR("forward_list containers incompatible for splice_after");
            }

        if (this != _STD addressof(_Right))
            {   // transfer ownership of (_First, _Last)
            const_iterator _Next = _First;
            for (++_Next; _Next != _Last; )
                {   // transfer ownership
                const_iterator _Iter = _Next++;
                _Right._Orphan_ptr(_Iter._Ptr);
                _Iter._Adopt(_STD addressof(this->_Get_data()));
                }
            }

 #else /* _ITERATOR_DEBUG_LEVEL == 2 */
        if (this->_Getal() != _Right._Getal())
            _STD terminate();
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        _Splice_same_after(_Where, _Right, _First, _Last);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::_Splice_same_after ( const_iterator  _Where, _Myt &  _Right, const_iterator  _First, const_iterator  _Last  )

inlineprivate

        {   // splice _Right (_First, _Last) just after _Where
        const_iterator _Next = _First;
        const_iterator _After = _Next;
        for (++_After; _After != _Last; ++_Next, (void)++_After)
            if (_After == _Right.end())
                {   // find last element, and check for bad range
 #if _ITERATOR_DEBUG_LEVEL == 2
                _DEBUG_ERROR("forward_list splice_after invalid range");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

                return;
                }
        this->_Nextnode(_Next._Mynode()) =
            this->_Nextnode(_Where._Mynode());  // link last to new home
        this->_Nextnode(_Where._Mynode()) =
            this->_Nextnode(_First._Mynode());  // link first to new home
        this->_Nextnode(_First._Mynode()) =
            _Last._Mynode();    // drop range from old home
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::_Tidy ( )

inlineprivate

        {   // free all storage
        clear();
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::assign ( initializer_list< _Ty >  _Ilist )

inline

        {   // assign initializer_list
        assign(_Ilist.begin(), _Ilist.end());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

enable_if<_Is_iterator<_Iter>::value, void>::type forward_list< _Ty, _Alloc >::assign ( _Iter  _First, _Iter  _Last  )

inline

        {   // assign [_First, _Last), input iterators
        clear();
        insert_after(before_begin(), _First, _Last);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::assign ( _CRT_GUARDOVERFLOW size_type  _Count, const _Ty &  _Val  )

inline

        {   // assign _Count * _Val
        clear();
        _Insert_n_after(before_begin(), _Count, _Val);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::before_begin ( )

inline

        {   // return iterator before beginning of mutable sequence
        return (iterator(this->_Before_head(), _STD addressof(this->_Get_data())));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator forward_list< _Ty, _Alloc >::before_begin ( ) const

inline

        {   // return iterator before beginning of nonmutable sequence
        return (const_iterator(this->_Before_head(), _STD addressof(this->_Get_data())));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::begin ( )

inline

        {   // return iterator for beginning of mutable sequence
        return (iterator(this->_Myhead(), _STD addressof(this->_Get_data())));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator forward_list< _Ty, _Alloc >::begin ( ) const

inline

        {   // return iterator for beginning of nonmutable sequence
        return (const_iterator(this->_Myhead(), _STD addressof(this->_Get_data())));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator forward_list< _Ty, _Alloc >::cbefore_begin ( ) const

inline

        {   // return iterator before beginning of nonmutable sequence
        return (before_begin());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator forward_list< _Ty, _Alloc >::cbegin ( ) const

inline

        {   // return iterator for beginning of nonmutable sequence
        return (begin());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator forward_list< _Ty, _Alloc >::cend ( ) const

inline

        {   // return iterator for end of nonmutable sequence
        return (end());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::clear ( )

inline

        {   // erase all
 #if _ITERATOR_DEBUG_LEVEL == 2
        this->_Orphan_ptr(nullptr_t{});
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        _Nodeptr _Pnext;
        _Nodeptr _Pnode = this->_Myhead();
        this->_Myhead() = nullptr_t{};

        for (; _Pnode != nullptr_t{}; _Pnode = _Pnext)
            {   // delete an element
            _Pnext = this->_Nextnode(_Pnode);

            this->_Freenode(_Pnode);
            }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class... _Valty>

iterator forward_list< _Ty, _Alloc >::emplace_after ( const_iterator  _Where, _Valty &&...  _Val  )

inline

        {   // insert element at _Where
        _Insert_after(_Where, _STD forward<_Valty>(_Val)...);
        return (_Make_iter(++_Where));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class... _Valty>

void forward_list< _Ty, _Alloc >::emplace_front ( _Valty &&...  _Val )

inline

        {   // insert element at beginning
        _Insert_after(before_begin(), _STD forward<_Valty>(_Val)...);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

bool forward_list< _Ty, _Alloc >::empty ( ) const

inline

        {   // test if sequence is empty
        return (begin() == end());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::end ( )

inline

        {   // return iterator for end of mutable sequence
        return (iterator(nullptr_t{}, _STD addressof(this->_Get_data())));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator forward_list< _Ty, _Alloc >::end ( ) const

inline

        {   // return iterator for end of nonmutable sequence
        return (const_iterator(nullptr_t{}, _STD addressof(this->_Get_data())));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::erase_after ( const_iterator  _Where )

inline

        {   // erase element after _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Where._Getcont() != _STD addressof(this->_Get_data())
            || _Where == end())
            {
            _DEBUG_ERROR("forward_list erase_after iterator outside range");
            }

        _Nodeptr _Pnodeb = _Where._Mynode();
        _Orphan_ptr(this->_Nextnode(_Pnodeb));

 #else /* _ITERATOR_DEBUG_LEVEL == 2 */
        _Nodeptr _Pnodeb = _Where._Mynode();
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (++_Where == end())
            {
 #if _ITERATOR_DEBUG_LEVEL == 2
            _DEBUG_ERROR("forward_list erase_after iterator outside range");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
            }
        else
            {   // node exists, erase it
            _Nodeptr _Pnode = _Where._Mynode(); // subject node
            ++_Where;   // point past subject node

            this->_Nextnode(_Pnodeb) =
                this->_Nextnode(_Pnode);    // link past it

            this->_Freenode(_Pnode);
            }

        return (_Make_iter(_Where));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::erase_after ( const_iterator  _First, const_iterator  _Last  )

inline

        {   // erase (_First, _Last)
        if (_First == before_begin() && _Last == end())
            {   // erase all and return fresh iterator
            clear();
            return (end());
            }
        else
            {   // erase subrange
            if (_First == end() || _First == _Last)
                {
 #if _ITERATOR_DEBUG_LEVEL == 2
                _DEBUG_ERROR("forward_list invalid erase_after range");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
                }
            else
                {   // range not awful, try it
                const_iterator _After = _First;
                ++_After;
                _DEBUG_RANGE(_After, _Last);
                while (_After != _Last)
                    _After = erase_after(_First);
                }
            return (_Make_iter(_Last));
            }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

reference forward_list< _Ty, _Alloc >::front ( )

inline

        {   // return first element of mutable sequence
        return (*begin());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reference forward_list< _Ty, _Alloc >::front ( ) const

inline

        {   // return first element of nonmutable sequence
        return (*begin());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

allocator_type forward_list< _Ty, _Alloc >::get_allocator ( ) const

inline

        {   // return allocator object for values
        allocator_type _Ret(this->_Getal());
        return (_Ret);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::insert_after ( const_iterator  _Where, _Ty &&  _Val  )

inline

        {   // insert _Val at _Where
        return (emplace_after(_Where, _STD forward<_Ty>(_Val)));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::insert_after ( const_iterator  _Where, initializer_list< _Ty >  _Ilist  )

inline

        {   // insert initializer_list
        return (insert_after(_Where, _Ilist.begin(), _Ilist.end()));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::insert_after ( const_iterator  _Where, const _Ty &  _Val  )

inline

        {   // insert _Val at _Where
        _Insert_after(_Where, _Val);
        return (_Make_iter(++_Where));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator forward_list< _Ty, _Alloc >::insert_after ( const_iterator  _Where, _CRT_GUARDOVERFLOW size_type  _Count, const _Ty &  _Val  )

inline

        {   // insert _Count * _Val at _Where
        return (_Insert_n_after(_Where, _Count, _Val));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

enable_if<_Is_iterator<_Iter>::value, iterator>::type forward_list< _Ty, _Alloc >::insert_after ( const_iterator  _Where, _Iter  _First, _Iter  _Last  )

inline

        {   // insert [_First, _Last) at _Where
        return (_Insert_range(_Where, _First, _Last, _Iter_cat_t<_Iter>()));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

size_type forward_list< _Ty, _Alloc >::max_size ( ) const

inline

        {   // return maximum possible length of sequence
        return (this->_Getal().max_size());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::merge ( _Myt &  _Right )

inline

        {   // merge in elements from _Right, both ordered by operator<
        _Merge1(_Right, less<>());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::merge ( _Myt &&  _Right )

inline

        {   // merge in elements from _Right, both ordered by operator<
        _Merge1(_Right, less<>());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Pr2 >

void forward_list< _Ty, _Alloc >::merge ( _Myt &  _Right, _Pr2  _Pred  )

inline

        {   // merge in elements from _Right, both ordered by _Pred
        _Merge1(_Right, _Pred);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Pr2 >

void forward_list< _Ty, _Alloc >::merge ( _Myt &&  _Right, _Pr2  _Pred  )

inline

        {   // merge in elements from _Right, both ordered by _Pred
        _Merge1(_Right, _Pred);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

_Myt& forward_list< _Ty, _Alloc >::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        if (this != _STD addressof(_Right))
            {   // different, assign it
            clear();
            this->_Move_alloc(_Right._Getal());
            _Assign_rv(_STD move(_Right),
                typename _Alty::propagate_on_container_move_assignment());
            }
        return (*this);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

_Myt& forward_list< _Ty, _Alloc >::operator= ( initializer_list< _Ty >  _Ilist )

inline

        {   // assign initializer_list
        assign(_Ilist.begin(), _Ilist.end());
        return (*this);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

_Myt& forward_list< _Ty, _Alloc >::operator= ( const _Myt &  _Right )

inline

        {   // assign _Right
        if (this != _STD addressof(_Right))
            {   // different, assign it
#pragma warning(push)
#pragma warning(disable: 4127)  // conditional expression is constant
            if (_Alty::propagate_on_container_copy_assignment::value
                && this->_Getal() != _Right._Getal())
                {   // change allocator before copying
                clear();
                }
#pragma warning(pop)

            this->_Copy_alloc(_Right._Getal());

            assign(_Right.begin(), _Right.end());
            }
        return (*this);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::pop_front ( )

inline

        {   // erase element at beginning
        erase_after(before_begin());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::push_front ( _Ty &&  _Val )

inline

        {   // insert element at beginning
        _Insert_after(before_begin(), _STD forward<_Ty>(_Val));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::push_front ( const _Ty &  _Val )

inline

        {   // insert element at beginning
        _Insert_after(before_begin(), _Val);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::remove ( const _Ty &  _Val )

inline

        {   // erase each element matching _Val
        iterator _Firstb = before_begin();
        iterator _Val_it = end();

        for (iterator _First = begin(); _First != end(); )
            if (*_First == _Val)
                if (_STD addressof(*_First) == _STD addressof(_Val))
                    {   // store iterator to _Val and advance iterators
                    _Val_it = _Firstb;
                    ++_Firstb;
                    ++_First;
                    }
                else
                    _First = erase_after(_Firstb);
            else
                {   // advance iterators
                ++_Firstb;
                ++_First;
                }

        if (_Val_it != end())
            erase_after(_Val_it);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Pr1 >

void forward_list< _Ty, _Alloc >::remove_if ( _Pr1  _Pred )

inline

        {   // erase each element satisfying _Pr1
        _Remove_if(_Pred);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::resize ( _CRT_GUARDOVERFLOW size_type  _Newsize )

inline

        {   // determine new length, padding with _Ty() elements as needed
        size_type _Cursize = _Size();
        if (_Cursize < _Newsize)
            {   // pad to make larger
            const_iterator _Next = _Before_end();
            _TRY_BEGIN
            for (; _Cursize < _Newsize; ++_Cursize)
                _Insert_after(_Next);
            _CATCH_ALL
            erase_after(_Next, end());
            _RERAISE;
            _CATCH_END
            }
        else if (_Newsize < _Cursize)
            {   // erase all but _Newsize elements
            iterator _Next = before_begin();
            for (; 0 < _Newsize; --_Newsize)
                ++_Next;
            erase_after(_Next, end());
            }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::resize ( _CRT_GUARDOVERFLOW size_type  _Newsize, const _Ty &  _Val  )

inline

        {   // determine new length, padding with _Val elements as needed
        size_type _Cursize = _Size();
        if (_Cursize < _Newsize)
            _Insert_n_after(_Before_end(), _Newsize - _Cursize, _Val);
        else if (_Newsize < _Cursize)
            {   // erase all but _Newsize elements
            iterator _Next = before_begin();
            for (; 0 < _Newsize; --_Newsize)
                ++_Next;
            erase_after(_Next, end());
            }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::reverse ( )

inline

        {   // reverse sequence
        if (!empty())
            {   // worth doing, move to back in reverse order
            const_iterator _First = _Before_end();
            for (; begin() != _First; )
                _Splice_same_after(_First, *this, before_begin(), ++begin());
            }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::sort ( )

inline

        {   // order sequence, using operator<
        sort(less<>());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Pr2 >

void forward_list< _Ty, _Alloc >::sort ( _Pr2  _Pred )

inline

        {   // order sequence, using _Pred
        _Sort(before_begin(), end(), _Pred, _STD distance(begin(), end()));
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::splice_after ( const_iterator  _Where, _Myt &  _Right  )

inline

        {   // splice all of _Right after _Where
        if (this != _STD addressof(_Right) && !_Right.empty())
            {   // worth splicing, do it
            _Splice_after(_Where, _Right,
                _Right.before_begin(), _Right.end());
            }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::splice_after ( const_iterator  _Where, _Myt &&  _Right  )

inline

        {   // splice all of _Right at _Where
        splice_after(_Where, _Right);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::splice_after ( const_iterator  _Where, _Myt &  _Right, const_iterator  _First  )

inline

        {   // splice _Right (_First, _First + 2) after _Where
        const_iterator _After = _First;
        if (_First == _Right.end() || ++_After == _Right.end())
            {
 #if _ITERATOR_DEBUG_LEVEL == 2
            _DEBUG_ERROR("forward_list splice_after iterator outside range");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
            }
        else
            {   // element exists, try splice
            if (this != _STD addressof(_Right)
                || (_Where != _First && _Where != _After))
                _Splice_after(_Where, _Right, _First, ++_After);
            }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::splice_after ( const_iterator  _Where, _Myt &&  _Right, const_iterator  _First  )

inline

        {   // splice _Right [_First, _First + 1) at _Where
        splice_after(_Where, _Right, _First);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::splice_after ( const_iterator  _Where, _Myt &  _Right, const_iterator  _First, const_iterator  _Last  )

inline

        {   // splice _Right [_First, _Last) at _Where
        const_iterator _After = _First;
        if (_First == _Right.end())
            {
 #if _ITERATOR_DEBUG_LEVEL == 2
            _DEBUG_ERROR("forward_list splice_after iterator outside range");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
            }
        else if (++_After != _Last && (this != _STD addressof(_Right) || _Where != _First))
            _Splice_after(_Where, _Right, _First, _Last);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::splice_after ( const_iterator  _Where, _Myt &&  _Right, const_iterator  _First, const_iterator  _Last  )

inline

        {   // splice _Right [_First, _Last) at _Where
        splice_after(_Where, _Right, _First, _Last);
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::swap ( _Myt &  _Right )

inline

        {   // exchange contents with _Right
        if (this != _STD addressof(_Right))
            {   // (maybe) swap allocators, swap control information
            _Pocs(this->_Getal(), _Right._Getal());
            this->_Swap_all(_Right);
            _Swap_adl(this->_Myhead(), _Right._Myhead());
            }
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

void forward_list< _Ty, _Alloc >::unique ( )

inline

        {   // erase each element matching previous
        unique(equal_to<>());
        }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Pr2 >

void forward_list< _Ty, _Alloc >::unique ( _Pr2  _Pred )

inline

        {   // erase each element satisfying _Pred with previous
        iterator _First = begin();
        if (_First != end())
            {   // worth doing
            iterator _After = _First;
            for (++_After; _After != end(); )
                if (_Pred(*_First, *_After))
                    _After = erase_after(_First);
                else
                    _First = _After++;
            }
        }

---

The documentation for this class was generated from the following file:

• VS2017/inc/forward_list