Class template small

Class template small_vector

boost::container::small_vector

Synopsis

// In header: <boost/container/small_vector.hpp>

template<typename T, std::size_t N, typename Allocator = new_allocator<T> > 
class small_vector :
  public boost::container::small_vector_base< T, Allocator >
{
public:
  // construct/copy/destruct
  small_vector() noexcept(dtl::is_nothrow_default_constructible< Allocator >::value));
  explicit small_vector(const allocator_type &);
  explicit small_vector(size_type);
  small_vector(size_type, const allocator_type &);
  small_vector(size_type, default_init_t);
  small_vector(size_type, default_init_t, const allocator_type &);
  small_vector(size_type, const value_type &);
  small_vector(size_type, const value_type &, const allocator_type &);
  template<typename InIt> small_vector(InIt, InIt last );
  template<typename InIt> small_vector(InIt, InIt, const allocator_type &a );
  small_vector(const small_vector &);
  small_vector(const small_vector &, const allocator_type &);
  explicit small_vector(const base_type &);
  explicit small_vector(base_type &&);
  small_vector(small_vector &&);
  small_vector(small_vector &&, const allocator_type &);
  small_vector(std::initializer_list< value_type >, 
               const allocator_type & = allocator_type());
  small_vector & operator=(const small_vector &);
  small_vector & operator=(small_vector &&);
  small_vector & operator=(const base_type &);
  small_vector & operator=(base_type &&);

  // public member functions
  void swap(small_vector &);
};

Description

small_vector is a vector-like container optimized for the case when it contains few elements. It contains some preallocated elements in-place, which can avoid the use of dynamic storage allocation when the actual number of elements is below that preallocated threshold.

small_vector<T, N, Allocator> is convertible to small_vector_base<T, Allocator> that is independent from the preallocated element capacity, so client code does not need to be templated on that N argument.

All boost::container::vector member functions are inherited. See vector documentation for details.

Template Parameters

```
typename T
```
The type of object that is stored in the small_vector
```
std::size_t N
```
The number of preallocated elements stored inside small_vector. It shall be less than Allocator::max_size();
```
typename Allocator = new_allocator<T>
```
The allocator used for memory management when the number of elements exceeds N.

`small_vector` public construct/copy/destruct

small_vector() noexcept(dtl::is_nothrow_default_constructible< Allocator >::value));

explicit small_vector(const allocator_type & a);

```
explicit small_vector(size_type n);
```

small_vector(size_type n, const allocator_type & a);

small_vector(size_type n, default_init_t);

small_vector(size_type n, default_init_t, const allocator_type & a);

small_vector(size_type n, const value_type & v);

small_vector(size_type n, const value_type & v, const allocator_type & a);

template<typename InIt> 
  small_vector(InIt first, InIt last  BOOST_CONTAINER_DOCIGN);

template<typename InIt> 
  small_vector(InIt first, InIt last, 
               const allocator_type &a  BOOST_CONTAINER_DOCIGN);

small_vector(const small_vector & other);

small_vector(const small_vector & other, const allocator_type & a);

explicit small_vector(const base_type & other);

explicit small_vector(base_type && other);

```
small_vector(small_vector && other);
```

small_vector(small_vector && other, const allocator_type & a);

small_vector(std::initializer_list< value_type > il, 
             const allocator_type & a = allocator_type());

small_vector & operator=(const small_vector & other);

small_vector & operator=(small_vector && other);

small_vector & operator=(const base_type & other);

small_vector & operator=(base_type && other);

`small_vector` public member functions

```
void swap(small_vector & other);
```