queue< _Ty, _Container > Class Template Reference

Public Types
typedef queue< _Ty, _Container >	_Myt
typedef _Container	container_type
typedef _Container::value_type	value_type
typedef _Container::size_type	size_type
typedef _Container::reference	reference
typedef _Container::const_reference	const_reference

Public Member Functions
	queue ()
	queue (const _Myt &_Right)
	queue (const _Container &_Cont)
_Myt &	operator= (const _Myt &_Right)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	queue (const _Alloc &_Al)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	queue (const _Container &_Cont, const _Alloc &_Al)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	queue (const _Myt &_Right, const _Alloc &_Al)
	queue (_Myt &&_Right) _NOEXCEPT_OP(is_nothrow_move_constructible< _Container >
	queue (_Container &&_Cont)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	queue (_Container &&_Cont, const _Alloc &_Al)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	queue (_Myt &&_Right, const _Alloc &_Al)
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT_OP(is_nothrow_move_assignable< _Container >
void	push (value_type &&_Val)
template<class... _Valty>
void	emplace (_Valty &&..._Val)
bool	empty () const
size_type	size () const
reference	front ()
const_reference	front () const
reference	back ()
const_reference	back () const
void	push (const value_type &_Val)
void	pop ()
const _Container &	_Get_container () const
void	swap (_Myt &_Right) _NOEXCEPT_OP(_NOEXCEPT_OP(_Swap_adl(c

Public Attributes
void _Right	c

Protected Attributes
_Container	c

Member Typedef Documentation

template<class _Ty, class _Container = deque<_Ty>>

typedef queue<_Ty, _Container> queue< _Ty, _Container >::_Myt

template<class _Ty, class _Container = deque<_Ty>>

typedef _Container::const_reference queue< _Ty, _Container >::const_reference

template<class _Ty, class _Container = deque<_Ty>>

typedef _Container queue< _Ty, _Container >::container_type

template<class _Ty, class _Container = deque<_Ty>>

typedef _Container::reference queue< _Ty, _Container >::reference

template<class _Ty, class _Container = deque<_Ty>>

typedef _Container::size_type queue< _Ty, _Container >::size_type

template<class _Ty, class _Container = deque<_Ty>>

typedef _Container::value_type queue< _Ty, _Container >::value_type

Constructor & Destructor Documentation

template<class _Ty, class _Container = deque<_Ty>>

queue< _Ty, _Container >::queue ( )

inline

        : c()
        {   // construct with empty container
        }

template<class _Ty, class _Container = deque<_Ty>>

queue< _Ty, _Container >::queue ( const _Myt &  _Right )

inline

        : c(_Right.c)
        {   // construct by copying _Right container
        }

template<class _Ty, class _Container = deque<_Ty>>

queue< _Ty, _Container >::queue ( const _Container &  _Cont )

inlineexplicit

        : c(_Cont)
        {   // construct by copying specified container
        }

template<class _Ty, class _Container = deque<_Ty>>

template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>

queue< _Ty, _Container >::queue ( const _Alloc &  _Al )

inlineexplicit

        : c(_Al)
        {   // construct with empty container, allocator
        }

template<class _Ty, class _Container = deque<_Ty>>

template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>

queue< _Ty, _Container >::queue ( const _Container &  _Cont, const _Alloc &  _Al  )

inline

        : c(_Cont, _Al)
        {   // construct by copying specified container, allocator
        }

template<class _Ty, class _Container = deque<_Ty>>

template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>

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

inline

        : c(_Right.c, _Al)
        {   // construct by copying _Right container, allocator
        }

template<class _Ty, class _Container = deque<_Ty>>

queue< _Ty, _Container >::queue ( _Myt &&  _Right )

inline

        : c(_STD move(_Right.c))
        {   // construct by moving _Right
        }

template<class _Ty, class _Container = deque<_Ty>>

queue< _Ty, _Container >::queue ( _Container &&  _Cont )

inlineexplicit

        : c(_STD move(_Cont))
        {   // construct by moving specified container
        }

template<class _Ty, class _Container = deque<_Ty>>

template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>

queue< _Ty, _Container >::queue ( _Container &&  _Cont, const _Alloc &  _Al  )

inline

        : c(_STD move(_Cont), _Al)
        {   // construct by moving specified container, allocator
        }

template<class _Ty, class _Container = deque<_Ty>>

template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>

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

inline

        : c(_STD move(_Right.c), _Al)
        {   // construct by moving _Right container, allocator
        }

Member Function Documentation

template<class _Ty, class _Container = deque<_Ty>>

const _Container& queue< _Ty, _Container >::_Get_container ( ) const

inline

        {   // get reference to container
        return (c);
        }

template<class _Ty, class _Container = deque<_Ty>>

reference queue< _Ty, _Container >::back ( )

inline

        {   // return last element of mutable queue
        return (c.back());
        }

template<class _Ty, class _Container = deque<_Ty>>

const_reference queue< _Ty, _Container >::back ( ) const

inline

        {   // return last element of nonmutable queue
        return (c.back());
        }

template<class _Ty, class _Container = deque<_Ty>>

template<class... _Valty>

void queue< _Ty, _Container >::emplace ( _Valty &&...  _Val )

inline

        {   // insert element at beginning
        c.emplace_back(_STD forward<_Valty>(_Val)...);
        }

template<class _Ty, class _Container = deque<_Ty>>

bool queue< _Ty, _Container >::empty ( ) const

inline

        {   // test if queue is empty
        return (c.empty());
        }

template<class _Ty, class _Container = deque<_Ty>>

reference queue< _Ty, _Container >::front ( )

inline

        {   // return first element of mutable queue
        return (c.front());
        }

template<class _Ty, class _Container = deque<_Ty>>

const_reference queue< _Ty, _Container >::front ( ) const

inline

        {   // return first element of nonmutable queue
        return (c.front());
        }

template<class _Ty, class _Container = deque<_Ty>>

_Myt& queue< _Ty, _Container >::operator= ( const _Myt &  _Right )

inline

        {   // assign by copying _Right
        c = _Right.c;
        return (*this);
        }

template<class _Ty, class _Container = deque<_Ty>>

_Myt& queue< _Ty, _Container >::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        c = _STD move(_Right.c);
        return (*this);
        }

template<class _Ty, class _Container = deque<_Ty>>

void queue< _Ty, _Container >::pop ( )

inline

        {   // erase element at end
        c.pop_front();
        }

template<class _Ty, class _Container = deque<_Ty>>

void queue< _Ty, _Container >::push ( value_type &&  _Val )

inline

        {   // insert element at beginning
        c.push_back(_STD move(_Val));
        }

template<class _Ty, class _Container = deque<_Ty>>

void queue< _Ty, _Container >::push ( const value_type &  _Val )

inline

        {   // insert element at beginning
        c.push_back(_Val);
        }

template<class _Ty, class _Container = deque<_Ty>>

size_type queue< _Ty, _Container >::size ( ) const

inline

        {   // return length of queue
        return (c.size());
        }

template<class _Ty, class _Container = deque<_Ty>>

void queue< _Ty, _Container >::swap

(

_Myt &

_Right

)

Member Data Documentation

template<class _Ty, class _Container = deque<_Ty>>

void _Right queue< _Ty, _Container >::c

Initial value:

{   
        _Swap_adl(c, _Right.c)

template<class _Ty, class _Container = deque<_Ty>>

_Container queue< _Ty, _Container >::c

protected

---

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

• VS2013/inc/queue