std::fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator > Template-Klassenreferenz

#include <fixed_vector.hpp>

Klassendiagramm für std::fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator >:

Zusammengehörigkeiten von std::fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator >:

Öffentliche Typen
using	iterator = T *
using	const_iterator = const T *

Öffentliche Methoden
	fixed_vector (const allocator_type &allocator=allocator_type())
	fixed_vector (size_type initialSize, const allocator_type &allocator=allocator_type())
	fixed_vector (const T *first, const T *last, const allocator_type &allocator=allocator_type())
	fixed_vector (const fixed_vector &rhs, const allocator_type &allocator=allocator_type())
	fixed_vector (e_noinitialize n)
fixed_vector &	operator= (const fixed_vector &rhs)
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
T *	data ()
const T *	data () const
T &	front ()
const T &	front () const
T &	back ()
const T &	back () const
T &	operator[] (size_type i)
const T &	operator[] (size_type i) const
T &	at (size_type i)
const T &	at (size_type i) const
void	push_back (const T &v)
void	push_back ()
void	pop_back ()
void	assign (const T *first, const T *last)
void	insert (size_type index, size_type n, const T &val)
void	insert (iterator it, size_type n, const T &val)
iterator	insert (iterator it, const T &val)
iterator	erase (iterator it)
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 T &item, size_type index=0) const
iterator	find (const T &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 öffentliche Attribute
static const size_type	kInitialCapacity
static const size_type	npos = size_type(-1)

Ausführliche Beschreibung

template<typename T, int TCapacity, bool TGrowOnOverflow, class TAllocator = std::allocator>
class std::fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator >

Dokumentation der benutzerdefinierten Datentypen

const_iterator

using std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::const_iterator = const T*

inherited

iterator

using std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::iterator = T*

inherited

Beschreibung der Konstruktoren und Destruktoren

fixed_vector() [1/5]

template<typename T , int TCapacity, bool TGrowOnOverflow, class TAllocator = std::allocator>

std::fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator >::fixed_vector ( const allocator_type &  allocator = allocator_type() )

inlineexplicit

            : base_vector(allocator)
        {
        }

fixed_vector() [2/5]

template<typename T , int TCapacity, bool TGrowOnOverflow, class TAllocator = std::allocator>

std::fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator >::fixed_vector ( size_type  initialSize, const allocator_type &  allocator = allocator_type()  )

inlineexplicit

            : base_vector(initialSize, allocator)
        {
        }

fixed_vector() [3/5]

template<typename T , int TCapacity, bool TGrowOnOverflow, class TAllocator = std::allocator>

std::fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator >::fixed_vector ( const T *  first, const T *  last, const allocator_type &  allocator = allocator_type()  )

inline

            : base_vector(first, last, allocator)
        {
        }

fixed_vector() [4/5]

template<typename T , int TCapacity, bool TGrowOnOverflow, class TAllocator = std::allocator>

std::fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator >::fixed_vector ( const fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator > &  rhs, const allocator_type &  allocator = allocator_type()  )

inline

            : base_vector(rhs, allocator)
        {
        }

fixed_vector() [5/5]

template<typename T , int TCapacity, bool TGrowOnOverflow, class TAllocator = std::allocator>

std::fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator >::fixed_vector ( e_noinitialize  n )

inlineexplicit

            : base_vector(n)
        {
        }

Dokumentation der Elementfunktionen

assign()

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::assign ( const T *  first, const T *  last  )

inlineinherited

    {
        assert(!validate_iterator(first));
        assert(!validate_iterator(last));

        const size_type count = size_type(last - first);
        assert(count > 0);
        clear();
        if (m_begin + count > m_capacityEnd)
                reallocate_discard_old(compute_new_capacity(count));

        std::copy_n(first, count, m_begin);
        m_end = m_begin + count;
        TStorage::record_high_watermark();
        assert(invariant());
    }

at() [1/2]

T& std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::at ( size_type  i )

inlineinherited

        {
            assert(i < size());
            return m_begin[i];
        }

at() [2/2]

const T& std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::at ( size_type  i ) const

inlineinherited

    {
        assert(i < size());
        return m_begin[i];
    }

back() [1/2]

T& std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::back ( )

inlineinherited

        {
            assert(!empty());
            return *(end() - 1);
        }

back() [2/2]

const T& std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::back ( ) const

inlineinherited

        {
            assert(!empty());
            return *(end() - 1);
        }

begin() [1/2]

iterator std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::begin ( )

inlineinherited

        { 
            return m_begin; 
        }

begin() [2/2]

const_iterator std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::begin ( ) const

inlineinherited

        { 
            return m_begin; 
        }

capacity()

size_type std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::capacity ( ) const

inlineinherited

        { 
            return size_type(m_capacityEnd - m_begin); 
        }

clear()

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::clear ( )

inlineinherited

    {
        shrink(0);
        assert(invariant());
    }

copy()

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::copy ( const vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > > &  rhs )

inlineinherited

        {
            const size_type newSize = rhs.size();
            if (newSize > capacity())
            {
                    reallocate_discard_old(rhs.capacity());
            }
            std::copy_construct_n(rhs.m_begin, newSize, m_begin);
            m_end = m_begin + newSize;
            TStorage::record_high_watermark();
            assert(invariant());
        }

data() [1/2]

T* std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::data ( )

inlineinherited

        { 
            return empty() ? 0 : m_begin; 
        }

data() [2/2]

const T* std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::data ( ) const

inlineinherited

        { 
            return empty() ? 0 : m_begin; 
        }

empty()

bool std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::empty ( ) const

inlineinherited

        { 
            return m_begin == m_end; 
        }

end() [1/2]

iterator std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::end ( )

inlineinherited

        { 
            return m_end; 
        }

end() [2/2]

const_iterator std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::end ( ) const

inlineinherited

        { 
            return m_end; 
        }

erase() [1/2]

iterator std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::erase ( iterator  it )

inlineinherited

    {
        assert(validate_iterator(it));
        assert(it != end());
        assert(invariant());

        // Move everything down, overwriting *it
        if (it + 1 < m_end)
        {
                move_down_1(it, int_to_type<has_trivial_copy<T>::value>());
        }
        --m_end;
        std::destruct(m_end);
        return it;
    }

erase() [2/2]

iterator std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::erase ( iterator  first, iterator  last  )

inlineinherited

    {
        assert(validate_iterator(first));
        assert(validate_iterator(last));
        assert(invariant());
        if (last <= first)
                return end();
        
        const size_type indexFirst = size_type(first - m_begin);
        const size_type toRemove = size_type(last - first);
        if (toRemove > 0)
        {
                move_down(last, first, int_to_type<has_trivial_copy<T>::value>());
                shrink(size() - toRemove);
        }
        return m_begin + indexFirst;
    }

erase_unostdred()

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::erase_unostdred ( iterator  it )

inlineinherited

    {
        assert(validate_iterator(it));
        assert(it != end());
        assert(invariant());
        const iterator itNewEnd = end() - 1;
        if (it != itNewEnd)
                *it = *itNewEnd;
        pop_back();
    }

find()

iterator std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::find ( const T &  item )

inlineinherited

    {
        iterator itEnd = end();
        for (iterator it = begin(); it != itEnd; ++it)
                if (*it == item)
                        return it;
        return itEnd;
    }

front() [1/2]

T& std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::front ( )

inlineinherited

        {
            assert(!empty());
            return *begin();
        }

front() [2/2]

const T& std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::front ( ) const

inlineinherited

        {
            assert(!empty());
            return *begin();
        }

get_allocator()

const allocator_type& std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::get_allocator ( ) const

inlineinherited

    { 
        return m_allocator; 
    }

get_high_watermark()

size_type std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::get_high_watermark ( ) const

inlineinherited

    {
        return TStorage::get_high_watermark();
    }

index_of()

size_type std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::index_of ( const T &  item, size_type  index = 0  ) const

inlineinherited

    {
        assert(index >= 0 && index < size());
        for ( ; index < size(); ++index)
                if (m_begin[index] == item)
                        return index;
        return npos;
    }

insert() [1/3]

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::insert ( size_type  index, size_type  n, const T &  val  )

inlineinherited

    {
        assert(invariant());
        const size_type indexEnd = index + n;
        const size_type prevSize = size();
        if (m_end + n > m_capacityEnd)
        {
            reallocate(compute_new_capacity(prevSize + n), prevSize);
        }
        if (indexEnd > prevSize)
        {
            const size_type numCopy         = prevSize - index;
            const size_type numAppend       = indexEnd - prevSize;
            assert(numCopy >= 0 && numAppend >= 0);
            assert(numAppend + numCopy == n);
            iterator itOut = m_begin + prevSize;
            for (size_type i = 0; i < numAppend; ++i, ++itOut)
                    std::copy_construct(itOut, val);
            std::copy_construct_n(m_begin + index, numCopy, itOut);
            for (size_type i = 0; i < numCopy; ++i)
                    m_begin[index + i] = val;
        }
        else
        {
            std::copy_construct_n(m_end - n, n, m_end);
            iterator insertPos = m_begin + index;
            std::move_n(insertPos, prevSize - indexEnd, insertPos + n);
            for (size_type i = 0; i < n; ++i)
                    insertPos[i] = val;
        }
        m_end += n; 
        TStorage::record_high_watermark();
    }

insert() [2/3]

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::insert ( iterator  it, size_type  n, const T &  val  )

inlineinherited

    {
        assert(validate_iterator(it));
        assert(invariant());
        insert(size_type(it - m_begin), n, val);
    }

insert() [3/3]

iterator std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::insert ( iterator  it, const T &  val  )

inlineinherited

    {
        assert(validate_iterator(it));
        assert(invariant());

        const size_type index = (size_type)(it - m_begin);
        if (m_end == m_capacityEnd)
        {
            grow();
            it = m_begin + index;
        }
        else
        {
            std::construct(m_end);
        }

        if (m_end > it)
        {
            if(!has_trivial_copy<T>::value)
            {
                const size_type prevSize = size();
                assert(index <= prevSize);
                const size_type toMove = prevSize - index;

                std::internal::move_n(it, toMove, it + 1, int_to_type<has_trivial_copy<T>::value>());
            }
            else
            {
                assert(it < m_end);
                const size_t n = reinterpret_cast<uintptr_t>(m_end) - reinterpret_cast<uintptr_t>(it);
                Sys::MemMove(it + 1, it, n);
            }
        }
        *it = val;
        ++m_end;
        assert(invariant());
        TStorage::record_high_watermark();
        return it;
    }

operator=()

template<typename T , int TCapacity, bool TGrowOnOverflow, class TAllocator = std::allocator>

fixed_vector& std::fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator >::operator= ( const fixed_vector< T, TCapacity, TGrowOnOverflow, TAllocator > &  rhs )

inline

        {
            if (&rhs != this)
            {
                base_vector::copy(rhs);
            }
            return *this;
        }

operator[]() [1/2]

T& std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::operator[] ( size_type  i )

inlineinherited

        {
            return at(i);
        }

operator[]() [2/2]

const T& std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::operator[] ( size_type  i ) const

inlineinherited

        {
            return at(i);
        }

pop_back()

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::pop_back ( )

inlineinherited

    {
        assert(!empty());
        --m_end;
        std::destruct(m_end);
    }

push_back() [1/2]

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::push_back ( const T &  v )

inlineinherited

    {
        if (m_end < m_capacityEnd)
        {
                std::copy_construct(m_end++, v);
        }
        else
        {
                grow();
                std::copy_construct(m_end++, v);
        }
        TStorage::record_high_watermark();
    }

push_back() [2/2]

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::push_back ( )

inlineinherited

    {
        if (m_end == m_capacityEnd)
                grow();
        std::construct(m_end);
        ++m_end;
        TStorage::record_high_watermark();
    }

reserve()

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::reserve ( size_type  n )

inlineinherited

    {
        if (n > capacity())                     
            reallocate(n, size());
    }

reset()

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::reset ( )

inlineinherited

    {
        TStorage::reset();
        assert(invariant());
    }

resize()

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::resize ( size_type  n )

inlineinherited

    {
        if (n > size())
            insert(m_end, n - size(), value_type());
        else
            shrink(n);
    }

set_allocator()

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::set_allocator ( const allocator_type &  allocator )

inlineinherited

    {
        m_allocator = allocator;
    }

set_capacity()

void std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::set_capacity ( size_type  newCapacity )

inlineinherited

    {
        reallocate(newCapacity, size());
    }

size()

size_type std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::size ( ) const

inlineinherited

        { 
            return size_type(m_end - m_begin); 
        }

validate_iterator()

bool std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::validate_iterator ( const_iterator  it ) const

inlineinherited

    {
        return it >= begin() && it <= end();
    }

Dokumentation der Datenelemente

kInitialCapacity

const size_type std::vector< T, TAllocator, fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > >::kInitialCapacity

staticinherited

npos

const size_type std::base_vector::npos = size_type(-1)

staticinherited

---

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

• include/fixed_vector.hpp