Class template small

Class template small_vector

boost::container::small_vector

Synopsis

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

template<typename T,  N, typename Allocator, 
         typename Options> 
class small_vector : public  {
public:

  // public member functions
  ();
  ();
  (size_type);
  (size_type, );
  (size_type, default_init_t);
  (size_type, default_init_t, );
  (size_type, value_type &);
  (size_type, value_type &, );
  template<typename InIt> (, );
  template<typename InIt> (, , );
  ();
  (, );
  ();
  ();
  ();
  (, );
  (value_type >,  = );
   ();
   ();
   ();
   ();
   ();
   ();
};

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

```
typename T
```
The type of object that is stored in the small_vector
```
 N
```
The number of preallocated elements stored inside small_vector. It shall be less than Allocator::max_size();
```
typename Allocator
```
The allocator used for memory management when the number of elements exceeds N. Use void for the default allocator
```
typename Options
```
A type produced from boost::container::small_vector_options.

`small_vector` public member functions

```
();
```
```
( a);
```
```
(size_type n);
```
```
(size_type n,  a);
```
```
(size_type n, default_init_t);
```
```
(size_type n, default_init_t,  a);
```
```
(size_type n, value_type & v);
```
```
(size_type n, value_type & v,  a);
```

template<typename InIt> 
  ( first,  BOOST_CONTAINER_DOCIGN);

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

```
( other);
```
```
( other,  a);
```
```
( other);
```
```
( other);
```
```
( other);
```
```
( other,  a);
```
```
(value_type > il, 
              a = );
```
```
 ( other);
```
```
 ( other);
```
```
 ( other);
```
```
 ( other);
```
```
 ( other);
```
```
 ();
```