stack< _Ty, _Container > Class Template Reference

Public Types
typedef stack< _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
	stack ()
	stack (const _Myt &_Right)
	stack (const _Container &_Cont)
_Myt &	operator= (const _Myt &_Right)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	stack (const _Alloc &_Al)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	stack (const _Myt &_Right, const _Alloc &_Al)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	stack (const _Container &_Cont, const _Alloc &_Al)
	stack (_Myt &&_Right) _NOEXCEPT_OP(is_nothrow_move_constructible< _Container >
	stack (_Container &&_Cont)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	stack (_Myt &&_Right, const _Alloc &_Al)
template<class _Alloc , class = typename enable_if<uses_allocator<_Container, _Alloc>::value, void>::type>
	stack (_Container &&_Cont, 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	top ()
const_reference	top () 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 stack<_Ty, _Container> stack< _Ty, _Container >::_Myt

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

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

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

typedef _Container stack< _Ty, _Container >::container_type

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

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

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

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

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

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

Constructor & Destructor Documentation

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

stack< _Ty, _Container >::stack ( )

inline

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

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

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

inline

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

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

stack< _Ty, _Container >::stack ( 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>

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

inlineexplicit

        : c(_Al)
        {   // construct with allocator
        }

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

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

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

inline

        : c(_Right.c, _Al)
        {   // 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>

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

inline

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

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

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

inline

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

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

stack< _Ty, _Container >::stack ( _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>

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

inline

        : c(_STD move(_Right.c), _Al)
        {   // 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>

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

inline

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

Member Function Documentation

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

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

inline

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

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

template<class... _Valty>

void stack< _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 stack< _Ty, _Container >::empty ( ) const

inline

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

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

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

inline

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

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

_Myt& stack< _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 stack< _Ty, _Container >::pop ( )

inline

        {   // erase last element
        c.pop_back();
        }

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

void stack< _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 stack< _Ty, _Container >::push ( const value_type &  _Val )

inline

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

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

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

inline

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

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

void stack< _Ty, _Container >::swap

(

_Myt &

_Right

)

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

reference stack< _Ty, _Container >::top ( )

inline

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

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

const_reference stack< _Ty, _Container >::top ( ) const

inline

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

Member Data Documentation

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

void _Right stack< _Ty, _Container >::c

Initial value:

{   
        _Swap_adl(c, _Right.c)

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

_Container stack< _Ty, _Container >::c

protected

---

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

• VS2013/inc/stack