std::list< T, TAllocator > Template-Klassenreferenz

#include <list.hpp>

Öffentliche Typen
typedef T	value_type
typedef TAllocator	allocator_type
typedef int	size_type
typedef node_iterator< node *, T *, T & >	iterator
typedef node_iterator< const node *, const T *, const T & >	const_iterator

Öffentliche Methoden
	list (const allocator_type &allocator=allocator_type())
template<class InputIterator >
	list (InputIterator first, InputIterator last, const allocator_type &allocator=allocator_type())
	list (const list &rhs, const allocator_type &allocator=allocator_type())
	~list ()
list &	operator= (const list &rhs)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
const T &	front () const
T &	front ()
const T &	back () const
T &	back ()
void	push_front (const T &value)
void	pop_front ()
void	push_back (const T &value)
void	pop_back ()
iterator	insert (iterator pos, const T &value)
iterator	erase (iterator it)
iterator	erase (iterator first, iterator last)
template<class InputIterator >
void	assign (InputIterator first, InputIterator last)
bool	empty () const
void	clear ()
size_type	size () const
const allocator_type &	get_allocator () const
void	set_allocator (const allocator_type &allocator)

Statische öffentliche Attribute
static const size_t	kNodeSize = sizeof(node)

Ausführliche Beschreibung

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

Dokumentation der benutzerdefinierten Datentypen

allocator_type

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

typedef TAllocator std::list< T, TAllocator >::allocator_type

const_iterator

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

typedef node_iterator<const node*, const T*, const T&> std::list< T, TAllocator >::const_iterator

iterator

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

typedef node_iterator<node*, T*, T&> std::list< T, TAllocator >::iterator

size_type

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

typedef int std::list< T, TAllocator >::size_type

value_type

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

typedef T std::list< T, TAllocator >::value_type

Beschreibung der Konstruktoren und Destruktoren

list() [1/3]

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

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

inlineexplicit

                    : m_allocator(allocator)
            {
                    m_root.reset();
            }

list() [2/3]

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

template<class InputIterator >

std::list< T, TAllocator >::list ( InputIterator  first, InputIterator  last, const allocator_type &  allocator = allocator_type()  )

inline

                    : m_allocator(allocator)
            {
                    m_root.reset();
                    assign(first, last);
            }

list() [3/3]

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

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

inline

                    : m_allocator(allocator)
            {
                    m_root.reset();
                    assign(rhs.begin(), rhs.end());
            }

~list()

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

std::list< T, TAllocator >::~list ( )

inline

            {
                    clear();
            }

Dokumentation der Elementfunktionen

assign()

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

template<class InputIterator >

void std::list< T, TAllocator >::assign ( InputIterator  first, InputIterator  last  )

inline

            {
                clear();
                while (first != last)
                {
                        push_back(*first);
                        ++first;
                }
            }

back() [1/2]

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

const T& std::list< T, TAllocator >::back ( ) const

inline

            { 
                    assert(!empty()); return upcast(m_root.prev)->value; 
            }

back() [2/2]

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

T& std::list< T, TAllocator >::back ( )

inline

            { 
                    assert(!empty()); return upcast(m_root.prev)->value; 
            }

begin() [1/2]

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

iterator std::list< T, TAllocator >::begin ( )

inline

            { 
                    return iterator(upcast(m_root.next)); 
            }

begin() [2/2]

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

const_iterator std::list< T, TAllocator >::begin ( ) const

inline

            { 
                    return const_iterator(upcast(m_root.next)); 
            }

clear()

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

void std::list< T, TAllocator >::clear ( )

inline

            {
                    node* it = upcast(m_root.next);
                    while (it != &m_root)
                    {
                            node* nextIt = upcast(it->next);
                            destruct_node(it);
                            it = nextIt;
                    }
                    m_root.reset();
            }

empty()

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

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

inline

            { 
                    return !m_root.in_list(); 
            }

end() [1/2]

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

iterator std::list< T, TAllocator >::end ( )

inline

            {   
                    return iterator(&m_root); 
            }

end() [2/2]

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

const_iterator std::list< T, TAllocator >::end ( ) const

inline

            { 
                    return const_iterator(&m_root); 
            }

erase() [1/2]

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

iterator std::list< T, TAllocator >::erase ( iterator  it )

inline

            {
                assert(it.node()->in_list());
                iterator itErase(it);
                ++it;
                itErase.node()->unlink();
                destruct_node(itErase.node());
                return it;
            }

erase() [2/2]

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

iterator std::list< T, TAllocator >::erase ( iterator  first, iterator  last  )

inline

            {
                while (first != last)
                        first = erase(first);
                return first;
            }

front() [1/2]

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

const T& std::list< T, TAllocator >::front ( ) const

inline

            { 
                    assert(!empty()); 
                    return upcast(m_root.next)->value; 
            }

front() [2/2]

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

T& std::list< T, TAllocator >::front ( )

inline

            { 
                    assert(!empty());
                    return upcast(m_root.next)->value; 
            }

get_allocator()

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

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

inline

            { 
                    return m_allocator; 
            }

insert()

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

iterator std::list< T, TAllocator >::insert ( iterator  pos, const T &  value  )

inline

            {
                node* newNode = construct_node(value);
                newNode->link_before(pos.node());
                return iterator(newNode);
            }

operator=()

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

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

inline

            {
                    if (this != &rhs)
                    {
                            assign(rhs.begin(), rhs.end());
                    }
                    return *this;
            }

pop_back()

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

void std::list< T, TAllocator >::pop_back ( )

inline

            {
                assert(!empty());
                node* backNode = upcast(m_root.prev);
                backNode->unlink();
                destruct_node(backNode);
            }

pop_front()

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

void std::list< T, TAllocator >::pop_front ( )

inline

            {
                assert(!empty());
                node* frontNode = upcast(m_root.next);
                frontNode->unlink();
                destruct_node(frontNode);
            }

push_back()

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

void std::list< T, TAllocator >::push_back ( const T &  value )

inline

            {
                node* newNode = construct_node(value);
                newNode->link_before(&m_root);
            }

push_front()

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

void std::list< T, TAllocator >::push_front ( const T &  value )

inline

            {
                node* newNode = construct_node(value);
                newNode->link_before(m_root.next);
            }

set_allocator()

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

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

inline

            {
                    m_allocator = allocator;
            }

size()

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

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

inline

            {
                const node* it = upcast(m_root.next);
                size_type size(0);
                while (it != &m_root)
                {
                        ++size;
                        it = upcast(it->next);
                }
                return size;
            }

Dokumentation der Datenelemente

kNodeSize

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

const size_t std::list< T, TAllocator >::kNodeSize = sizeof(node)

static

---

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

• include/list.hpp