std::ring_buffer< T, TAllocator > Template-Klassenreferenz

#include <ringbuffer.hpp>

Öffentliche Typen
using	value_type = T
using	pointer = T *
using	const_pointer = const T *
using	reference = T &
using	const_reference = const T &
using	size_type = size_t
using	difference_type = ptrdiff_t
using	allocator_type = TAllocator
using	iterator = ring_buffer_iterator< ring_buffer< T, TAllocator >, value_type >
using	const_iterator = ring_buffer_iterator< ring_buffer< T, TAllocator >, const value_type >

Öffentliche Methoden
	ring_buffer (size_t capacity=100)
	~ring_buffer ()
void	clear ()
void	push_back (const value_type &item)
reference	pop_front ()
const_reference	pop_front () const
iterator	begin ()
iterator	end ()
const_iterator	begin ()
const_iterator	end ()
reference	front ()
const_reference	front () const
const_reference	back () const
reference	back ()
size_type	size () const
size_type	capacity () const
bool	empty () const
bool	full () const
size_type	max () const

Ausführliche Beschreibung

template<class T, class TAllocator = std::allocator>
class std::ring_buffer< T, TAllocator >

Dokumentation der benutzerdefinierten Datentypen

allocator_type

template<class T , class TAllocator = std::allocator>

using std::ring_buffer< T, TAllocator >::allocator_type = TAllocator

const_iterator

template<class T , class TAllocator = std::allocator>

using std::ring_buffer< T, TAllocator >::const_iterator = ring_buffer_iterator<ring_buffer<T, TAllocator>, const value_type>

const_pointer

template<class T , class TAllocator = std::allocator>

using std::ring_buffer< T, TAllocator >::const_pointer = const T*

const_reference

template<class T , class TAllocator = std::allocator>

using std::ring_buffer< T, TAllocator >::const_reference = const T&

difference_type

template<class T , class TAllocator = std::allocator>

using std::ring_buffer< T, TAllocator >::difference_type = ptrdiff_t

iterator

template<class T , class TAllocator = std::allocator>

using std::ring_buffer< T, TAllocator >::iterator = ring_buffer_iterator<ring_buffer<T, TAllocator>, value_type>

pointer

template<class T , class TAllocator = std::allocator>

using std::ring_buffer< T, TAllocator >::pointer = T*

reference

template<class T , class TAllocator = std::allocator>

using std::ring_buffer< T, TAllocator >::reference = T&

size_type

template<class T , class TAllocator = std::allocator>

using std::ring_buffer< T, TAllocator >::size_type = size_t

value_type

template<class T , class TAllocator = std::allocator>

using std::ring_buffer< T, TAllocator >::value_type = T

Beschreibung der Konstruktoren und Destruktoren

ring_buffer()

template<class T , class TAllocator = std::allocator>

std::ring_buffer< T, TAllocator >::ring_buffer ( size_t  capacity = 100 )

inlineexplicit

                : m_Array(new T[capacity]),
                  m_ArraySize(capacity),
                  m_Head(0), m_Tail(0),
                  m_ContentsSize(0) {}

~ring_buffer()

template<class T , class TAllocator = std::allocator>

std::ring_buffer< T, TAllocator >::~ring_buffer ( )

inline

{ delete [] m_Array; }

Dokumentation der Elementfunktionen

back() [1/2]

template<class T , class TAllocator = std::allocator>

const_reference std::ring_buffer< T, TAllocator >::back ( ) const

inline

                                      { 
            return m_Array[m_Tail]; 
        }

back() [2/2]

template<class T , class TAllocator = std::allocator>

reference std::ring_buffer< T, TAllocator >::back ( )

inline

                                      { 
            return m_Array[m_Tail]; 
        }

begin() [1/2]

template<class T , class TAllocator = std::allocator>

iterator std::ring_buffer< T, TAllocator >::begin ( )

inline

                         { 
            return iterator(this, empty() ? 0 : front()); 
        }

begin() [2/2]

template<class T , class TAllocator = std::allocator>

const_iterator std::ring_buffer< T, TAllocator >::begin ( )

inline

                               { 
            return const_iterator(this, 0); 
        }

capacity()

template<class T , class TAllocator = std::allocator>

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

inline

                                   {
            return m_ContentsSize;
        }

clear()

template<class T , class TAllocator = std::allocator>

void std::ring_buffer< T, TAllocator >::clear ( )

inline

                      { 
            m_Head = m_Tail = m_ContentsSize = 0; 
        }

empty()

template<class T , class TAllocator = std::allocator>

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

inline

                           {
            return size() == 0; 
        }

end() [1/2]

template<class T , class TAllocator = std::allocator>

iterator std::ring_buffer< T, TAllocator >::end ( )

inline

                       { 
            return iterator(this, size()); 
        }

end() [2/2]

template<class T , class TAllocator = std::allocator>

const_iterator std::ring_buffer< T, TAllocator >::end ( )

inline

                             { 
            return const_iterator(this, size()); 
        }

front() [1/2]

template<class T , class TAllocator = std::allocator>

reference std::ring_buffer< T, TAllocator >::front ( )

inline

                                      { 
            return m_Array[m_Head];
        }

front() [2/2]

template<class T , class TAllocator = std::allocator>

const_reference std::ring_buffer< T, TAllocator >::front ( ) const

inline

                                      { 
            return m_Array[m_Head]; 
        }

full()

template<class T , class TAllocator = std::allocator>

bool std::ring_buffer< T, TAllocator >::full ( ) const

inline

                          {
            return size() == capacity();
        }

max()

template<class T , class TAllocator = std::allocator>

size_type std::ring_buffer< T, TAllocator >::max ( ) const

inline

                              {
            return size_type(-1) / sizeof(value_type);
        }

pop_front() [1/2]

template<class T , class TAllocator = std::allocator>

reference std::ring_buffer< T, TAllocator >::pop_front ( )

inline

                              { 
            inc_head(); 
            return front();
        }

pop_front() [2/2]

template<class T , class TAllocator = std::allocator>

const_reference std::ring_buffer< T, TAllocator >::pop_front ( ) const

inline

                                          { 
            inc_head(); 
            return front();
        }

push_back()

template<class T , class TAllocator = std::allocator>

void std::ring_buffer< T, TAllocator >::push_back ( const value_type &  item )

inline

                                               {
            inc_tail();
            if (m_ContentsSize == m_ArraySize)
                inc_head();
            m_Array[m_Tail] = item;
        }

size()

template<class T , class TAllocator = std::allocator>

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

inline

                               {
            return m_ArraySize;
        }

---

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

• include/ringbuffer.hpp