Template Class BoundedVector
Defined in File bounded_vector.hpp
Inheritance Relationships
Base Type
protected std::vector< Tp, std::allocator< Tp > >
Class Documentation
-
template<typename Tp, std::size_t UpperBound, typename Alloc = std::allocator<Tp>>
class BoundedVector : protected std::vector<Tp, std::allocator<Tp>> A container based on std::vector but with an upper bound.
Meets the same requirements as std::vector.
- Param Tp:
Type of element
- Param UpperBound:
The upper bound for the number of elements
- Param Alloc:
Allocator type, defaults to std::allocator<Tp>
Public Functions
-
inline BoundedVector() noexcept(std::is_nothrow_default_constructible<Alloc>::value)
Create a BoundedVector with no elements.
-
inline explicit BoundedVector(const typename Base::allocator_type &a) noexcept
Creates a BoundedVector with no elements.
- Parameters:
a – An allocator object
-
inline explicit BoundedVector(typename Base::size_type n, const typename Base::allocator_type &a = allocator_type())
Create a BoundedVector with default constructed elements.
This constructor fills the BoundedVector with n default constructed elements.
- Parameters:
n – The number of elements to initially create
a – An allocator
-
inline BoundedVector(typename Base::size_type n, const typename Base::value_type &value, const typename Base::allocator_type &a = allocator_type())
Create a BoundedVector with copies of an exemplar element.
This constructor fills the BoundedVector with n copies of value.
- Parameters:
n – The number of elements to initially create
value – An element to copy
a – An allocator
-
inline BoundedVector(const BoundedVector &x)
BoundedVector copy constructor.
The newly-created BoundedVector uses a copy of the allocation object used by x. All the elements of x are copied, but any extra memory in x (for fast expansion) will not be copied.
- Parameters:
x – A BoundedVector of identical element and allocator types
-
inline BoundedVector(BoundedVector &&x) noexcept
BoundedVector move constructor.
The newly-created BoundedVector contains the exact contents of x. The contents of x are a valid, but unspecified BoundedVector.
- Parameters:
x – A BoundedVector of identical element and allocator types
-
inline BoundedVector(const BoundedVector &x, const typename Base::allocator_type &a)
Copy constructor with alternative allocator.
-
inline BoundedVector(std::initializer_list<typename Base::value_type> l, const typename Base::allocator_type &a = typename Base::allocator_type())
Build a BoundedVector from an initializer list.
Create a BoundedVector consisting of copies of the elements in the initializer_list l.
This will call the element type’s copy constructor N times (where N is l.size()) and do no memory reallocation.
- Parameters:
l – An initializer_list
a – An allocator
-
template<typename InputIterator>
inline BoundedVector(InputIterator first, InputIterator last, const typename Base::allocator_type &a = allocator_type()) Build a BoundedVector from a range.
Create a BoundedVector consisting of copies of the elements from [first,last).
If the iterators are forward, bidirectional, or random-access, then this will call the elements’ copy constructor N times (where N is distance(first,last)) and do no memory reallocation. But if only input iterators are used, then this will do at most 2N calls to the copy constructor, and logN memory reallocations.
- Parameters:
first – An input iterator
last – An input iterator
a – An allocator
-
inline ~BoundedVector() noexcept
The dtor only erases the elements.
Note that if the elements themselves are pointers, the pointed-to memory is not touched in any way. Managing the pointer is the user’s responsibility.
-
inline BoundedVector &operator=(const BoundedVector &x)
BoundedVector assignment operator.
All the elements of x are copied, but any extra memory in x (for fast expansion) will not be copied. Unlike the copy constructor, the allocator object is not copied.
- Parameters:
x – A BoundedVector of identical element and allocator types
-
inline BoundedVector &operator=(BoundedVector &&x)
BoundedVector move assignment operator
- Parameters:
x – A BoundedVector of identical element and allocator types.
-
inline BoundedVector &operator=(std::initializer_list<typename Base::value_type> l)
BoundedVector list assignment operator.
This function fills a BoundedVector with copies of the elements in the initializer list l.
Note that the assignment completely changes the BoundedVector and that the resulting BoundedVector’s size is the same as the number of elements assigned. Old data may be lost.
- Parameters:
l – An initializer_list
-
inline void assign(typename Base::size_type n, const typename Base::value_type &val)
Assign a given value to a BoundedVector.
This function fills a BoundedVector with n copies of the given value. Note that the assignment completely changes the BoundedVector and that the resulting BoundedVector’s size is the same as the number of elements assigned. Old data may be lost.
- Parameters:
n – Number of elements to be assigned
val – Value to be assigned
-
template<typename InputIterator>
inline void assign(InputIterator first, InputIterator last) Assign a range to a BoundedVector.
This function fills a BoundedVector with copies of the elements in the range [first,last).
Note that the assignment completely changes the BoundedVector and that the resulting BoundedVector’s size is the same as the number of elements assigned. Old data may be lost.
- Parameters:
first – An input iterator
last – An input iterator
-
inline void assign(std::initializer_list<typename Base::value_type> l)
Assign an initializer list to a BoundedVector.
This function fills a BoundedVector with copies of the elements in the initializer list l.
Note that the assignment completely changes the BoundedVector and that the resulting BoundedVector’s size is the same as the number of elements assigned. Old data may be lost.
- Parameters:
l – An initializer_list
-
inline Base::size_type max_size() const noexcept
Returns the size() of the largest possible BoundedVector.
-
inline void resize(typename Base::size_type new_size)
Resize the BoundedVector to the specified number of elements.
This function will resize the BoundedVector to the specified number of elements. If the number is smaller than the BoundedVector’s current size the BoundedVector is truncated, otherwise default constructed elements are appended.
- Parameters:
new_size – Number of elements the BoundedVector should contain
-
inline void resize(typename Base::size_type new_size, const typename Base::value_type &x)
Resize the BoundedVector to the specified number of elements.
This function will resize the BoundedVector to the specified number of elements. If the number is smaller than the BoundedVector’s current size the BoundedVector is truncated, otherwise the BoundedVector is extended and new elements are populated with given data.
- Parameters:
new_size – Number of elements the BoundedVector should contain
x – Data with which new elements should be populated
-
inline void reserve(typename Base::size_type n)
Attempt to preallocate enough memory for specified number of elements.
This function attempts to reserve enough memory for the BoundedVector to hold the specified number of elements. If the number requested is more than max_size(), length_error is thrown.
The advantage of this function is that if optimal code is a necessity and the user can determine the number of elements that will be required, the user can reserve the memory in advance, and thus prevent a possible reallocation of memory and copying of BoundedVector data.
- Parameters:
n – Number of elements required
- Throws:
std::length_error – If n exceeds
max_size()
-
template<typename T, typename std::enable_if<!std::is_same<T, Tp>::value && !std::is_same<T, bool>::value>::type* = nullptr>
inline T *data() noexcept Return a pointer such that [data(), data() + size()) is a valid range.
For a non-empty BoundedVector, data() == &front().
-
template<typename T, typename std::enable_if<!std::is_same<T, Tp>::value && !std::is_same<T, bool>::value>::type* = nullptr>
inline const T *data() const noexcept
-
inline void push_back(const typename Base::value_type &x)
Add data to the end of the BoundedVector.
This is a typical stack operation. The function creates an element at the end of the BoundedVector and assigns the given data to it. Due to the nature of a BoundedVector this operation can be done in constant time if the BoundedVector has preallocated space available.
- Parameters:
x – Data to be added
-
inline void push_back(typename Base::value_type &&x)
-
template<typename ...Args>
inline auto emplace_back(Args&&... args) Add data to the end of the BoundedVector.
This is a typical stack operation. The function creates an element at the end of the BoundedVector and assigns the given data to it. Due to the nature of a BoundedVector this operation can be done in constant time if the BoundedVector has preallocated space available.
- Parameters:
args – Arguments to be forwarded to the constructor of Tp
-
template<typename ...Args>
inline Base::iterator emplace(typename Base::const_iterator position, Args&&... args) Insert an object in BoundedVector before specified iterator.
This function will insert an object of type T constructed with T(std::forward<Args>(args)…) before the specified location. Note that this kind of operation could be expensive for a BoundedVector and if it is frequently used the user should consider using std::list.
- Parameters:
position – A const_iterator into the BoundedVector
args – Arguments
- Returns:
An iterator that points to the inserted data
-
inline Base::iterator insert(typename Base::const_iterator position, const typename Base::value_type &x)
Insert given value into BoundedVector before specified iterator.
This function will insert a copy of the given value before the specified location. Note that this kind of operation could be expensive for a BoundedVector and if it is frequently used the user should consider using std::list.
- Parameters:
position – A const_iterator into the BoundedVector
x – Data to be inserted
- Returns:
An iterator that points to the inserted data
-
inline Base::iterator insert(typename Base::const_iterator position, typename Base::value_type &&x)
Insert given rvalue into BoundedVector before specified iterator.
This function will insert a copy of the given rvalue before the specified location. Note that this kind of operation could be expensive for a BoundedVector and if it is frequently used the user should consider using std::list.
- Parameters:
position – A const_iterator into the BoundedVector
x – Data to be inserted
- Returns:
An iterator that points to the inserted data
-
inline Base::iterator insert(typename Base::const_iterator position, std::initializer_list<typename Base::value_type> l)
Insert an initializer_list into the BoundedVector.
This function will insert copies of the data in the initializer_list l into the BoundedVector before the location specified by position.
Note that this kind of operation could be expensive for a BoundedVector and if it is frequently used the user should consider using std::list.
- Parameters:
position – An iterator into the BoundedVector
l – An initializer_list
-
inline Base::iterator insert(typename Base::const_iterator position, typename Base::size_type n, const typename Base::value_type &x)
Insert a number of copies of given data into the BoundedVector.
This function will insert a specified number of copies of the given data before the location specified by position.
Note that this kind of operation could be expensive for a BoundedVector and if it is frequently used the user should consider using std::list.
- Parameters:
position – A const_iterator into the BoundedVector
n – Number of elements to be inserted
x – Data to be inserted
- Returns:
An iterator that points to the inserted data
-
template<typename InputIterator>
inline Base::iterator insert(typename Base::const_iterator position, InputIterator first, InputIterator last) Insert a range into the BoundedVector.
This function will insert copies of the data in the range [first,last) into the BoundedVector before the location specified by pos.
Note that this kind of operation could be expensive for a BoundedVector and if it is frequently used the user should consider using std::list.
- Parameters:
position – A const_iterator into the BoundedVector
first – An input iterator
last – An input iterator
- Returns:
An iterator that points to the inserted data