STLdoc: list< _Ty, _Alloc > Class Template Reference

STLdoc

STLdocumentation

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

Inheritance diagram for list< _Ty, _Alloc >:

Public Types
typedef list< _Ty, _Alloc >	_Myt

typedef _List_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

typedef _Mybase::_Unchecked_const_iterator	_Unchecked_const_iterator

typedef _Mybase::_Unchecked_iterator	_Unchecked_iterator

typedef _STD reverse_iterator< iterator >	reverse_iterator

typedef _STD reverse_iterator< const_iterator >	const_reverse_iterator

Public Types inherited from _List_buy< _Ty, _Alloc >
typedef _List_buy< _Ty, _Alloc >	_Myt

typedef _List_alloc< _List_base_types< _Ty, _Alloc > >	_Mybase

typedef _Mybase::_Alty	_Alty

typedef _Mybase::_Nodeptr	_Nodeptr

Public Types inherited from _List_alloc< _List_base_types< _Ty, _Alloc > >
typedef _List_alloc< _List_base_types< _Ty, _Alloc > >	_Myt

typedef _List_base_types< _Ty, _Alloc >::_Alloc	_Alloc

typedef _List_base_types< _Ty, _Alloc >::_Alnod_type	_Alty

typedef _List_base_types< _Ty, _Alloc >::_Node	_Node

typedef _List_base_types< _Ty, _Alloc >::_Nodeptr	_Nodeptr

typedef _List_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 _List_const_iterator< _List_val< _Val_types > >	const_iterator

typedef _List_iterator< _List_val< _Val_types > >	iterator

typedef _List_unchecked_const_iterator< _List_val< _Val_types > >	_Unchecked_const_iterator

typedef _List_unchecked_iterator< _List_val< _Val_types > >	_Unchecked_iterator

Public Member Functions
	list ()

	list (const _Alloc &_Al)

	list (_CRT_GUARDOVERFLOW size_type _Count, const _Alloc &_Al=_Alloc())

	list (_CRT_GUARDOVERFLOW size_type _Count, const _Ty &_Val)

	list (_CRT_GUARDOVERFLOW size_type _Count, const _Ty &_Val, const _Alloc &_Al)

	list (const _Myt &_Right)

	list (const _Myt &_Right, const _Alloc &_Al)

template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>
	list (_Iter _First, _Iter _Last)

template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>
	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)

	list (_Myt &&_Right)

	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)

void	push_back (_Ty &&_Val)

iterator	insert (const_iterator _Where, _Ty &&_Val)

template<class... _Valty>
void	emplace_front (_Valty &&..._Val)

template<class... _Valty>
void	emplace_back (_Valty &&..._Val)

template<class... _Valty>
iterator	emplace (const_iterator _Where, _Valty &&..._Val)

template<class... _Valty>
void	_Insert (_Unchecked_const_iterator _Where, _Valty &&..._Val)

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

_Myt &	operator= (initializer_list< _Ty > _Ilist)

void	assign (initializer_list< _Ty > _Ilist)

iterator	insert (const_iterator _Where, initializer_list< _Ty > _Ilist)

	~list () _NOEXCEPT

_Myt &	operator= (const _Myt &_Right)

iterator	begin () _NOEXCEPT

const_iterator	begin () const _NOEXCEPT

iterator	end () _NOEXCEPT

const_iterator	end () const _NOEXCEPT

_Unchecked_iterator	_Unchecked_begin ()

_Unchecked_const_iterator	_Unchecked_begin () const

_Unchecked_iterator	_Unchecked_end ()

_Unchecked_const_iterator	_Unchecked_end () const

iterator	_Make_iter (const_iterator _Where) const _NOEXCEPT

iterator	_Make_iter (_Unchecked_const_iterator _Where) const

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

void	resize (_CRT_GUARDOVERFLOW size_type _Newsize)

void	resize (_CRT_GUARDOVERFLOW size_type _Newsize, const _Ty &_Val)

size_type	size () const _NOEXCEPT

size_type	max_size () const _NOEXCEPT

bool	empty () const _NOEXCEPT

allocator_type	get_allocator () const _NOEXCEPT

reference	front ()

const_reference	front () const

reference	back ()

const_reference	back () const

void	push_front (const _Ty &_Val)

void	pop_front ()

void	push_back (const _Ty &_Val)

void	pop_back ()

template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, void >::type	assign (_Iter _First, _Iter _Last)

template<class _TArg >
void	_Reusenode (iterator _Where, _TArg &&_Arg)

void	assign (_CRT_GUARDOVERFLOW size_type _Count, const _Ty &_Val)

iterator	insert (const_iterator _Where, const _Ty &_Val)

iterator	insert (const_iterator _Where, _CRT_GUARDOVERFLOW size_type _Count, const _Ty &_Val)

template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, iterator >::type	insert (const_iterator _Where, _Iter _First, _Iter _Last)

template<class _Iter >
void	_Insert_range (_Unchecked_const_iterator _Where, _Iter _First, _Iter _Last, input_iterator_tag)

template<class _Iter >
void	_Insert_range (_Unchecked_const_iterator _Where, _Iter _First, _Iter _Last, forward_iterator_tag)

_Nodeptr	_Unlinknode (const_iterator _Where)

iterator	erase (const_iterator _Where)

void	_Unchecked_erase (_Unchecked_const_iterator _Where)

iterator	erase (const_iterator _First, const_iterator _Last)

void	clear () _NOEXCEPT

void	swap (_Myt &_Right) _NOEXCEPT_OP(_Alty

void	splice (const_iterator _Where, _Myt &_Right)

void	splice (const_iterator _Where, _Myt &&_Right)

void	splice (const_iterator _Where, _Myt &_Right, const_iterator _First)

void	splice (const_iterator _Where, _Myt &&_Right, const_iterator _First)

void	splice (const_iterator _Where, _Myt &_Right, const_iterator _First, const_iterator _Last)

void	splice (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 >
iterator	_Sort (iterator _First, iterator _Last, _Pr2 &_Pred, size_type _Size)

void	reverse () _NOEXCEPT

void	_Splice (const_iterator _Where, _Myt &_Right, const_iterator _First, const_iterator _Last, size_type _Count)

void	_Splice_same (const_iterator _Where, _Myt &_Right, const_iterator _First, const_iterator _Last, size_type _Count)

void	_Unchecked_splice (_Unchecked_const_iterator _Where, _Unchecked_const_iterator _First, _Unchecked_const_iterator _Last)

void	_Tidy ()

void	_Insert_n (_Unchecked_const_iterator _Where, size_type _Count, const _Ty &_Val)

void	_Incsize (size_type _Count)

Public Member Functions inherited from _List_buy< _Ty, _Alloc >
	_List_buy ()

template<class _Any_alloc , class = enable_if_t<!is_same<decay_t<_Any_alloc>, _Myt>::value>>
	_List_buy (_Any_alloc &&_Al)

template<class... _Valty>
_Nodeptr	_Buynode (_Nodeptr _Next, _Nodeptr _Prev, _Valty &&..._Val)

void	_Freenode (_Nodeptr _Pnode)

Public Member Functions inherited from _List_alloc< _List_base_types< _Ty, _Alloc > >
	_List_alloc ()

	_List_alloc (_Any_alloc &&_Al)

	~_List_alloc () _NOEXCEPT

void	_Alloc_proxy ()

void	_Free_proxy ()

void	_Copy_alloc (const _Alty &_Al)

void	_Move_alloc (_Alty &_Al)

_Nodeptr	_Buyheadnode ()

void	_Freeheadnode (_Nodeptr _Pnode)

_Nodeptr	_Buynode0 (_Nodeptr _Next, _Nodeptr _Prev)

void	_Orphan_all ()

void	_Swap_all (_Myt &_Right)

_Alty &	_Getal () _NOEXCEPT

const _Alty &	_Getal () const _NOEXCEPT

_List_val< _Val_types > &	_Get_data () _NOEXCEPT

const _List_val< _Val_types > &	_Get_data () const _NOEXCEPT

_Nodeptr &	_Myhead () _NOEXCEPT

const _Nodeptr &	_Myhead () const _NOEXCEPT

size_type &	_Mysize () _NOEXCEPT

const size_type &	_Mysize () const _NOEXCEPT

Additional Inherited Members
Static Public Member Functions inherited from _List_alloc< _List_base_types< _Ty, _Alloc > >
static _Nodepref	_Nextnode (_Nodeptr _Pnode)

static _Nodepref	_Prevnode (_Nodeptr _Pnode)

static reference	_Myval (_Nodeptr _Pnode)

Member Typedef Documentation

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

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

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

typedef _List_buy<_Ty, _Alloc> list< _Ty, _Alloc >::_Mybase

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

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

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

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

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

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

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

typedef _Mybase::_Unchecked_const_iterator list< _Ty, _Alloc >::_Unchecked_const_iterator

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

typedef _Mybase::_Unchecked_iterator list< _Ty, _Alloc >::_Unchecked_iterator

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

typedef _Alloc list< _Ty, _Alloc >::allocator_type

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

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

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

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

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

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

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

typedef _STD reverse_iterator<const_iterator> list< _Ty, _Alloc >::const_reverse_iterator

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

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

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

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

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

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

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

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

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

typedef _STD reverse_iterator<iterator> list< _Ty, _Alloc >::reverse_iterator

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

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

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

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

Constructor & Destructor Documentation

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

list< _Ty, _Alloc >::list ( )

inline

         : _Mybase()
         {   // construct empty list
         }

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

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

inlineexplicit

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

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

list< _Ty, _Alloc >::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>>

list< _Ty, _Alloc >::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>>

list< _Ty, _Alloc >::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>>

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

inline

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

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

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

inline

         : _Mybase(_Al)
         {   // construct list by copying _Right, allocator
         _TRY_BEGIN
         insert(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>

list< _Ty, _Alloc >::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>

list< _Ty, _Alloc >::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>>

list< _Ty, _Alloc >::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>>

list< _Ty, _Alloc >::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>>

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

inline

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

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

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

inline

         {   // destroy the object
         _Tidy();
         }

Member Function Documentation

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

void 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());
         _STD swap(this->_Mysize(), _Right._Mysize());
         }

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

void 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>>

template<class _Iter >

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

inline

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

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

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

inline

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

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

void list< _Ty, _Alloc >::_Incsize ( size_type _Count )

inline

         {   // alter element count, with checking
         if (max_size() - this->_Mysize() - 1 < _Count)
             _Xlength_error("list<T> too long");
         this->_Mysize() += _Count;
         }

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

template<class... _Valty>

void list< _Ty, _Alloc >::_Insert	(	_Unchecked_const_iterator	_Where,
		_Valty &&...	_Val
	)

inline

         {   // insert element at _Where
         _Nodeptr _Pnode = _Where._Mynode();
         _Nodeptr _Newnode =
             this->_Buynode(_Pnode, this->_Prevnode(_Pnode),
                 _STD forward<_Valty>(_Val)...);
         _Incsize(1);
         this->_Prevnode(_Pnode) = _Newnode;
         this->_Nextnode(this->_Prevnode(_Newnode)) = _Newnode;
         }

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

void list< _Ty, _Alloc >::_Insert_n	(	_Unchecked_const_iterator	_Where,
		size_type	_Count,
		const _Ty &	_Val
	)

inline

         {   // insert _Count * _Val at _Where
         size_type _Countsave = _Count;
 
         _TRY_BEGIN
         for (; 0 < _Count; --_Count)
             _Insert(_Where, _Val);
         _CATCH_ALL
         for (; _Count < _Countsave; ++_Count)
             {   // undo inserts
             _Unchecked_const_iterator _Before = _Where;
             _Unchecked_erase(--_Before);
             }
         _RERAISE;
         _CATCH_END
         }

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

template<class _Iter >

void list< _Ty, _Alloc >::_Insert_range	(	_Unchecked_const_iterator	_Where,
		_Iter	_First,
		_Iter	_Last,
		input_iterator_tag
	)

inline

         {   // insert [_First, _Last) at _Where, input iterators
         size_type _Num = 0;
 
         _TRY_BEGIN
         for (; _First != _Last; ++_First, (void)++_Num)
             _Insert(_Where, *_First);
         _CATCH_ALL
         for (; 0 < _Num; --_Num)
             {   // undo inserts
             _Unchecked_const_iterator _Before = _Where;
             _Unchecked_erase(--_Before);
             }
         _RERAISE;
         _CATCH_END
         }

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

template<class _Iter >

void list< _Ty, _Alloc >::_Insert_range	(	_Unchecked_const_iterator	_Where,
		_Iter	_First,
		_Iter	_Last,
		forward_iterator_tag
	)

inline

         {   // insert [_First, _Last) at _Where, forward iterators
         _DEBUG_RANGE(_First, _Last);
         _Iter _Next = _First;
 
         _TRY_BEGIN
         for (; _First != _Last; ++_First)
             _Insert(_Where, *_First);
         _CATCH_ALL
         for (; _Next != _First; ++_Next)
             {   // undo inserts
             _Unchecked_const_iterator _Before = _Where;
             _Unchecked_erase(--_Before);
             }
         _RERAISE;
         _CATCH_END
         }

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

iterator 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>>

iterator list< _Ty, _Alloc >::_Make_iter ( _Unchecked_const_iterator _Where ) const

inline

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

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

template<class _Pr2 >

void 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 = begin(), _Last1 = end();
             iterator _First2 = _Right.begin(), _Last2 = _Right.end();
             _DEBUG_ORDER_PRED(_First1, _Last1, _Pred);
             _DEBUG_ORDER_PRED(_First2, _Last2, _Pred);
 
             while (_First1 != _Last1 && _First2 != _Last2)
                 if (_DEBUG_LT_PRED(_Pred, *_First2, *_First1))
                     {   // splice in an element from _Right
                     iterator _Mid2 = _First2;
                     _Splice(_First1, _Right, _First2, ++_Mid2, 1);
                     _First2 = _Mid2;
                     }
                 else
                     ++_First1;
 
             if (_First2 != _Last2)
                 _Splice(_Last1, _Right, _First2, _Last2,
                     _Right._Mysize());  // splice remainder of _Right
             }
         }

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

template<class _Pr1 >

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

inline

         {   // erase each element satisfying _Pred
         for (iterator _First = begin(); _First != end(); )
             if (_Pred(*_First))
                 _First = erase(_First);
             else
                 ++_First;
         }

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

template<class _TArg >

void list< _Ty, _Alloc >::_Reusenode	(	iterator	_Where,
		_TArg &&	_Arg
	)

inline

         {   // destroy the element at _Where and reconstruct from _Arg
         _TRY_BEGIN
         this->_Getal().destroy(
             _STD addressof(this->_Myval(_Where._Ptr)));
         this->_Getal().construct(
             _STD addressof(this->_Myval(_Where._Ptr)),
             _STD forward<_TArg>(_Arg));
         _CATCH_ALL
         _Unlinknode(_Where);
         this->_Getal().destroy(
             _STD addressof(this->_Nextnode(_Where._Ptr)));
         this->_Getal().destroy(
             _STD addressof(this->_Prevnode(_Where._Ptr)));
         this->_Getal().deallocate(_Where._Ptr, 1);
         _RERAISE;
         _CATCH_END
         }

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

template<class _Pr2 >

iterator list< _Ty, _Alloc >::_Sort	(	iterator	_First,
		iterator	_Last,
		_Pr2 &	_Pred,
		size_type	_Size
	)

inline

         {   // order [_First, _Last), using _Pred, return new first
             // _Size must be distance from _First to _Last
         if (_Size < 2)
             return (_First);    // nothing to do
 
         iterator _Mid = _STD next(_First, _Size / 2);
         _First = _Sort(_First, _Mid, _Pred, _Size / 2);
         _Mid = _Sort(_Mid, _Last, _Pred, _Size - _Size / 2);
         iterator _Newfirst = _First;
 
         for (bool _Initial_loop = true; ; _Initial_loop = false)
             {   // [_First, _Mid) and [_Mid, _Last) are sorted and non-empty
             if (_DEBUG_LT_PRED(_Pred, *_Mid, *_First))
                 {   // consume _Mid
                 if (_Initial_loop)
                     _Newfirst = _Mid;   // update return value
                 splice(_First, *this, _Mid++);
                 if (_Mid == _Last)
                     return (_Newfirst); // exhausted [_Mid, _Last); done
                 }
             else
                 {   // consume _First
                 ++_First;
                 if (_First == _Mid)
                     return (_Newfirst); // exhausted [_First, _Mid); done
                 }
             }
         }

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

void list< _Ty, _Alloc >::_Splice	(	const_iterator	_Where,
		_Myt &	_Right,
		const_iterator	_First,
		const_iterator	_Last,
		size_type	_Count
	)

inline

         {   // splice _Right [_First, _Last) before _Where
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Where._Getcont() != _STD addressof(this->_Get_data()))
             {
             _DEBUG_ERROR("list splice iterator outside range");
             }
 
         if (this->_Getal() != _Right._Getal())
             {
             _DEBUG_ERROR("list containers incompatible for splice");
             }
 
         if (this != _STD addressof(_Right))
             {   // transfer ownership
             _Lockit _Lock(_LOCK_DEBUG);
 
             const bool _One = _Count == 1;
             const bool _All = !_One && _Count == _Right.size();
             const bool _Some = !_One && !_All;
 
             _Nodeptr _Oldprev = this->_Prevnode(_First._Ptr);
 
             if (_Some)
                 for (_Nodeptr _Ptr = _First._Ptr; _Ptr != _Last._Ptr;
                     _Ptr = this->_Nextnode(_Ptr))
                     {   // mark _Prev pointers
                     this->_Prevnode(_Ptr) = nullptr_t{};
                     }
 
             const_iterator **_Pnext = (const_iterator **)_Right._Getpfirst();
 
             if (_Pnext == 0)
                 {
                 _DEBUG_ERROR("list container corrupted");
                 }
 
             while (*_Pnext != 0)
                 {   // check the iterator
                 const_iterator& _Iter = **_Pnext;
 
                 if ((_One && _Iter._Ptr == _First._Ptr)
                     || (_All && _Iter._Ptr != _Right._Myhead())
                     || (_Some && this->_Prevnode(_Iter._Ptr) == nullptr_t{}))
                     {   // adopt the iterator
                     *_Pnext = (const_iterator *)_Iter._Mynextiter;
                     _Iter._Myproxy = this->_Myproxy();
                     _Iter._Mynextiter = this->_Myproxy()->_Myfirstiter;
                     this->_Myproxy()->_Myfirstiter = _STD addressof(_Iter);
                     }
                 else
                     {   // skip the iterator
                     _Pnext = (const_iterator **)_Iter._Getpnext();
                     }
                 }
 
             if (_Some)
                 for (_Nodeptr _Ptr = _First._Ptr; _Ptr != _Last._Ptr;
                     _Ptr = this->_Nextnode(_Ptr))
                     {   // restore _Prev pointers
                     this->_Prevnode(_Ptr) = _Oldprev;
                     _Oldprev = _Ptr;
                     }
             }
 
  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
         if (this->_Getal() != _Right._Getal())
             _STD terminate();
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         _Splice_same(_Where, _Right, _First, _Last, _Count);
         }

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

void list< _Ty, _Alloc >::_Splice_same	(	const_iterator	_Where,
		_Myt &	_Right,
		const_iterator	_First,
		const_iterator	_Last,
		size_type	_Count
	)

inline

         {   // splice _Right [_First, _Last) before _Where
         if (this != _STD addressof(_Right))
             {   // splicing from another list, adjust counts
             _Incsize(_Count);
             _Right._Mysize() -= _Count;
             }
         this->_Nextnode(this->_Prevnode(_First._Mynode())) =
             _Last._Mynode();
         this->_Nextnode(this->_Prevnode(_Last._Mynode())) =
             _Where._Mynode();
         this->_Nextnode(this->_Prevnode(_Where._Mynode())) =
             _First._Mynode();
 
         _Nodeptr _Pnode = this->_Prevnode(_Where._Mynode());
         this->_Prevnode(_Where._Mynode()) =
             this->_Prevnode(_Last._Mynode());
         this->_Prevnode(_Last._Mynode()) =
             this->_Prevnode(_First._Mynode());
         this->_Prevnode(_First._Mynode()) = _Pnode;
         }

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

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

inline

         {   // free all storage
         clear();
         }

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

_Unchecked_iterator list< _Ty, _Alloc >::_Unchecked_begin ( )

inline

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

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

_Unchecked_const_iterator list< _Ty, _Alloc >::_Unchecked_begin ( ) const

inline

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

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

_Unchecked_iterator list< _Ty, _Alloc >::_Unchecked_end ( )

inline

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

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

_Unchecked_const_iterator list< _Ty, _Alloc >::_Unchecked_end ( ) const

inline

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

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

void list< _Ty, _Alloc >::_Unchecked_erase ( _Unchecked_const_iterator _Where )

inline

         {   // erase element at _Where
         _Nodeptr _Pnode = _Where._Mynode();
 
         this->_Nextnode(this->_Prevnode(_Pnode)) =
             this->_Nextnode(_Pnode);
         this->_Prevnode(this->_Nextnode(_Pnode)) =
             this->_Prevnode(_Pnode);
         this->_Freenode(_Pnode);
         --this->_Mysize();
         }

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

void list< _Ty, _Alloc >::_Unchecked_splice	(	_Unchecked_const_iterator	_Where,
		_Unchecked_const_iterator	_First,
		_Unchecked_const_iterator	_Last
	)

inline

         {   // splice [_First, _Last) before _Where
         this->_Nextnode(this->_Prevnode(_First._Mynode())) =
             _Last._Mynode();
         this->_Nextnode(this->_Prevnode(_Last._Mynode())) =
             _Where._Mynode();
         this->_Nextnode(this->_Prevnode(_Where._Mynode())) =
             _First._Mynode();
 
         _Nodeptr _Pnode = this->_Prevnode(_Where._Mynode());
         this->_Prevnode(_Where._Mynode()) =
             this->_Prevnode(_Last._Mynode());
         this->_Prevnode(_Last._Mynode()) =
             this->_Prevnode(_First._Mynode());
         this->_Prevnode(_First._Mynode()) = _Pnode;
         }

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

_Nodeptr list< _Ty, _Alloc >::_Unlinknode ( const_iterator _Where )

inline

         {   // unlink node at _Where from the list
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Where._Getcont() != _STD addressof(this->_Get_data())
             || _Where._Ptr == this->_Myhead())
             {
             _DEBUG_ERROR("list erase iterator outside range");
             }
 
         _Nodeptr _Pnode = (_Where)._Mynode();
         _Orphan_ptr(_Pnode);
 
  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
         _Nodeptr _Pnode = (_Where)._Mynode();
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         this->_Nextnode(this->_Prevnode(_Pnode)) =
             this->_Nextnode(_Pnode);
         this->_Prevnode(this->_Nextnode(_Pnode)) =
             this->_Prevnode(_Pnode);
 
         --this->_Mysize();
         return (_Pnode);
         }

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

void 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 list< _Ty, _Alloc >::assign	(	_Iter	_First,
		_Iter	_Last
	)

inline

         {   // assign [_First, _Last), input iterators
         iterator _Old = begin();
         _TRY_BEGIN
         for (; _First != _Last && _Old != end(); ++_First, (void)++_Old)
             _Reusenode(_Old, *_First);
         for (; _First != _Last; ++_First)
             _Insert(_Unchecked_end(), *_First);
         _CATCH_ALL
         clear();
         _RERAISE;
         _CATCH_END
         erase(_Old, end());
         }

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

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

inline

         {   // assign _Count * _Val
         clear();
         _Insert_n(_Unchecked_begin(), _Count, _Val);
         }

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

reference list< _Ty, _Alloc >::back ( )

inline

         {   // return last element of mutable sequence
         return (*(--end()));
         }

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

const_reference list< _Ty, _Alloc >::back ( ) const

inline

         {   // return last element of nonmutable sequence
         return (*(--end()));
         }

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

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

inline

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

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

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

inline

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

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

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

inline

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

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

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

inline

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

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

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

inline

         {   // erase all
  #if _ITERATOR_DEBUG_LEVEL == 2
 
         this->_Orphan_ptr(nullptr);
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
         _Nodeptr _Pnode = this->_Nextnode(this->_Myhead());
         this->_Nextnode(this->_Myhead()) = this->_Myhead();
         this->_Prevnode(this->_Myhead()) = this->_Myhead();
         this->_Mysize() = 0;
 
         for (_Nodeptr _Pnext; _Pnode != this->_Myhead(); _Pnode = _Pnext)
             {   // delete an element
             _Pnext = this->_Nextnode(_Pnode);
             this->_Freenode(_Pnode);
             }
         }

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

const_reverse_iterator list< _Ty, _Alloc >::crbegin ( ) const

inline

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

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

const_reverse_iterator list< _Ty, _Alloc >::crend ( ) const

inline

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

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

template<class... _Valty>

iterator list< _Ty, _Alloc >::emplace	(	const_iterator	_Where,
		_Valty &&...	_Val
	)

inline

         {   // insert element at _Where
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Where._Getcont() != _STD addressof(this->_Get_data()))
             {
             _DEBUG_ERROR("list emplace iterator outside range");
             }
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         _Insert(_Where._Unchecked(), _STD forward<_Valty>(_Val)...);
         return (_Make_iter(--_Where));
         }

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

template<class... _Valty>

void list< _Ty, _Alloc >::emplace_back ( _Valty &&... _Val )

inline

         {   // insert element at end
         _Insert(_Unchecked_end(), _STD forward<_Valty>(_Val)...);
         }

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

template<class... _Valty>

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

inline

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

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

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

inline

         {   // test if sequence is empty
         return (this->_Mysize() == 0);
         }

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

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

inline

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

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

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

inline

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

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

iterator list< _Ty, _Alloc >::erase ( const_iterator _Where )

inline

         {   // erase element at _Where
         _Nodeptr _Pnode = _Unlinknode(_Where++);
         this->_Freenode(_Pnode);
         return (_Make_iter(_Where));
         }

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

iterator list< _Ty, _Alloc >::erase	(	const_iterator	_First,
		const_iterator	_Last
	)

inline

         {   // erase [_First, _Last)
         if (_First == begin() && _Last == end())
             {   // erase all and return fresh iterator
             clear();
             return (end());
             }
         else
             {   // erase subrange
             while (_First != _Last)
                 _First = erase(_First);
             return (_Make_iter(_Last));
             }
         }

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

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

inline

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

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

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

inline

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

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

allocator_type 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 list< _Ty, _Alloc >::insert	(	const_iterator	_Where,
		_Ty &&	_Val
	)

inline

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

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

iterator list< _Ty, _Alloc >::insert	(	const_iterator	_Where,
		initializer_list< _Ty >	_Ilist
	)

inline

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

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

iterator list< _Ty, _Alloc >::insert	(	const_iterator	_Where,
		const _Ty &	_Val
	)

inline

         {   // insert _Val at _Where
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Where._Getcont() != _STD addressof(this->_Get_data()))
             {
             _DEBUG_ERROR("list insert iterator outside range");
             }
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         _Insert(_Where._Unchecked(), _Val);
         return (_Make_iter(--_Where));
         }

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

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

inline

         {   // insert _Count * _Val at _Where
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Where._Getcont() != _STD addressof(this->_Get_data()))
             {
             _DEBUG_ERROR("list insert iterator outside range");
             }
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         iterator _Prev = _Make_iter(_Where);
         if (_Prev == begin())
             {   // insert sequence at beginning
             _Insert_n(_Where._Unchecked(), _Count, _Val);
             return (begin());
             }
         else
             {   // insert sequence not at beginning
             --_Prev;
             _Insert_n(_Where._Unchecked(), _Count, _Val);
             return (++_Prev);
             }
         }

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

template<class _Iter >

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

inline

         {   // insert [_First, _Last) at _Where
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Where._Getcont() != _STD addressof(this->_Get_data()))
             {
             _DEBUG_ERROR("list insert iterator outside range");
             }
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         iterator _Prev = _Make_iter(_Where);
         if (_Prev == begin())
             {   // insert sequence at beginning
             _Insert_range(_Where._Unchecked(), _First, _Last,
                 _Iter_cat_t<_Iter>());
             return (begin());
             }
         else
             {   // insert sequence not at beginning
             --_Prev;
             _Insert_range(_Where._Unchecked(), _First, _Last,
                 _Iter_cat_t<_Iter>());
             return (++_Prev);
             }
         }

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

size_type 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 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 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 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 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& 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& 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& 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 list< _Ty, _Alloc >::pop_back ( )

inline

         {   // erase element at end
         erase(--end());
         }

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

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

inline

         {   // erase element at beginning
         erase(begin());
         }

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

void list< _Ty, _Alloc >::push_back ( _Ty && _Val )

inline

         {   // insert element at end
         _Insert(_Unchecked_end(), _STD forward<_Ty>(_Val));
         }

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

void list< _Ty, _Alloc >::push_back ( const _Ty & _Val )

inline

         {   // insert element at end
         _Insert(_Unchecked_end(), _Val);
         }

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

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

inline

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

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

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

inline

         {   // insert element at beginning
         _Insert(_Unchecked_begin(), _Val);
         }

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

reverse_iterator list< _Ty, _Alloc >::rbegin ( )

inline

         {   // return iterator for beginning of reversed mutable sequence
         return (reverse_iterator(end()));
         }

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

const_reverse_iterator list< _Ty, _Alloc >::rbegin ( ) const

inline

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

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

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

inline

         {   // erase each element matching _Val
         iterator _Val_it = end();
 
         for (iterator _First = begin(); _First != end(); )
             if (*_First == _Val)
                 if (_STD addressof(*_First) == _STD addressof(_Val))
                     _Val_it = _First++;
                 else
                     _First = erase(_First);
             else
                 ++_First;
 
         if (_Val_it != end())
             erase(_Val_it);
         }

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

template<class _Pr1 >

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

inline

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

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

reverse_iterator list< _Ty, _Alloc >::rend ( )

inline

         {   // return iterator for end of reversed mutable sequence
         return (reverse_iterator(begin()));
         }

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

const_reverse_iterator list< _Ty, _Alloc >::rend ( ) const

inline

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

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

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

inline

         {   // determine new length, padding with _Ty() elements as needed
         if (this->_Mysize() < _Newsize)
             {   // pad to make larger
             size_type _Count = 0;
             _TRY_BEGIN
             for (; this->_Mysize() < _Newsize; ++_Count)
                 _Insert(_Unchecked_end());
             _CATCH_ALL
             for (; 0 < _Count; --_Count)
                 pop_back(); // undo inserts
             _RERAISE;
             _CATCH_END
             }
         else
             while (_Newsize < this->_Mysize())
                 pop_back();
         }

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

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

inline

         {   // determine new length, padding with _Val elements as needed
         if (this->_Mysize() < _Newsize)
             _Insert_n(_Unchecked_end(), _Newsize - this->_Mysize(), _Val);
         else
             while (_Newsize < this->_Mysize())
                 pop_back();
         }

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

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

inline

         {   // reverse sequence
         const _Nodeptr _Phead = this->_Myhead();
         _Nodeptr _Pnode = _Phead;
 
         for (; ; )
             {   // flip pointers in a node
             const _Nodeptr _Pnext = this->_Nextnode(_Pnode);
             this->_Nextnode(_Pnode) = this->_Prevnode(_Pnode);
             this->_Prevnode(_Pnode) = _Pnext;
 
             if (_Pnext == _Phead)
                 break;
             _Pnode = _Pnext;
             }
         }

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

size_type list< _Ty, _Alloc >::size ( ) const

inline

         {   // return length of sequence
         return (this->_Mysize());
         }

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

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

inline

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

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

template<class _Pr2 >

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

inline

         {   // order sequence, using _Pred
         _Sort(begin(), end(), _Pred, this->_Mysize());
         }

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

void list< _Ty, _Alloc >::splice	(	const_iterator	_Where,
		_Myt &	_Right
	)

inline

         {   // splice all of _Right at _Where
         if (this != _STD addressof(_Right) && !_Right.empty())
             {   // worth splicing, do it
             _Splice(_Where, _Right, _Right.begin(), _Right.end(),
                 _Right._Mysize());
             }
         }

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

void list< _Ty, _Alloc >::splice	(	const_iterator	_Where,
		_Myt &&	_Right
	)

inline

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

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

void list< _Ty, _Alloc >::splice	(	const_iterator	_Where,
		_Myt &	_Right,
		const_iterator	_First
	)

inline

         {   // splice _Right [_First, _First + 1) at _Where
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_First == _Right.end())
             {
             _DEBUG_ERROR("list splice iterator outside range");
             }
         else
 
  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
         if (_First != _Right.end())
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
             {   // element exists, try splice
             const_iterator _Last = _First;
             ++_Last;
             if (this != _STD addressof(_Right)
                 || (_Where != _First && _Where != _Last))
                 _Splice(_Where, _Right, _First, _Last, 1);
             }
         }

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

void list< _Ty, _Alloc >::splice	(	const_iterator	_Where,
		_Myt &&	_Right,
		const_iterator	_First
	)

inline

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

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

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

inline

         {   // splice _Right [_First, _Last) at _Where
         if (_First != _Last && (this != _STD addressof(_Right) || _Where != _Last))
             {   // worth splicing, do it
             size_type _Count = 0;
 
             if (this == _STD addressof(_Right))
                 ;   // just rearrange this list
             else if (_First == _Right.begin() && _Last == _Right.end())
                 _Count = _Right._Mysize();  // splice in whole list
             else
                 {   // count nodes and check for knot
                 const_iterator _Next = _First;
 
                 for (; _Next != _Last; ++_Next, (void)++_Count)
                     if (_Next == _Right.end())
                         _Xlength_error("list<T> bad splice");
                 }
             _Splice(_Where, _Right, _First, _Last, _Count);
             }
         }

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

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

inline

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

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

void 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());
             _STD swap(this->_Mysize(), _Right._Mysize());
             }
         }

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

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

inline

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

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

template<class _Pr2 >

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

inline

         {   // erase each element satisfying _Pred with previous
         const _Nodeptr _Phead = this->_Myhead();
         _Nodeptr _Pprev = this->_Nextnode(_Phead);
         _Nodeptr _Pnode = this->_Nextnode(_Pprev);
 
         while (_Pnode != _Phead)
             if (_Pred(_Pprev->_Myval, _Pnode->_Myval))
                 {   // match, remove it
                 const _Nodeptr _Perase = _Pnode;
                 _Pnode = this->_Nextnode(_Pnode);
 
                 this->_Nextnode(_Pprev) = _Pnode;
                 this->_Prevnode(_Pnode) = _Pprev;
                 this->_Freenode(_Perase);
 
                 --this->_Mysize();
                 }
             else
                 {   // no match, advance
                 _Pprev = _Pnode;
                 _Pnode = this->_Nextnode(_Pnode);
                 }
         }

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

VS2017/inc/list