std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage > Template-Klassenreferenz

#include <sorted_vector.hpp>

Klassendiagramm für std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >:

Zusammengehörigkeiten von std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >:

Öffentliche Typen
using	key_type = TKey
using	mapped_type = TValue
using	size_type = Base::size_type
using	value_type = Base::value_type
using	iterator = Base::iterator
using	const_iterator = Base::const_iterator
using	allocator_type = Base::allocator_type

Öffentliche Methoden
	sorted_vector (const allocator_type &allocator=allocator_type())
template<class InputIterator >
	sorted_vector (InputIterator first, InputIterator last, const allocator_type &allocator=allocator_type())
pair< iterator, bool >	insert (const value_type &val)
pair< iterator, bool >	insert (const key_type &k, const mapped_type &v)
iterator	find (const key_type &k)
const_iterator	find (const key_type &k) const
iterator	erase (iterator it)
size_type	erase (const key_type &k)
iterator	lower_bound (const key_type &k)
const_iterator	lower_bound (const key_type &k) const
iterator	upper_bound (const key_type &k)
const_iterator	upper_bound (const key_type &k) const

Private Methoden
void	copy (const vector &rhs)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
size_type	size () const
bool	empty () const
size_type	capacity () const
pair< TKey, TValue > *	data ()
const pair< TKey, TValue > *	data () const
pair< TKey, TValue > &	front ()
const pair< TKey, TValue > &	front () const
pair< TKey, TValue > &	back ()
const pair< TKey, TValue > &	back () const
pair< TKey, TValue > &	operator[] (size_type i)
const pair< TKey, TValue > &	operator[] (size_type i) const
pair< TKey, TValue > &	at (size_type i)
const pair< TKey, TValue > &	at (size_type i) const
void	push_back (const pair< TKey, TValue > &v)
void	push_back ()
void	pop_back ()
void	assign (const pair< TKey, TValue > *first, const pair< TKey, TValue > *last)
void	insert (size_type index, size_type n, const pair< TKey, TValue > &val)
void	insert (iterator it, size_type n, const pair< TKey, TValue > &val)
iterator	insert (iterator it, const pair< TKey, TValue > &val)
iterator	erase (iterator first, iterator last)
void	erase_unostdred (iterator it)
void	resize (size_type n)
void	reserve (size_type n)
void	clear ()
void	reset ()
void	set_capacity (size_type newCapacity)
size_type	index_of (const pair< TKey, TValue > &item, size_type index=0) const
iterator	find (const pair< TKey, TValue > &item)
const allocator_type &	get_allocator () const
void	set_allocator (const allocator_type &allocator)
bool	validate_iterator (const_iterator it) const
size_type	get_high_watermark () const

Statische, private Attribute
static const size_type	kInitialCapacity
static const size_type	npos = size_type(-1)

Ausführliche Beschreibung

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>
class std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >

Dokumentation der benutzerdefinierten Datentypen

allocator_type

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::allocator_type = Base::allocator_type

const_iterator

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::const_iterator = Base::const_iterator

iterator

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::iterator = Base::iterator

key_type

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::key_type = TKey

mapped_type

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::mapped_type = TValue

size_type

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::size_type = Base::size_type

value_type

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::value_type = Base::value_type

Beschreibung der Konstruktoren und Destruktoren

sorted_vector() [1/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::sorted_vector ( const allocator_type &  allocator = allocator_type() )

inlineexplicit

            : Base(allocator)
        {
        }

sorted_vector() [2/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

template<class InputIterator >

std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::sorted_vector ( InputIterator  first, InputIterator  last, const allocator_type &  allocator = allocator_type()  )

inline

            : Base(first, last, allocator)
        {
            std::quick_sort(begin(), end(), m_compare);
            assert(invariant());
        }

Dokumentation der Elementfunktionen

erase() [1/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::erase ( iterator  it )

inline

        {
            assert(invariant());
            return Base::erase(it);
        }

erase() [2/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

size_type std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::erase ( const key_type &  k )

inline

        {
            iterator i(find(k));
            if (i == end()) 
                return 0;
            erase(i);
            assert(invariant());
            return 1;
        }

find() [1/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::find ( const key_type &  k )

inline

        {
            assert(invariant());
            iterator i(lower_bound(k));
            if (i != end() && m_compare(k, *i))
            {
                i = end();
            }
            return i;
        }

find() [2/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

const_iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::find ( const key_type &  k ) const

inline

        {       
            assert(invariant());
            const_iterator i(lower_bound(k));
            if (i != end() && m_compare(k, *i))
            {
                i = end();
            }
            return i;
        }

insert() [1/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

pair<iterator, bool> std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::insert ( const value_type &  val )

inline

        {
            assert(invariant());
            bool found(true);
            iterator it = lower_bound(val.first);
            assert(it == end() || !m_compare(*it, val));
            if (it == end() || m_compare(*it, val))
            {
                it = Base::insert(it, val);
                found = false;
            }
            assert(invariant());
            return pair<iterator, bool>(it, !found);
        }

insert() [2/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

pair<iterator, bool> std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::insert ( const key_type &  k, const mapped_type &  v  )

inline

        {
            return insert(value_type(k, v));
        }

lower_bound() [1/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::lower_bound ( const key_type &  k )

inline

        {
            return std::lower_bound(begin(), end(), k, m_compare);
        }

lower_bound() [2/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

const_iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::lower_bound ( const key_type &  k ) const

inline

        {
            return std::lower_bound(begin(), end(), k, m_compare);
        }

upper_bound() [1/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::upper_bound ( const key_type &  k )

inline

        {
            return std::upper_bound(begin(), end(), k, m_compare);
        }

upper_bound() [2/2]

template<typename TKey, typename TValue, class TCompare = std::less<TKey>, class TAllocator = std::allocator, class TStorage = std::standard_vector_storage<pair<TKey, TValue>, TAllocator>>

const_iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, TStorage >::upper_bound ( const key_type &  k ) const

inline

        {
            return std::upper_bound(begin(), end(), k, m_compare);
        }

---

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

• include/sorted_vector.hpp