Inheritance diagram for deque< _Ty, _Alloc >:

Public Types
enum	{ _EEN_DS = _DEQUESIZ }

typedef deque< _Ty, _Alloc >	_Myt

typedef _Deque_alloc<!is_empty< _Alloc >::value, _Deque_base_types< _Ty, _Alloc > >	_Mybase

typedef _Alloc	allocator_type

typedef _Mybase::_Alty	_Alty

typedef _Mybase::_Alpty	_Alpty

typedef _Mybase::_Mapptr	_Mapptr

typedef _Mybase::value_type	value_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::iterator	iterator

typedef _Mybase::const_iterator	const_iterator

typedef _STD reverse_iterator< iterator >	reverse_iterator

typedef _STD reverse_iterator< const_iterator >	const_reverse_iterator

Public Types inherited from _Deque_alloc<!is_empty< _Alloc >::value, _Deque_base_types< _Ty, _Alloc > >
typedef _Deque_alloc< _Al_has_storage, _Deque_base_types< _Ty, _Alloc > >	_Myt

typedef _Deque_base_types< _Ty, _Alloc >::_Alloc	_Alloc

typedef _Deque_base_types< _Ty, _Alloc >::_Alty	_Alty

typedef _Deque_base_types< _Ty, _Alloc >::_Alpty	_Alpty

Public Types inherited from _Deque_val< _Deque_base_types< _Ty, _Alloc >::_Val_types >
typedef _Deque_val< _Deque_base_types< _Ty, _Alloc >::_Val_types >	_Myt

typedef _Deque_base_types< _Ty, _Alloc >::_Val_types::value_type	value_type

typedef _Deque_base_types< _Ty, _Alloc >::_Val_types::size_type	size_type

typedef _Deque_base_types< _Ty, _Alloc >::_Val_types::difference_type	difference_type

typedef _Deque_base_types< _Ty, _Alloc >::_Val_types::pointer	pointer

typedef _Deque_base_types< _Ty, _Alloc >::_Val_types::const_pointer	const_pointer

typedef _Deque_base_types< _Ty, _Alloc >::_Val_types::reference	reference

typedef _Deque_base_types< _Ty, _Alloc >::_Val_types::const_reference	const_reference

typedef _Deque_base_types< _Ty, _Alloc >::_Val_types::_Mapptr	_Mapptr

typedef _Deque_iterator< _Myt >	iterator

typedef _Deque_const_iterator< _Myt >	const_iterator

Public Member Functions
	deque ()

	deque (const _Alloc &_Al)

	deque (size_type _Count)

	deque (size_type _Count, const value_type &_Val)

	deque (size_type _Count, const value_type &_Val, const _Alloc &_Al)

	deque (const _Myt &_Right)

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

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

template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>
	deque (_Iter _First, _Iter _Last, const _Alloc &_Al)

template<class _Iter >
void	_Construct (_Iter _First, _Iter _Last)

void	_Construct_n (size_type _Count, const value_type &_Val)

	deque (_Myt &&_Right)

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

_Myt &	operator= (_Myt &&_Right)

void	_Assign_rv (_Myt &&_Right, true_type)

void	_Assign_rv (_Myt &&_Right, false_type)

void	_Assign_rv (_Myt &&_Right)

void	push_front (value_type &&_Val)

void	push_back (value_type &&_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)

	deque (_XSTD initializer_list< value_type > _Ilist, const _Alloc &_Al=allocator_type())

_Myt &	operator= (_XSTD initializer_list< value_type > _Ilist)

void	assign (_XSTD initializer_list< value_type > _Ilist)

iterator	insert (const_iterator _Where, _XSTD initializer_list< value_type > _Ilist)

	~deque () _NOEXCEPT

_Myt &	operator= (const _Myt &_Right)

iterator	begin () _NOEXCEPT

const_iterator	begin () const _NOEXCEPT

iterator	end () _NOEXCEPT

const_iterator	end () const _NOEXCEPT

iterator	_Make_iter (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	shrink_to_fit ()

void	resize (size_type _Newsize)

void	resize (size_type _Newsize, const value_type &_Val)

size_type	size () const _NOEXCEPT

size_type	max_size () const _NOEXCEPT

bool	empty () const _NOEXCEPT

allocator_type	get_allocator () const _NOEXCEPT

const_reference	at (size_type _Pos) const

reference	at (size_type _Pos)

const_reference	operator[] (size_type _Pos) const

reference	operator[] (size_type _Pos)

reference	front ()

const_reference	front () const

reference	back ()

const_reference	back () const

void	push_front (const value_type &_Val)

void	pop_front ()

void	push_back (const value_type &_Val)

void	pop_back ()

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

void	assign (size_type _Count, const value_type &_Val)

iterator	insert (const_iterator _Where, const value_type &_Val)

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

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

iterator	erase (const_iterator _Where)

iterator	erase (const_iterator _First_arg, const_iterator _Last_arg)

void	clear () _NOEXCEPT

void	swap (_Myt &_Right)

Public Member Functions inherited from _Deque_alloc<!is_empty< _Alloc >::value, _Deque_base_types< _Ty, _Alloc > >
	_Deque_alloc (const _Alloc &_Al=_Alloc())

	~_Deque_alloc () _NOEXCEPT

void	_Change_alloc (const _Alty &_Al)

void	_Swap_alloc (_Myt &_Right)

void	_Alloc_proxy ()

void	_Free_proxy ()

_Alty &	_Getal ()

const _Alty &	_Getal () const

Public Member Functions inherited from _Deque_val< _Deque_base_types< _Ty, _Alloc >::_Val_types >
	_Deque_val ()

size_type	_Getblock (size_type _Off) const

Public Member Functions inherited from _Container_base12
	_Container_base12 ()

	_Container_base12 (const _Container_base12 &)

_Container_base12 &	operator= (const _Container_base12 &)

	~_Container_base12 () _NOEXCEPT

_Iterator_base12 **	_Getpfirst () const

void	_Orphan_all ()

void	_Swap_all (_Container_base12 &)

Static Public Attributes
static const int	_EEM_DS = _DEQUESIZ

Protected Member Functions
void	_Insert_n (const_iterator _Where, size_type _Count, const value_type &_Val)

	__declspec (noreturn) void _Xlen() const

	__declspec (noreturn) void _Xran() const

void	_Growmap (size_type _Count)

void	_Tidy ()

Additional Inherited Members
Public Attributes inherited from _Deque_alloc<!is_empty< _Alloc >::value, _Deque_base_types< _Ty, _Alloc > >
_Deque_base_types< _Ty, _Alloc >::_Alty	_Alval

Public Attributes inherited from _Deque_val< _Deque_base_types< _Ty, _Alloc >::_Val_types >
_Mapptr	_Map

size_type	_Mapsize

size_type	_Myoff

size_type	_Mysize

Public Attributes inherited from _Container_base12
_Container_proxy *	_Myproxy

Member Typedef Documentation

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

typedef _Mybase::_Alpty deque< _Ty, _Alloc >::_Alpty

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

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

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

typedef _Mybase::_Mapptr deque< _Ty, _Alloc >::_Mapptr

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

typedef _Deque_alloc<!is_empty<_Alloc>::value, _Deque_base_types<_Ty, _Alloc> > deque< _Ty, _Alloc >::_Mybase

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

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

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

typedef _Alloc deque< _Ty, _Alloc >::allocator_type

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Member Enumeration Documentation

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

anonymous enum

Enumerator
_EEN_DS

948 {_EEN_DS = _DEQUESIZ}; // helper for expression evaluator

deque::_EEN_DS

Definition: deque:948

_DEQUESIZ

#define _DEQUESIZ

Definition: deque:19

Constructor & Destructor Documentation

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

deque< _Ty, _Alloc >::deque ( )

inline

         : _Mybase()
         {   // construct empty deque
         }

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

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

inlineexplicit

         : _Mybase(_Al)
         {   // construct empty deque with allocator
         }

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

deque< _Ty, _Alloc >::deque ( size_type _Count )

inlineexplicit

         : _Mybase()
         {   // construct from _Count * value_type()
         resize(_Count);
         }

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

deque< _Ty, _Alloc >::deque	(	size_type	_Count,
		const value_type &	_Val
	)

inline

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

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

deque< _Ty, _Alloc >::deque	(	size_type	_Count,
		const value_type &	_Val,
		const _Alloc &	_Al
	)

inline

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

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

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

inline

         : _Mybase(_Right._Getal().select_on_container_copy_construction())
 
 
         {   // construct by copying _Right
         _Construct(_Right.begin(), _Right.end());
         }

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

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

inline

         : _Mybase(_Al)
         {   // construct by copying _Right
         _Construct(_Right.begin(), _Right.end());
         }

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

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

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

inline

         : _Mybase()
         {   // construct 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>

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

inline

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

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

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

inline

         : _Mybase(_Right._Getal())
         {   // construct by moving _Right
         _Assign_rv(_STD forward<_Myt>(_Right), true_type());
         }

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

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

inline

         : _Mybase(_Al)
         {   // construct by moving _Right
         _Assign_rv(_STD forward<_Myt>(_Right));
         }

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

deque< _Ty, _Alloc >::deque	(	_XSTD initializer_list< value_type >	_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>>

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

inline

         {   // destroy the deque
         _Tidy();
         }

Member Function Documentation

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

deque< _Ty, _Alloc >::__declspec ( noreturn ) const

inlineprotected

         {   // report a length_error
         _Xlength_error("deque<T> too long");
         }

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

deque< _Ty, _Alloc >::__declspec ( noreturn ) const

inlineprotected

         {   // report an out_of_range error
         _Xout_of_range("invalid deque<T> subscript");
         }

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

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

inline

         {   // move from _Right, stealing its contents
         this->_Swap_all((_Myt&)_Right);
         this->_Map = _Right._Map;
         this->_Mapsize = _Right._Mapsize;
         this->_Myoff = _Right._Myoff;
         this->_Mysize = _Right._Mysize;
 
         _Right._Map = _Mapptr();
         _Right._Mapsize = 0;
         _Right._Myoff = 0;
         _Right._Mysize = 0;
         }

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

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

inline

         {   // move from _Right, possibly moving its contents
         if (get_allocator() == _Right.get_allocator())
             _Assign_rv(_STD forward<_Myt>(_Right), true_type());
         else
             _Construct(_STD make_move_iterator(_Right.begin()),
                 _STD make_move_iterator(_Right.end()));
         }

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

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

inline

         {   // assign by moving _Right
         _Assign_rv(_STD forward<_Myt>(_Right),
             typename _Alty::propagate_on_container_move_assignment());
         }

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

template<class _Iter >

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

inline

         {   // initialize from [_First, _Last), input iterators
         _TRY_BEGIN
 
         for (; _First != _Last; ++_First)
             emplace_back(*_First);
 
         _CATCH_ALL
         _Tidy();
         _RERAISE;
         _CATCH_END
         }

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

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

inline

         {   // construct from _Count * _Val
         _TRY_BEGIN
         for (; 0 < _Count; --_Count)
             push_back(_Val);
         _CATCH_ALL
         _Tidy();
         _RERAISE;
         _CATCH_END
         }

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

void deque< _Ty, _Alloc >::_Growmap ( size_type _Count )

inlineprotected

         {   // grow map by at least _Count pointers, _Mapsize a power of 2
         static_assert(1 < _DEQUEMAPSIZ,
             "The _Xlen() test should always be performed.");
 
         typedef typename _Alpty::pointer _Blockptr;
         _Alpty _Almap(this->_Getal());
         size_type _Newsize = 0 < this->_Mapsize ? this->_Mapsize : 1;
         while (_Newsize - this->_Mapsize < _Count || _Newsize < _DEQUEMAPSIZ)
             {   // scale _Newsize to 2^N >= _Mapsize + _Count
             if (max_size() / _DEQUESIZ - _Newsize < _Newsize)
                 _Xlen();    // result too long
             _Newsize *= 2;
             }
         _Count = _Newsize - this->_Mapsize;
 
         size_type _Myboff = this->_Myoff / _DEQUESIZ;
         _Mapptr _Newmap = _Almap.allocate(this->_Mapsize + _Count);
         _Mapptr _Myptr = _Newmap + _Myboff;
 
         _Myptr = _Uninitialized_copy(this->_Map + _Myboff,
             this->_Map + this->_Mapsize,
             _Myptr, _Almap);    // copy initial to end
         if (_Myboff <= _Count)
             {   // increment greater than offset of initial block
             _Myptr = _Uninitialized_copy(this->_Map,
                 this->_Map + _Myboff,
                 _Myptr, _Almap);    // copy rest of old
             _Uninitialized_default_fill_n(_Myptr, _Count - _Myboff,
                 _Almap);    // clear suffix of new
             _Uninitialized_default_fill_n(_Newmap, _Myboff,
                 _Almap);    // clear prefix of new
             }
         else
             {   // increment not greater than offset of initial block
             _Uninitialized_copy(this->_Map,
                 this->_Map + _Count,
                 _Myptr, _Almap);    // copy more old
             _Myptr = _Uninitialized_copy(this->_Map + _Count,
                 this->_Map + _Myboff,
                 _Newmap, _Almap);   // copy rest of old
             _Uninitialized_default_fill_n(_Myptr, _Count,
                 _Almap);    // clear rest to initial block
             }
 
         _Destroy_range(this->_Map + _Myboff, this->_Map + this->_Mapsize,
             _Almap);
         if (this->_Map != _Mapptr())
             _Almap.deallocate(this->_Map,
                 this->_Mapsize);    // free storage for old
 
         this->_Map = _Newmap;   // point at new
         this->_Mapsize += _Count;
         }

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

void deque< _Ty, _Alloc >::_Insert_n	(	const_iterator	_Where,
		size_type	_Count,
		const value_type &	_Val
	)

inlineprotected

         {   // insert _Count * _Val at _Where
         iterator _Mid;
         size_type _Num;
         size_type _Off = _Where - begin();
         size_type _Rem = this->_Mysize - _Off;
         size_type _Oldsize = this->_Mysize;
 
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (this->_Mysize < _Off)
             _DEBUG_ERROR("deque insert iterator outside range");
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         if (_Off < _Rem)
             {   // closer to front
             _TRY_BEGIN
             if (_Off < _Count)
                 {   // insert longer than prefix
                 for (_Num = _Count - _Off; 0 < _Num; --_Num)
                     push_front(_Val);   // push excess values
                 for (_Num = _Off; 0 < _Num; --_Num)
                     push_front(begin()[_Count - 1]);    // push prefix
 
                 _Mid = begin() + _Count;
                 _STD fill(_Mid, _Mid + _Off,
                     _Val);  // fill in rest of values
                 }
             else
                 {   // insert not longer than prefix
                 for (_Num = _Count; 0 < _Num; --_Num)
                     push_front(begin()[_Count - 1]);    // push part of prefix
 
                 _Mid = begin() + _Count;
                 value_type _Tmp = _Val; // in case _Val is in sequence
                 _Move(_Mid + _Count, _Mid + _Off,
                     _Mid);  // copy rest of prefix
                 _STD fill(begin() + _Off, _Mid + _Off,
                     _Tmp);  // fill in values
                 }
             _CATCH_ALL
             for (; _Oldsize < this->_Mysize; )
                 pop_front();    // restore old size, at least
             _RERAISE;
             _CATCH_END
             }
         else
             {       // closer to back
             _TRY_BEGIN
             if (_Rem < _Count)
                 {   // insert longer than suffix
                 for (_Num = _Count - _Rem; 0 < _Num; --_Num)
                     push_back(_Val);    // push excess values
                 for (_Num = 0; _Num < _Rem; ++_Num)
                     push_back(begin()[_Off + _Num]);    // push suffix
 
                 _Mid = begin() + _Off;
                 _STD fill(_Mid, _Mid + _Rem,
                     _Val);  // fill in rest of values
                 }
             else
                 {   // insert not longer than prefix
                 for (_Num = 0; _Num < _Count; ++_Num)
                     push_back(begin()[_Off + _Rem
                         - _Count + _Num]);  // push part of prefix
 
                 _Mid = begin() + _Off;
                 value_type _Tmp = _Val; // in case _Val is in sequence
                 _Move_backward(_Mid, _Mid + _Rem - _Count,
                     _Mid + _Rem);   // copy rest of prefix
                 _STD fill(_Mid, _Mid + _Count,
                     _Tmp);  // fill in values
                 }
             _CATCH_ALL
             for (; _Oldsize < this->_Mysize; )
                 pop_back(); // restore old size, at least
             _RERAISE;
             _CATCH_END
             }
         }

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

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

inline

         {   // make iterator from const_iterator
         return (iterator(_Where._Myoff, this));
         }

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

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

inlineprotected

         {   // free all storage
         _Alpty _Almap(this->_Getal());
         while (!empty())
             pop_back();
         for (size_type _Block = this->_Mapsize; 0 < _Block; )
             {   // free storage for a block and destroy pointer
             if (this->_Map[--_Block] != pointer())
                 {   // free block and destroy its pointer
                 this->_Getal().deallocate(this->_Map[_Block], _DEQUESIZ);
                 this->_Getal().destroy(&this->_Map[_Block]);
                 }
             }
 
         if (this->_Map != _Mapptr())
             _Almap.deallocate(this->_Map,
                 this->_Mapsize);    // free storage for map
         this->_Mapsize = 0;
         this->_Map = _Mapptr();
         }

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

void deque< _Ty, _Alloc >::assign ( _XSTD initializer_list< value_type > _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 deque< _Ty, _Alloc >::assign	(	_Iter	_First,
		_Iter	_Last
	)

inline

         {   // assign [_First, _Last), input iterators
         clear();
 
         for (; _First != _Last; ++_First)
             emplace_back(*_First);
         }

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

void deque< _Ty, _Alloc >::assign	(	size_type	_Count,
		const value_type &	_Val
	)

inline

         {   // assign _Count * _Val
         erase(begin(), end());
         _Insert_n(begin(), _Count, _Val);
         }

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

const_reference deque< _Ty, _Alloc >::at ( size_type _Pos ) const

inline

         {   // subscript nonmutable sequence with checking
         if (this->_Mysize <= _Pos)
             _Xran();
         return (*(begin() + _Pos));
         }

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

reference deque< _Ty, _Alloc >::at ( size_type _Pos )

inline

         {   // subscript mutable sequence with checking
         if (this->_Mysize <= _Pos)
             _Xran();
         return (*(begin() + _Pos));
         }

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

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

inline

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

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

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

inline

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

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

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

inline

         {   // return iterator for beginning of mutable sequence
         return (iterator(this->_Myoff, this));
         }

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

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

inline

         {   // return iterator for beginning of nonmutable sequence
         return (const_iterator(this->_Myoff, this));
         }

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

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

inline

         {   // return iterator for beginning of nonmutable sequence
         return (((const _Myt *)this)->begin());
         }

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

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

inline

         {   // return iterator for end of nonmutable sequence
         return (((const _Myt *)this)->end());
         }

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

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

inline

         {   // erase all
         _Tidy();
         }

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

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

inline

         {   // return iterator for beginning of reversed nonmutable sequence
         return (((const _Myt *)this)->rbegin());
         }

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

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

inline

         {   // return iterator for end of reversed nonmutable sequence
         return (((const _Myt *)this)->rend());
         }

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

template<class... _Valty>

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

inline

         {   // insert element at _Where
         size_type _Off = _Where - begin();
 
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (this->_Mysize < _Off)
             _DEBUG_ERROR("deque emplace iterator outside range");
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         if (_Off <= this->_Mysize / 2)
             {   // closer to front, push to front then rotate
             emplace_front(_STD forward<_Valty>(_Val)...);
             _STD rotate(begin(), begin() + 1, begin() + 1 + _Off);
             }
         else
             {   // closer to back, push to back then rotate
             emplace_back(_STD forward<_Valty>(_Val)...);
             _STD rotate(begin() + _Off, end() - 1, end());
             }
         return (begin() + _Off);
         }

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

template<class... _Valty>

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

inline

         {   // insert element at end
         this->_Orphan_all();
         _PUSH_BACK_BEGIN;
         this->_Getal().construct(
             this->_Map[_Block] + _Newoff % _DEQUESIZ,
             _STD forward<_Valty>(_Val)...);
         _PUSH_BACK_END;
         }

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

template<class... _Valty>

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

inline

         {   // insert element at beginning
         this->_Orphan_all();
         _PUSH_FRONT_BEGIN;
         this->_Getal().construct(
             this->_Map[_Block] + _Newoff % _DEQUESIZ,
             _STD forward<_Valty>(_Val)...);
         _PUSH_FRONT_END;
         }

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

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

inline

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

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

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

inline

         {   // return iterator for end of mutable sequence
         return (iterator(this->_Myoff + this->_Mysize, this));
         }

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

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

inline

         {   // return iterator for end of nonmutable sequence
         return (const_iterator(this->_Myoff + this->_Mysize, this));
         }

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

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

inline

         {   // erase element at _Where
         return (erase(_Where, _Where + 1));
         }

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

iterator deque< _Ty, _Alloc >::erase	(	const_iterator	_First_arg,
		const_iterator	_Last_arg
	)

inline

         {   // erase [_First, _Last)
         iterator _First = _Make_iter(_First_arg);
         iterator _Last = _Make_iter(_Last_arg);
 
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Last < _First
             || _First < begin() || end() < _Last)
             _DEBUG_ERROR("deque erase iterator outside range");
         _DEBUG_RANGE(_First, _Last);
 
         size_type _Off = _First - begin();
         size_type _Count = _Last - _First;
         bool _Moved = 0 < _Off && _Off + _Count < this->_Mysize;
 
  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
         size_type _Off = _First - begin();
         size_type _Count = _Last - _First;
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         if (_Off < (size_type)(end() - _Last))
             {   // closer to front
             _Move_backward(begin(), _First, _Last); // copy over hole
             for (; 0 < _Count; --_Count)
                 pop_front();    // pop copied elements
             }
         else
             {   // closer to back
             _Move(_Last, end(), _First);    // copy over hole
             for (; 0 < _Count; --_Count)
                 pop_back(); // pop copied elements
             }
 
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_Moved)
             this->_Orphan_all();
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         return (begin() + _Off);
         }

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

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

inline

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

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

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

inline

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

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

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

inline

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

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

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

inline

         {   // insert _Val at _Where
         return (emplace(_Where, _STD move(_Val)));
         }

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

iterator deque< _Ty, _Alloc >::insert	(	const_iterator	_Where,
		_XSTD initializer_list< value_type >	_Ilist
	)

inline

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

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

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

inline

         {   // insert _Val at _Where
         size_type _Off = _Where - begin();
 
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (this->_Mysize < _Off)
             _DEBUG_ERROR("deque insert iterator outside range");
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         if (_Off <= this->_Mysize / 2)
             {   // closer to front, push to front then copy
             push_front(_Val);
             _STD rotate(begin(), begin() + 1, begin() + 1 + _Off);
             }
         else
             {   // closer to back, push to back then copy
             push_back(_Val);
             _STD rotate(begin() + _Off, end() - 1, end());
             }
         return (begin() + _Off);
         }

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

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

inline

         {   // insert _Count * _Val at _Where
         size_type _Off = _Where - begin();
         _Insert_n(_Where, _Count, _Val);
         return (begin() + _Off);
         }

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

template<class _Iter >

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

inline

         {   // insert [_First, _Last) at _Where, input iterators
         size_type _Off = _Where - begin();
 
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (this->_Mysize < _Off)
             _DEBUG_ERROR("deque insert iterator outside range");
         _DEBUG_RANGE(_First, _Last);
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         size_type _Oldsize = this->_Mysize;
 
         if (_First == _Last)
             ;
         else if (_Off <= this->_Mysize / 2)
             {   // closer to front, push to front then rotate
             _TRY_BEGIN
             for (; _First != _Last; ++_First)
                 push_front(*_First);    // prepend flipped
 
             _CATCH_ALL
             for (; _Oldsize < this->_Mysize; )
                 pop_front();    // restore old size, at least
             _RERAISE;
             _CATCH_END
 
             size_type _Num = this->_Mysize - _Oldsize;
             _STD reverse(begin(), begin() + _Num);  // flip new stuff in place
             _STD rotate(begin(), begin() + _Num, begin() + _Num + _Off);
             }
         else
             {   // closer to back
             _TRY_BEGIN
             for (; _First != _Last; ++_First)
                 push_back(*_First); // append
 
             _CATCH_ALL
             for (; _Oldsize < this->_Mysize; )
                 pop_back(); // restore old size, at least
             _RERAISE;
             _CATCH_END
 
             _STD rotate(begin() + _Off, begin() + _Oldsize, end());
             }
         return (begin() + _Off);
         }

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

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

inline

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

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

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

inline

         {   // assign by moving _Right
         if (this != &_Right)
             {   // different, assign it
             _Tidy();
             if (_Alty::propagate_on_container_move_assignment::value
                 && this->_Getal() != _Right._Getal())
                 this->_Change_alloc(_Right._Getal());
             _Assign_rv(_STD forward<_Myt>(_Right));
             }
         return (*this);
         }

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

_Myt& deque< _Ty, _Alloc >::operator= ( _XSTD initializer_list< value_type > _Ilist )

inline

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

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

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

inline

         {   // assign _Right
         if (this != &_Right)
             {   // different, assign it
             if (this->_Getal() != _Right._Getal()
                 && _Alty::propagate_on_container_copy_assignment::value)
                 {   // change allocator before copying
                 _Tidy();
                 this->_Change_alloc(_Right._Getal());
                 }
 
             this->_Orphan_all();
 
             if (_Right._Mysize == 0)
                 clear();
             else if (_Right._Mysize <= this->_Mysize)
                 {   // enough elements, copy new and destroy old
                 iterator _Mid = _STD copy(_Right.begin(), _Right.end(),
                     begin());
                 erase(_Mid, end());
                 }
             else
                 {   // new sequence longer, copy and construct new
                 const_iterator _Mid = _Right.begin() + this->_Mysize;
                 _STD copy(_Right.begin(), _Mid, begin());
                 insert(end(), _Mid, _Right.end());
                 }
             }
         return (*this);
         }

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

const_reference deque< _Ty, _Alloc >::operator[] ( size_type _Pos ) const

inline

         {   // subscript nonmutable sequence
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (this->_Mysize <= _Pos)
             _DEBUG_ERROR("deque subscript out of range");
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         return (*(begin() + _Pos));
         }

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

reference deque< _Ty, _Alloc >::operator[] ( size_type _Pos )

inline

         {   // subscript mutable sequence
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (this->_Mysize <= _Pos)
             _DEBUG_ERROR("deque subscript out of range");
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         return (*(begin() + _Pos));
         }

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

void deque< _Ty, _Alloc >::pop_back ( )

inline

         {   // erase element at end
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (empty())
             _DEBUG_ERROR("deque empty before pop");
         else
             {   // something to erase, do it
             size_type _Newoff = this->_Myoff + this->_Mysize - 1;
             _Orphan_off(_Newoff);
             size_type _Block = this->_Getblock(_Newoff);
             this->_Getal().destroy(
                 this->_Map[_Block] + _Newoff % _DEQUESIZ);
             if (--this->_Mysize == 0)
                 this->_Myoff = 0;
             }
 
  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
         size_type _Newoff = this->_Myoff + this->_Mysize - 1;
         size_type _Block = this->_Getblock(_Newoff);
         this->_Getal().destroy(
             this->_Map[_Block] + _Newoff % _DEQUESIZ);
         if (--this->_Mysize == 0)
             this->_Myoff = 0;
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
         }

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

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

inline

         {   // erase element at beginning
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (empty())
             _DEBUG_ERROR("deque empty before pop");
         else
             {   // something to erase, do it
             _Orphan_off(this->_Myoff);
             size_type _Block = this->_Getblock(this->_Myoff);
             this->_Getal().destroy(
                 this->_Map[_Block] + this->_Myoff % _DEQUESIZ);
             if (--this->_Mysize == 0)
                 this->_Myoff = 0;
             else
                 ++this->_Myoff;
             }
 
  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
         size_type _Block = this->_Getblock(this->_Myoff);
         this->_Getal().destroy(
             this->_Map[_Block] + this->_Myoff % _DEQUESIZ);
         if (--this->_Mysize == 0)
             this->_Myoff = 0;
         else
             ++this->_Myoff;
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
         }

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

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

inline

         {   // insert element at end
         this->_Orphan_all();
         _PUSH_BACK_BEGIN;
         this->_Getal().construct(
             this->_Map[_Block] + _Newoff % _DEQUESIZ,
             _STD forward<value_type>(_Val));
         _PUSH_BACK_END;
         }

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

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

inline

         {   // insert element at end
         this->_Orphan_all();
         _PUSH_BACK_BEGIN;
         this->_Getal().construct(
             this->_Map[_Block] + _Newoff % _DEQUESIZ, _Val);
         _PUSH_BACK_END;
         }

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

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

inline

         {   // insert element at beginning
         this->_Orphan_all();
         _PUSH_FRONT_BEGIN;
         this->_Getal().construct(
             this->_Map[_Block] + _Newoff % _DEQUESIZ,
             _STD forward<value_type>(_Val));
         _PUSH_FRONT_END;
         }

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

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

inline

         {   // insert element at beginning
         this->_Orphan_all();
         _PUSH_FRONT_BEGIN;
         this->_Getal().construct(
             this->_Map[_Block] + _Newoff % _DEQUESIZ, _Val);
         _PUSH_FRONT_END;
         }

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

reverse_iterator deque< _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 deque< _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>>

reverse_iterator deque< _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 deque< _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 deque< _Ty, _Alloc >::resize ( size_type _Newsize )

inline

         {   // determine new length, padding as needed
         while (this->_Mysize < _Newsize)
             emplace_back();
 
         while (_Newsize < this->_Mysize)
             pop_back();
         }

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

void deque< _Ty, _Alloc >::resize	(	size_type	_Newsize,
		const value_type &	_Val
	)

inline

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

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

void deque< _Ty, _Alloc >::shrink_to_fit ( )

inline

         {   // reduce capacity
         size_type _Oldcapacity = _DEQUESIZ * this->_Mapsize;
         size_type _Newcapacity = _Oldcapacity / 2;
 
         if (_Newcapacity < _DEQUESIZ * _DEQUEMAPSIZ)
             _Newcapacity = _DEQUESIZ * _DEQUEMAPSIZ;
 
         if ((empty() && 0 < this->_Mapsize)
             || (!empty()
                 && size() <= _Newcapacity
                 && _Newcapacity < _Oldcapacity))
             {   // worth shrinking, do it
             _Myt _Tmp(_STD make_move_iterator(begin()),
                 _STD make_move_iterator(end()));
             swap(_Tmp);
             }
         }

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

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

inline

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

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

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

inline

         {   // exchange contents with _Right
         if (this == &_Right)
             ;   // same object, do nothing
         else if (this->_Getal() == _Right._Getal())
             {   // same allocator, swap control information
             this->_Swap_all(_Right);
             _Swap_adl(this->_Map, _Right._Map);
             _STD swap(this->_Mapsize, _Right._Mapsize);
             _STD swap(this->_Myoff, _Right._Myoff);
             _STD swap(this->_Mysize, _Right._Mysize);
             }
 
         else if (_Alty::propagate_on_container_swap::value)
             {   // swap allocators and control information
             this->_Swap_alloc(_Right);
             _Swap_adl(this->_Map, _Right._Map);
             _STD swap(this->_Mapsize, _Right._Mapsize);
             _STD swap(this->_Myoff, _Right._Myoff);
             _STD swap(this->_Mysize, _Right._Mysize);
             }
         else
             {   // containers are incompatible
  #if _ITERATOR_DEBUG_LEVEL == 2
             _DEBUG_ERROR("deque containers incompatible for swap");
 
  #else /* ITERATOR_DEBUG_LEVEL == 2 */
             _XSTD terminate();
  #endif /* ITERATOR_DEBUG_LEVEL == 2 */
             }
 
         }

Member Data Documentation

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

const int deque< _Ty, _Alloc >::_EEM_DS = _DEQUESIZ

static

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

VS2013/inc/deque

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Additional Inherited Members

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation