std::map< Tk, Tv, TAllocator > Template-Klassenreferenz

#include <map.hpp>

Öffentliche Typen
using	key_type = Tk
using	data_type = Tv
using	value_type = map_pair< Tk, Tv >
using	tree_type = rb_tree_base< map_traits< Tk, Tv > >
using	size_type = tree_type::size_type
using	iterator = node_iterator< typename tree_type::node *, value_type *, value_type & >
using	const_iterator = node_iterator< typename tree_type::node *, const value_type *, const value_type & >
using	allocator_type = TAllocator

Öffentliche Methoden
	map (const allocator_type &allocator=allocator_type())
template<typename TInputIterator >
	map (TInputIterator dataBegin, TInputIterator dataEnd, const allocator_type &allocator=allocator_type())
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
data_type &	operator[] (const key_type &key)
iterator	insert (const value_type &v)
iterator	find (const key_type &key)
size_type	erase (const key_type &key)
void	clear ()
void	swap (map &other)
bool	empty () const
size_type	size () const

Ausführliche Beschreibung

template<typename Tk, typename Tv, class TAllocator = std::allocator>
class std::map< Tk, Tv, TAllocator >

Dokumentation der benutzerdefinierten Datentypen

allocator_type

template<typename Tk , typename Tv , class TAllocator = std::allocator>

using std::map< Tk, Tv, TAllocator >::allocator_type = TAllocator

const_iterator

template<typename Tk , typename Tv , class TAllocator = std::allocator>

using std::map< Tk, Tv, TAllocator >::const_iterator = node_iterator<typename tree_type::node*, const value_type*, const value_type&>

data_type

template<typename Tk , typename Tv , class TAllocator = std::allocator>

using std::map< Tk, Tv, TAllocator >::data_type = Tv

iterator

template<typename Tk , typename Tv , class TAllocator = std::allocator>

using std::map< Tk, Tv, TAllocator >::iterator = node_iterator<typename tree_type::node*, value_type*, value_type&>

key_type

template<typename Tk , typename Tv , class TAllocator = std::allocator>

using std::map< Tk, Tv, TAllocator >::key_type = Tk

size_type

template<typename Tk , typename Tv , class TAllocator = std::allocator>

using std::map< Tk, Tv, TAllocator >::size_type = tree_type::size_type

tree_type

template<typename Tk , typename Tv , class TAllocator = std::allocator>

using std::map< Tk, Tv, TAllocator >::tree_type = rb_tree_base<map_traits<Tk, Tv> >

value_type

template<typename Tk , typename Tv , class TAllocator = std::allocator>

using std::map< Tk, Tv, TAllocator >::value_type = map_pair<Tk, Tv>

Beschreibung der Konstruktoren und Destruktoren

map() [1/2]

template<typename Tk , typename Tv , class TAllocator = std::allocator>

std::map< Tk, Tv, TAllocator >::map ( const allocator_type &  allocator = allocator_type() )

inlineexplicit

            :  m_tree(allocator) 
        {
     
        }

map() [2/2]

template<typename Tk , typename Tv , class TAllocator = std::allocator>

template<typename TInputIterator >

std::map< Tk, Tv, TAllocator >::map ( TInputIterator  dataBegin, TInputIterator  dataEnd, const allocator_type &  allocator = allocator_type()  )

inline

            : m_tree(allocator)
        {
            TInputIterator it = dataBegin;
            while (it != dataEnd)
            {
                insert(*it);
                ++it;
            }
        }

Dokumentation der Elementfunktionen

begin() [1/2]

template<typename Tk , typename Tv , class TAllocator = std::allocator>

iterator std::map< Tk, Tv, TAllocator >::begin ( )

inline

        { 
            return iterator(m_tree.get_begin_node(), this); 
        }

begin() [2/2]

template<typename Tk , typename Tv , class TAllocator = std::allocator>

const_iterator std::map< Tk, Tv, TAllocator >::begin ( ) const

inline

        { 
            return const_iterator(m_tree.get_begin_node(), this); 
        }

clear()

template<typename Tk , typename Tv , class TAllocator = std::allocator>

void std::map< Tk, Tv, TAllocator >::clear ( )

inline

{ m_tree.clear(); }

empty()

template<typename Tk , typename Tv , class TAllocator = std::allocator>

bool std::map< Tk, Tv, TAllocator >::empty ( ) const

inline

        { 
            return m_tree.empty();
        }

end() [1/2]

template<typename Tk , typename Tv , class TAllocator = std::allocator>

iterator std::map< Tk, Tv, TAllocator >::end ( )

inline

        { 
            return iterator(0, this); 
        }

end() [2/2]

template<typename Tk , typename Tv , class TAllocator = std::allocator>

const_iterator std::map< Tk, Tv, TAllocator >::end ( ) const

inline

        { 
            return const_iterator(0, this); 
        }

erase()

template<typename Tk , typename Tv , class TAllocator = std::allocator>

size_type std::map< Tk, Tv, TAllocator >::erase ( const key_type &  key )

inline

        {
            return m_tree.erase(key);
        }

find()

template<typename Tk , typename Tv , class TAllocator = std::allocator>

iterator std::map< Tk, Tv, TAllocator >::find ( const key_type &  key )

inline

        {
            return iterator(m_tree.find_node(key), this);
        }

insert()

template<typename Tk , typename Tv , class TAllocator = std::allocator>

iterator std::map< Tk, Tv, TAllocator >::insert ( const value_type &  v )

inline

        {
            typename tree_type::node* n = m_tree.insert(v);
            return iterator(n, this);
        }

operator[]()

template<typename Tk , typename Tv , class TAllocator = std::allocator>

data_type& std::map< Tk, Tv, TAllocator >::operator[] ( const key_type &  key )

inline

        {
            typename tree_type::node* n = m_tree.find_node(key);
            if (n == 0)
                n = m_tree.insert(value_type(key, Tv()));
            return n->value.second;
        }

size()

template<typename Tk , typename Tv , class TAllocator = std::allocator>

size_type std::map< Tk, Tv, TAllocator >::size ( ) const

inline

        { 
            return m_tree.size();
        }

swap()

template<typename Tk , typename Tv , class TAllocator = std::allocator>

void std::map< Tk, Tv, TAllocator >::swap ( map< Tk, Tv, TAllocator > &  other )

inline

        {
            m_tree.swap(other.m_tree);
        }

---

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

• include/map.hpp