std::vector< T, TAllocator, TStorage > Template-Klassenreferenz

#include <vector.hpp>

Klassendiagramm für std::vector< T, TAllocator, TStorage >:

Zusammengehörigkeiten von std::vector< T, TAllocator, TStorage >:

Öffentliche Typen
using	value_type = T
using	iterator = T *
using	const_iterator = const T *
using	allocator_type = TAllocator
using	size_type = int

Öffentliche Methoden
	vector (const allocator_type &allocator=allocator_type())
	vector (size_type initialSize, const allocator_type &allocator=allocator_type())
	vector (const T *first, const T *last, const allocator_type &allocator=allocator_type())
	vector (const vector &rhs, const allocator_type &allocator=allocator_type())
	vector (e_noinitialize n)
	~vector ()
vector &	operator= (const 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 = 16
static const size_type	npos = size_type(-1)

Ausführliche Beschreibung

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

Dokumentation der benutzerdefinierten Datentypen

allocator_type

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

using std::vector< T, TAllocator, TStorage >::allocator_type = TAllocator

const_iterator

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

using std::vector< T, TAllocator, TStorage >::const_iterator = const T*

iterator

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

using std::vector< T, TAllocator, TStorage >::iterator = T*

size_type

using std::base_vector::size_type = int

inherited

value_type

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

using std::vector< T, TAllocator, TStorage >::value_type = T

Beschreibung der Konstruktoren und Destruktoren

vector() [1/5]

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

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

inlineexplicit

            : TStorage(allocator)
        {
        }

vector() [2/5]

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

std::vector< T, TAllocator, TStorage >::vector ( size_type  initialSize, const allocator_type &  allocator = allocator_type()  )

inlineexplicit

            : TStorage(allocator)
        {
            resize(initialSize);
        }

vector() [3/5]

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

std::vector< T, TAllocator, TStorage >::vector ( const T *  first, const T *  last, const allocator_type &  allocator = allocator_type()  )

inline

            : TStorage(allocator)
        {
            assign(first, last);
        }

vector() [4/5]

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

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

inline

            : TStorage(allocator)
        {
            if(rhs.size() == 0) 
                return;
            this->reallocate_discard_old(rhs.capacity());
            std::copy_construct_n(rhs.m_begin, rhs.size(), m_begin);
            m_end = m_begin + rhs.size();
            TStorage::record_high_watermark();
            assert(invariant());
        }

vector() [5/5]

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

std::vector< T, TAllocator, TStorage >::vector ( e_noinitialize  n )

inlineexplicit

            : TStorage(n)
        {
        }

~vector()

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

std::vector< T, TAllocator, TStorage >::~vector ( )

inline

        {
            if (TStorage::m_begin != 0)
                TStorage::destroy(TStorage::m_begin, size());
        }

Dokumentation der Elementfunktionen

assign()

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

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

inline

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

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

T& std::vector< T, TAllocator, TStorage >::at ( size_type  i )

inline

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

at() [2/2]

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

const T& std::vector< T, TAllocator, TStorage >::at ( size_type  i ) const

inline

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

back() [1/2]

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

T& std::vector< T, TAllocator, TStorage >::back ( )

inline

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

back() [2/2]

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

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

inline

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

begin() [1/2]

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

iterator std::vector< T, TAllocator, TStorage >::begin ( )

inline

        { 
            return m_begin; 
        }

begin() [2/2]

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

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

inline

        { 
            return m_begin; 
        }

capacity()

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

size_type std::vector< T, TAllocator, TStorage >::capacity ( ) const

inline

        { 
            return size_type(m_capacityEnd - m_begin); 
        }

clear()

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

void std::vector< T, TAllocator, TStorage >::clear ( )

inline

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

copy()

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

void std::vector< T, TAllocator, TStorage >::copy ( const vector< T, TAllocator, TStorage > &  rhs )

inline

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

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

T* std::vector< T, TAllocator, TStorage >::data ( )

inline

        { 
            return empty() ? 0 : m_begin; 
        }

data() [2/2]

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

const T* std::vector< T, TAllocator, TStorage >::data ( ) const

inline

        { 
            return empty() ? 0 : m_begin; 
        }

empty()

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

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

inline

        { 
            return m_begin == m_end; 
        }

end() [1/2]

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

iterator std::vector< T, TAllocator, TStorage >::end ( )

inline

        { 
            return m_end; 
        }

end() [2/2]

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

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

inline

        { 
            return m_end; 
        }

erase() [1/2]

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

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

inline

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

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

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

inline

    {
        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()

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

void std::vector< T, TAllocator, TStorage >::erase_unostdred ( iterator  it )

inline

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

find()

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

iterator std::vector< T, TAllocator, TStorage >::find ( const T &  item )

inline

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

front() [1/2]

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

T& std::vector< T, TAllocator, TStorage >::front ( )

inline

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

front() [2/2]

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

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

inline

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

get_allocator()

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

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

inline

    { 
        return m_allocator; 
    }

get_high_watermark()

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

size_type std::vector< T, TAllocator, TStorage >::get_high_watermark ( ) const

inline

    {
        return TStorage::get_high_watermark();
    }

index_of()

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

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

inline

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

insert() [1/3]

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

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

inline

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

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

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

inline

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

insert() [3/3]

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

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

inline

    {
        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, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>

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

inline

        {
            copy(rhs);              
            return *this;
        }

operator[]() [1/2]

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

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

inline

        {
            return at(i);
        }

operator[]() [2/2]

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

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

inline

        {
            return at(i);
        }

pop_back()

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

void std::vector< T, TAllocator, TStorage >::pop_back ( )

inline

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

push_back() [1/2]

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

void std::vector< T, TAllocator, TStorage >::push_back ( const T &  v )

inline

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

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

void std::vector< T, TAllocator, TStorage >::push_back ( )

inline

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

reserve()

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

void std::vector< T, TAllocator, TStorage >::reserve ( size_type  n )

inline

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

reset()

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

void std::vector< T, TAllocator, TStorage >::reset ( )

inline

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

resize()

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

void std::vector< T, TAllocator, TStorage >::resize ( size_type  n )

inline

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

set_allocator()

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

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

inline

    {
        m_allocator = allocator;
    }

set_capacity()

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

void std::vector< T, TAllocator, TStorage >::set_capacity ( size_type  newCapacity )

inline

    {
        reallocate(newCapacity, size());
    }

size()

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

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

inline

        { 
            return size_type(m_end - m_begin); 
        }

validate_iterator()

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

bool std::vector< T, TAllocator, TStorage >::validate_iterator ( const_iterator  it ) const

inline

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

Dokumentation der Datenelemente

kInitialCapacity

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

const size_type std::vector< T, TAllocator, TStorage >::kInitialCapacity = 16

static

npos

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

staticinherited

---

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

• include/vector.hpp