std::fixed_sorted_vector< TKey, TValue, TCapacity, TGrowOnOverflow, TCompare, TAllocator > Template-Klassenreferenz

#include <fixed_sorted_vector.hpp>

Klassendiagramm für std::fixed_sorted_vector< TKey, TValue, TCapacity, TGrowOnOverflow, TCompare, TAllocator >:

Zusammengehörigkeiten von std::fixed_sorted_vector< TKey, TValue, TCapacity, TGrowOnOverflow, TCompare, TAllocator >:

Ö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
	fixed_sorted_vector (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

Ausführliche Beschreibung

template<typename TKey, typename TValue, int TCapacity, bool TGrowOnOverflow, class TCompare = std::less<TKey>, class TAllocator = std::allocator>
class std::fixed_sorted_vector< TKey, TValue, TCapacity, TGrowOnOverflow, TCompare, TAllocator >

Dokumentation der benutzerdefinierten Datentypen

allocator_type

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::allocator_type = Base::allocator_type

inherited

const_iterator

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::const_iterator = Base::const_iterator

inherited

iterator

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::iterator = Base::iterator

inherited

key_type

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::key_type = TKey

inherited

mapped_type

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::mapped_type = TValue

inherited

size_type

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::size_type = Base::size_type

inherited

value_type

using std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::value_type = Base::value_type

inherited

Beschreibung der Konstruktoren und Destruktoren

fixed_sorted_vector()

template<typename TKey , typename TValue , int TCapacity, bool TGrowOnOverflow, class TCompare = std::less<TKey>, class TAllocator = std::allocator>

std::fixed_sorted_vector< TKey, TValue, TCapacity, TGrowOnOverflow, TCompare, TAllocator >::fixed_sorted_vector ( const allocator_type &  allocator = allocator_type() )

inlineexplicit

            : sorted_vector(allocator)
        {
        }

Dokumentation der Elementfunktionen

erase() [1/2]

iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::erase ( iterator  it )

inlineinherited

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

erase() [2/2]

size_type std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::erase ( const key_type &  k )

inlineinherited

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

find() [1/2]

iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::find ( const key_type &  k )

inlineinherited

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

find() [2/2]

const_iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::find ( const key_type &  k ) const

inlineinherited

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

insert() [1/2]

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

inlineinherited

        {
            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]

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

inlineinherited

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

lower_bound() [1/2]

iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::lower_bound ( const key_type &  k )

inlineinherited

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

lower_bound() [2/2]

const_iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::lower_bound ( const key_type &  k ) const

inlineinherited

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

upper_bound() [1/2]

iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::upper_bound ( const key_type &  k )

inlineinherited

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

upper_bound() [2/2]

const_iterator std::sorted_vector< TKey, TValue, TCompare, TAllocator, fixed_vector_storage< pair< TKey, TValue >, TAllocator, TCapacity, TGrowOnOverflow > >::upper_bound ( const key_type &  k ) const

inlineinherited

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

---

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

• include/fixed_sorted_vector.hpp