Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Class template small_vector

boost::container::small_vector

Synopsis

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

template<typename T,  N, typename Allocator = void, 
         typename Options = void> 
class small_vector : public  {
public:
  // construct/copy/destruct
  () ;
  (const allocator_type &);
  (size_type);
  (size_type, const allocator_type &);
  (size_type, default_init_t);
  (size_type, default_init_t, const allocator_type &);
  (size_type, const value_type &);
  (size_type, const value_type &, const allocator_type &);
  template<typename InIt> (InIt, InIt last );
  template<typename InIt> (InIt, InIt, const allocator_type &a );
  (const small_vector &);
  (const small_vector &, const allocator_type &);
  (const base_type &);
  (base_type &&);
  (small_vector &&) ;
  (small_vector &&, const allocator_type &);
  (value_type >, 
               const allocator_type & = allocator_type());
  small_vector & (const small_vector &);
  small_vector & 
  (small_vector &&) ;
  small_vector & (const base_type &);
  small_vector & (base_type &&);

  // public member functions
  void (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, Options> is convertible to small_vector_base<T, Allocator, Options> 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.

Any change to the capacity of the vector, including decreasing its size such as with the shrink_to_fit method, will cause the vector to permanently switch to dynamically allocated storage.

Template Parameters

  1. typename T

    The type of object that is stored in the small_vector

  2.  N

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

  3. typename Allocator = void

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

  4. typename Options = void

    A type produced from boost::container::small_vector_options.

small_vector public construct/copy/destruct

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

small_vector public member functions

  1. void (small_vector & other);

PrevUpHomeNext