Boost C++ Libraries of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.

Class template small_vector



// 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 >
  // construct/copy/destruct
  small_vector() noexcept(container_detail::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 &);


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

  1. typename T

    The type of object that is stored in the small_vector

  2. std::size_t N

    The number of preallocated elements stored inside small_vector. It shall be less than Allocator::max_size();

  3. typename Allocator = new_allocator<T>

    The allocator used for memory management when the number of elements exceeds N.

small_vector public construct/copy/destruct

  1. small_vector() noexcept(container_detail::is_nothrow_default_constructible< Allocator >::value));
  2. explicit small_vector(const allocator_type & a);
  3. explicit small_vector(size_type n);
  4. small_vector(size_type n, const allocator_type & a);
  5. small_vector(size_type n, default_init_t);
  6. small_vector(size_type n, default_init_t, const allocator_type & a);
  7. small_vector(size_type n, const value_type & v);
  8. small_vector(size_type n, const value_type & v, const allocator_type & a);
  9. template<typename InIt> 
      small_vector(InIt first, InIt last  BOOST_CONTAINER_DOCIGN);
  10. template<typename InIt> 
      small_vector(InIt first, InIt last, 
                   const allocator_type &a  BOOST_CONTAINER_DOCIGN);
  11. small_vector(const small_vector & other);
  12. small_vector(const small_vector & other, const allocator_type & a);
  13. explicit small_vector(const base_type & other);
  14. explicit small_vector(base_type && other);
  15. small_vector(small_vector && other);
  16. small_vector(small_vector && other, const allocator_type & a);
  17. small_vector(std::initializer_list< value_type > il, 
                 const allocator_type & a = allocator_type());
  18. small_vector & operator=(const small_vector & other);
  19. small_vector & operator=(small_vector && other);
  20. small_vector & operator=(const base_type & other);
  21. small_vector & operator=(base_type && other);

small_vector public member functions

  1. void swap(small_vector & other);