circular_buffer_space_optimized<T, Alloc>
circular_buffer_space_optimized<T, Alloc> |
|
The circular_buffer_space_optimized container is an adaptor of the
circular_buffer. The
functionality of the circular_buffer_space_optimized is similar to
the base circular_buffer except it does not allocate memory at
once when created rather it allocates memory as needed. (The predictive memory
allocation is similar to typical std::vector implementation.)
Moreover the memory is automatically freed as the size of the container
decreases.
 |
|
| Figure: | The memory allocation process of the space optimized circular
buffer. The min_capacity represents the minimal guaranteed amount
of allocated memory. The allocated memory will never drop under this value. By
default the min_capacity is set to 0.
|
namespace boost {
template <class T, class Alloc>
class circular_buffer_space_optimized
{
public:
typedef implementation-defined allocator_type;
typedef implementation-defined const_iterator;
typedef implementation-defined const_pointer;
typedef implementation-defined const_reference;
typedef implementation-defined const_reverse_iterator;
typedef implementation-defined difference_type;
typedef implementation-defined iterator;
typedef implementation-defined pointer;
typedef implementation-defined reference;
typedef implementation-defined reverse_iterator;
typedef implementation-defined size_type;
typedef implementation-defined value_type;
template <class InputIterator>
circular_buffer_space_optimized(size_type capacity, size_type min_capacity, InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
circular_buffer_space_optimized(size_type capacity, size_type min_capacity, value_type item, const allocator_type& alloc = allocator_type());
explicit circular_buffer_space_optimized(size_type capacity, size_type min_capacity = 0, const allocator_type& alloc = allocator_type());
template <class InputIterator>
void assign(InputIterator first, InputIterator last);
void assign(size_type n, value_type item);
size_type capacity() const;
void clear();
iterator erase(iterator first, iterator last);
iterator erase(iterator pos);
bool full() const;
template <class InputIterator>
void insert(iterator pos, InputIterator first, InputIterator last);
void insert(iterator pos, size_type n, value_type item);
iterator insert(iterator pos);
iterator insert(iterator pos, value_type item);
size_type internal_capacity() const;
size_type min_capacity() const;
value_type operator[](size_type n) const;
reference operator[](size_type n);
void pop_back();
void pop_front();
void push_back();
void push_back(value_type item);
void push_front();
void push_front(value_type item);
void resize(size_type new_size, value_type item = T(), bool remove_front = true);
template <class InputIterator>
void rinsert(iterator pos, InputIterator first, InputIterator last);
void rinsert(iterator pos, size_type n, value_type item);
iterator rinsert(iterator pos);
iterator rinsert(iterator pos, value_type item);
void set_capacity(size_type new_capacity, bool remove_front = true);
void set_min_capacity(size_type new_min_capacity);
void swap(circular_buffer_space_optimized& cb);
};
template <class T, class Alloc>
bool operator!=(const circular_buffer_space_optimized<T,Alloc>& lhs, const circular_buffer_space_optimized<T,Alloc>& rhs);
template <class T, class Alloc>
bool operator<(const circular_buffer_space_optimized<T,Alloc>& lhs, const circular_buffer_space_optimized<T,Alloc>& rhs);
template <class T, class Alloc>
bool operator<=(const circular_buffer_space_optimized<T,Alloc>& lhs, const circular_buffer_space_optimized<T,Alloc>& rhs);
template <class T, class Alloc>
bool operator==(const circular_buffer_space_optimized<T,Alloc>& lhs, const circular_buffer_space_optimized<T,Alloc>& rhs);
template <class T, class Alloc>
bool operator>(const circular_buffer_space_optimized<T,Alloc>& lhs, const circular_buffer_space_optimized<T,Alloc>& rhs);
template <class T, class Alloc>
bool operator>=(const circular_buffer_space_optimized<T,Alloc>& lhs, const circular_buffer_space_optimized<T,Alloc>& rhs);
template <class T, class Alloc>
void swap(circular_buffer_space_optimized<T,Alloc>& lhs, circular_buffer_space_optimized<T,Alloc>& rhs);
} // namespace boost
|
The auto-resizing mode of the space optimized circular buffer can be useful in
situations when the container can possibly store large number of elements but
most of its lifetime the container stores just few of them. The usage of the circular_buffer_space_optimized
will result in decreased memory consumption and can improve the CPU cache
effectiveness.
The circular_buffer_space_optimized is defined in the file
boost/circular_buffer.hpp.
There is also a forward declaration for the circular_buffer_space_optimized in the header file
boost/circular_buffer_fwd.hpp.
Random Access Container, Front Insertion Sequence, Back Insertion Sequence, Assignable (SGI specific), Equality Comparable, LessThan Comparable (SGI specific)
Template parameters, members and friend functions of the circular_buffer_space_optimized
are almost the same as for the base circular_buffer. Refer the circular_buffer
documentation and also its
source code documentation for a detailed description.
The specific methods of the circular_buffer_space_optimized are
listed below.
| Method | Description |
|---|---|
circular_buffer_space_optimized(size_type
capacity, size_type min_capacity = 0, const allocator_type& alloc =
allocator_type())
|
Create an empty space optimized circular buffer with a given capacity. |
circular_buffer_space_optimized
(size_type capacity, size_type min_capacity, const T& item, const
allocator_type& alloc = allocator_type())
|
Create a full space optimized circular buffer filled with copies of item.
|
template<InputIterator>
circular_buffer_space_optimized(size_type capacity, size_type
min_capacity, InputIterator first, InputIterator last, const
allocator_type& alloc = allocator_type())
|
Create a space optimized circular buffer with a copy of a range. |
min_capacity()
const
|
Return the minimal guaranteed amount of allocated memory. |
set_min_capacity()
|
Change the minimal guaranteed amount of allocated memory. |
The behaviour of memory auto-resizing is as follows:
circular_buffer_space_optimized
is created.
circular_buffer_space_optimized
container is created the allocated memory reflects the size of the container.
push_back, push_front, insert and rinsert
will predictively increase the allocated memory if necessary. (The predictive
memory allocation is similar to std::vector.)
set_capacity, resize, assign, insert
(range or n items), rinsert (range or n items), erase
(range) and clear
will accommodate the allocated memory as necessary.
pop_back, pop_front, erase and clear
will predictively decrease the allocated memory.
The semantics of the circular_buffer_space_optimized then follows
the semantics of the base circular_buffer
except the invalidation rules.
The rule for iterator invalidation for circular_buffer_space_optimized
is as follows:
data, set_capacity, resize, operator=,
assign, swap, push_back, push_front,
pop_back, pop_front, insert, rinsert,
erase and clear invalidate all iterators pointing to
the circular_buffer_space_optimized.
boost::circular_buffer,
std::vector
The idea of the space optimized circular buffer has been introduced by Pavel Vozenilek.
| Copyright © 2003-2005 Jan Gaspar |
|