std::standard_vector_storage< T, TAllocator > Template-Strukturreferenz

#include <vector.hpp>

Zusammengehörigkeiten von std::standard_vector_storage< T, TAllocator >:

Öffentliche Methoden
	standard_vector_storage (const TAllocator &allocator)
	standard_vector_storage (e_noinitialize)
void	reallocate (base_vector::size_type newCapacity, base_vector::size_type oldSize)
void	reallocate_discard_old (base_vector::size_type newCapacity)
void	destroy (T *ptr, base_vector::size_type n)
void	reset ()
bool	invariant () const
void	record_high_watermark ()

Öffentliche Attribute
T *	m_begin
T *	m_end
T *	m_capacityEnd
TAllocator	m_allocator

Ausführliche Beschreibung

template<typename T, class TAllocator>
struct std::standard_vector_storage< T, TAllocator >

Beschreibung der Konstruktoren und Destruktoren

standard_vector_storage() [1/2]

template<typename T, class TAllocator>

std::standard_vector_storage< T, TAllocator >::standard_vector_storage ( const TAllocator &  allocator )

inlineexplicit

            : m_begin(0), m_end(0), m_capacityEnd(0), m_allocator(allocator)
        {
        }       

standard_vector_storage() [2/2]

template<typename T, class TAllocator>

std::standard_vector_storage< T, TAllocator >::standard_vector_storage ( e_noinitialize  )

inlineexplicit

        {
        }

Dokumentation der Elementfunktionen

destroy()

template<typename T, class TAllocator>

void std::standard_vector_storage< T, TAllocator >::destroy ( T *  ptr, base_vector::size_type  n  )

inline

        {
            std::destruct_n(ptr, n);
            m_allocator.deallocate(ptr, n * sizeof(T));
        }

invariant()

template<typename T, class TAllocator>

bool std::standard_vector_storage< T, TAllocator >::invariant ( ) const

inline

        {
            return m_end >= m_begin;
        }

reallocate()

template<typename T, class TAllocator>

void std::standard_vector_storage< T, TAllocator >::reallocate ( base_vector::size_type  newCapacity, base_vector::size_type  oldSize  )

inline

        {
            T* newBegin = static_cast<T*>(m_allocator.allocate(newCapacity * sizeof(T)));
            const base_vector::size_type newSize = oldSize < newCapacity ? oldSize : newCapacity;
            // Copy old data if needed.
            if (m_begin)
            {
                    std::copy_construct_n(m_begin, newSize, newBegin);
                    destroy(m_begin, oldSize);
            }
            m_begin = newBegin;
            m_end = m_begin + newSize;
            m_capacityEnd = m_begin + newCapacity;
            assert(invariant());
        }

reallocate_discard_old()

template<typename T, class TAllocator>

void std::standard_vector_storage< T, TAllocator >::reallocate_discard_old ( base_vector::size_type  newCapacity )

inline

        {
            assert(newCapacity > base_vector::size_type(m_capacityEnd - m_begin));
            T* newBegin = static_cast<T*>(m_allocator.allocate(newCapacity * sizeof(T)));
            const base_vector::size_type currSize((base_vector::size_type)(m_end - m_begin));
            if (m_begin)
                    destroy(m_begin, currSize);
            m_begin = newBegin;
            m_end = m_begin + currSize;
            m_capacityEnd = m_begin + newCapacity;
            assert(invariant());
        }

record_high_watermark()

template<typename T, class TAllocator>

void std::standard_vector_storage< T, TAllocator >::record_high_watermark ( )

inline

        {
        }

reset()

template<typename T, class TAllocator>

void std::standard_vector_storage< T, TAllocator >::reset ( )

inline

        {
            if (m_begin)
                m_allocator.deallocate(m_begin, (m_end - m_begin) * sizeof(T));

            m_begin = m_end = 0;
            m_capacityEnd = 0;
        }

Dokumentation der Datenelemente

m_allocator

template<typename T, class TAllocator>

TAllocator std::standard_vector_storage< T, TAllocator >::m_allocator

m_begin

template<typename T, class TAllocator>

T* std::standard_vector_storage< T, TAllocator >::m_begin

m_capacityEnd

template<typename T, class TAllocator>

T* std::standard_vector_storage< T, TAllocator >::m_capacityEnd

m_end

template<typename T, class TAllocator>

T* std::standard_vector_storage< T, TAllocator >::m_end

---

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

• include/vector.hpp