std::stack< T, TAllocator, TContainer > Template-Klassenreferenz

#include <stack.hpp>

Öffentliche Typen
using	container_type = TContainer
using	value_type = TContainer::value_type
using	size_type = TContainer::size_type
using	allocator_type = TAllocator

Öffentliche Methoden
	stack (const allocator_type &allocator=allocator_type())
	stack (const stack &rhs, const allocator_type &allocator=allocator_type())
	stack (e_noinitialize n)
stack &	operator= (const stack &rhs)
void	push (const value_type &v)
void	pop ()
value_type &	top ()
const value_type &	top () const
void	clear ()
bool	empty () const
size_type	size () const
const allocator_type &	get_allocator () const
void	set_allocator (const allocator_type &allocator)

Ausführliche Beschreibung

template<typename T, class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>
class std::stack< T, TAllocator, TContainer >

Dokumentation der benutzerdefinierten Datentypen

allocator_type

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

using std::stack< T, TAllocator, TContainer >::allocator_type = TAllocator

container_type

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

using std::stack< T, TAllocator, TContainer >::container_type = TContainer

size_type

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

using std::stack< T, TAllocator, TContainer >::size_type = TContainer::size_type

value_type

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

using std::stack< T, TAllocator, TContainer >::value_type = TContainer::value_type

Beschreibung der Konstruktoren und Destruktoren

stack() [1/3]

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

std::stack< T, TAllocator, TContainer >::stack ( const allocator_type &  allocator = allocator_type() )

inlineexplicit

            : m_container(allocator)
        {
        }

stack() [2/3]

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

std::stack< T, TAllocator, TContainer >::stack ( const stack< T, TAllocator, TContainer > &  rhs, const allocator_type &  allocator = allocator_type()  )

inline

            : m_container(rhs, allocator)
        {
        }

stack() [3/3]

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

std::stack< T, TAllocator, TContainer >::stack ( e_noinitialize  n )

inlineexplicit

            : m_container(n)
        {
        }

Dokumentation der Elementfunktionen

clear()

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

void std::stack< T, TAllocator, TContainer >::clear ( )

inline

        { 
            m_container.clear(); 
        }

empty()

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

bool std::stack< T, TAllocator, TContainer >::empty ( ) const

inline

        { 
            return m_container.empty(); 
        }

get_allocator()

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

const allocator_type& std::stack< T, TAllocator, TContainer >::get_allocator ( ) const

inline

        { 
                return m_container.get_allocator(); 
        }

operator=()

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

stack& std::stack< T, TAllocator, TContainer >::operator= ( const stack< T, TAllocator, TContainer > &  rhs )

inline

        {
            if (&rhs != this)
            {
                m_container = rhs.m_container;
            }
            return *this;
        }

pop()

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

void std::stack< T, TAllocator, TContainer >::pop ( )

inline

        {
            m_container.pop_back();
        }

push()

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

void std::stack< T, TAllocator, TContainer >::push ( const value_type &  v )

inline

        {
            m_container.push_back(v);
        }

set_allocator()

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

void std::stack< T, TAllocator, TContainer >::set_allocator ( const allocator_type &  allocator )

inline

        {
                m_container.set_allocator(allocator);
        }

size()

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

size_type std::stack< T, TAllocator, TContainer >::size ( ) const

inline

        { 
            return m_container.size(); 
        }

top() [1/2]

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

value_type& std::stack< T, TAllocator, TContainer >::top ( )

inline

        { 
            return m_container.back(); 
        }

top() [2/2]

template<typename T , class TAllocator = std::allocator, class TContainer = std::vector<T, TAllocator>>

const value_type& std::stack< T, TAllocator, TContainer >::top ( ) const

inline

        { 
            return m_container.back(); 
        }

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/stack.hpp