priority_queue< _Ty, _Container, _Pr > Class Template Reference

Public Types
typedef priority_queue< _Ty, _Container, _Pr >	_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
	priority_queue ()
	priority_queue (const _Myt &_Right)
	priority_queue (const _Pr &_Pred)
	priority_queue (const _Pr &_Pred, const _Container &_Cont)
template<class _InIt >
	priority_queue (_InIt _First, _InIt _Last)
template<class _InIt >
	priority_queue (_InIt _First, _InIt _Last, const _Pr &_Pred)
template<class _InIt >
	priority_queue (_InIt _First, _InIt _Last, const _Pr &_Pred, const _Container &_Cont)
_Myt &	operator= (const _Myt &_Right)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	priority_queue (const _Alloc &_Al)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	priority_queue (const _Pr &_Pred, const _Alloc &_Al)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	priority_queue (const _Pr &_Pred, const _Container &_Cont, const _Alloc &_Al)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	priority_queue (const _Myt &_Right, const _Alloc &_Al)
	priority_queue (_Myt &&_Right) _NOEXCEPT_OP(is_nothrow_move_constructible< _Container >
	priority_queue (const _Pr &_Pred, _Container &&_Cont)
template<class _InIt >
	priority_queue (_InIt _First, _InIt _Last, const _Pr &_Pred, _Container &&_Cont)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	priority_queue (const _Pr &_Pred, _Container &&_Cont, const _Alloc &_Al)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	priority_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
const_reference	top () const
void	push (const value_type &_Val)
void	pop ()
void	swap (_Myt &_Right) _NOEXCEPT_OP(_Is_nothrow_swappable< _Container >

Protected Attributes
_Container	c
_Pr	comp

Member Typedef Documentation

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

typedef priority_queue<_Ty, _Container, _Pr> priority_queue< _Ty, _Container, _Pr >::_Myt

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

typedef _Container::const_reference priority_queue< _Ty, _Container, _Pr >::const_reference

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

typedef _Container priority_queue< _Ty, _Container, _Pr >::container_type

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

typedef _Container::reference priority_queue< _Ty, _Container, _Pr >::reference

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

typedef _Container::size_type priority_queue< _Ty, _Container, _Pr >::size_type

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

typedef _Container::value_type priority_queue< _Ty, _Container, _Pr >::value_type

Constructor & Destructor Documentation

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

priority_queue< _Ty, _Container, _Pr >::priority_queue ( )

inline

        : c(), comp()
        {   // construct with empty container, default comparator
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

inline

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

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

priority_queue< _Ty, _Container, _Pr >::priority_queue ( const _Pr &  _Pred )

inlineexplicit

        : c(), comp(_Pred)
        {   // construct with empty container, specified comparator
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

priority_queue< _Ty, _Container, _Pr >::priority_queue ( const _Pr &  _Pred, const _Container &  _Cont  )

inline

        : c(_Cont), comp(_Pred)
        {   // construct by copying specified container, comparator
        make_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

template<class _InIt >

priority_queue< _Ty, _Container, _Pr >::priority_queue ( _InIt  _First, _InIt  _Last  )

inline

        : c(_First, _Last), comp()
        {   // construct by copying [_First, _Last), default comparator
        make_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

template<class _InIt >

priority_queue< _Ty, _Container, _Pr >::priority_queue ( _InIt  _First, _InIt  _Last, const _Pr &  _Pred  )

inline

        : c(_First, _Last), comp(_Pred)
        {   // construct by copying [_First, _Last), specified comparator
        make_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

template<class _InIt >

priority_queue< _Ty, _Container, _Pr >::priority_queue ( _InIt  _First, _InIt  _Last, const _Pr &  _Pred, const _Container &  _Cont  )

inline

        : c(_Cont), comp(_Pred)
        {   // construct by copying [_First, _Last), container, and comparator
        c.insert(c.end(), _First, _Last);
        make_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

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

inlineexplicit

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

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

priority_queue< _Ty, _Container, _Pr >::priority_queue ( const _Pr &  _Pred, const _Alloc &  _Al  )

inline

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

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

priority_queue< _Ty, _Container, _Pr >::priority_queue ( const _Pr &  _Pred, const _Container &  _Cont, const _Alloc &  _Al  )

inline

        : c(_Cont, _Al), comp(_Pred)
        {   // construct by copying specified container, comparator, allocator
        make_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

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

inline

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

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

priority_queue< _Ty, _Container, _Pr >::priority_queue ( _Myt &&  _Right )

inline

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

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

priority_queue< _Ty, _Container, _Pr >::priority_queue ( const _Pr &  _Pred, _Container &&  _Cont  )

inline

        : c(_STD move(_Cont)), comp(_Pred)
        {   // construct by moving specified container, comparator
        make_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

template<class _InIt >

priority_queue< _Ty, _Container, _Pr >::priority_queue ( _InIt  _First, _InIt  _Last, const _Pr &  _Pred, _Container &&  _Cont  )

inline

        : c(_STD move(_Cont)), comp(_Pred)
        {   // construct by copying [_First, _Last), moving container
        c.insert(c.end(), _First, _Last);
        make_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

priority_queue< _Ty, _Container, _Pr >::priority_queue ( const _Pr &  _Pred, _Container &&  _Cont, const _Alloc &  _Al  )

inline

        : c(_STD move(_Cont), _Al), comp(_Pred)
        {   // construct by moving specified container, comparator, allocator
        make_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

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

inline

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

Member Function Documentation

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

template<class... _Valty>

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

inline

        {   // insert element at beginning
        c.emplace_back(_STD forward<_Valty>(_Val)...);
        push_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

bool priority_queue< _Ty, _Container, _Pr >::empty ( ) const

inline

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

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

inline

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

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

inline

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

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

void priority_queue< _Ty, _Container, _Pr >::pop ( )

inline

        {   // erase highest-priority element
        pop_heap(c.begin(), c.end(), comp);
        c.pop_back();
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

inline

        {   // insert element at beginning
        c.push_back(_STD move(_Val));
        push_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

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

inline

        {   // insert value in priority order
        c.push_back(_Val);
        push_heap(c.begin(), c.end(), comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

size_type priority_queue< _Ty, _Container, _Pr >::size ( ) const

inline

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

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

void priority_queue< _Ty, _Container, _Pr >::swap ( _Myt &  _Right )

inline

        {   // exchange contents with _Right
        _Swap_adl(c, _Right.c);
        _Swap_adl(comp, _Right.comp);
        }

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

const_reference priority_queue< _Ty, _Container, _Pr >::top ( ) const

inline

        {   // return highest-priority element
        return (c.front());
        }

Member Data Documentation

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

_Container priority_queue< _Ty, _Container, _Pr >::c

protected

template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>

_Pr priority_queue< _Ty, _Container, _Pr >::comp

protected

---

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

• VS2015/inc/queue