Class template stable_vector . Boost , The Boost C++ Libraries BoostBook Documentation Subset , Boost.Container Header Reference

Class template stable_vector

boost::container::stable_vector

Synopsis

// In header: <boost/container/stable_vector.hpp>
template<typename T, typename Allocator = new_allocator<T> > 
class stable_vector {
public:
  // types
  typedef T                                                                  value_type;            
  typedef ::boost::container::allocator_traits< Allocator >::pointer         pointer;               
  typedef ::boost::container::allocator_traits< Allocator >::const_pointer   const_pointer;         
  typedef ::boost::container::allocator_traits< Allocator >::reference       reference;             
  typedef ::boost::container::allocator_traits< Allocator >::const_reference const_reference;       
  typedef ::boost::container::allocator_traits< Allocator >::size_type       size_type;             
  typedef ::boost::container::allocator_traits< Allocator >::difference_type difference_type;       
  typedef Allocator                                                          allocator_type;        
  typedef node_allocator_type                                                stored_allocator_type; 
  typedef implementation_defined                                             iterator;              
  typedef implementation_defined                                             const_iterator;        
  typedef implementation_defined                                             reverse_iterator;      
  typedef implementation_defined                                             const_reverse_iterator;
  // construct/copy/destruct
  stable_vector() noexcept(container_detail::is_nothrow_default_constructible< Allocator >::value));
  explicit stable_vector(const allocator_type &) noexcept;
  explicit stable_vector(size_type);
  stable_vector(size_type, default_init_t);
  explicit stable_vector(size_type, const allocator_type &);
  stable_vector(size_type, default_init_t, const allocator_type &);
  stable_vector(size_type, const T &, 
                const allocator_type & = allocator_type());
  template<typename InputIterator> 
    stable_vector(InputIterator, InputIterator, 
                  const allocator_type & = allocator_type());
  stable_vector(const stable_vector &);
  stable_vector(std::initializer_list< value_type >, 
                const allocator_type & = allocator_type());
  stable_vector(stable_vector &&) noexcept;
  stable_vector(const stable_vector &, const allocator_type &);
  stable_vector(stable_vector &&, const allocator_type &);
  stable_vector & operator=(const stable_vector &);
  stable_vector & 
  operator=(stable_vector &&) noexcept(allocator_traits_type::propagate_on_container_move_assignment::value||allocator_traits_type::is_always_equal::value));
  stable_vector & operator=(std::initializer_list< value_type >);
  ~stable_vector();
  // public member functions
  void assign(size_type, const T &);
  template<typename InputIterator> void assign(InputIterator, InputIterator);
  void assign(std::initializer_list< value_type >);
  allocator_type get_allocator() const;
  const stored_allocator_type & get_stored_allocator() const noexcept;
  stored_allocator_type & get_stored_allocator() noexcept;
  iterator begin() noexcept;
  const_iterator begin() const noexcept;
  iterator end() noexcept;
  const_iterator end() const noexcept;
  reverse_iterator rbegin() noexcept;
  const_reverse_iterator rbegin() const noexcept;
  reverse_iterator rend() noexcept;
  const_reverse_iterator rend() const noexcept;
  const_iterator cbegin() const noexcept;
  const_iterator cend() const noexcept;
  const_reverse_iterator crbegin() const noexcept;
  const_reverse_iterator crend() const noexcept;
  bool empty() const noexcept;
  size_type size() const noexcept;
  size_type max_size() const noexcept;
  void resize(size_type);
  void resize(size_type, default_init_t);
  void resize(size_type, const T &);
  size_type capacity() const noexcept;
  void reserve(size_type);
  void shrink_to_fit();
  reference front() noexcept;
  const_reference front() const noexcept;
  reference back() noexcept;
  const_reference back() const noexcept;
  reference operator[](size_type) noexcept;
  const_reference operator[](size_type) const noexcept;
  iterator nth(size_type) noexcept;
  const_iterator nth(size_type) const noexcept;
  size_type index_of(iterator) noexcept;
  size_type index_of(const_iterator) const noexcept;
  reference at(size_type);
  const_reference at(size_type) const;
  template<class... Args> reference emplace_back(Args &&...);
  template<class... Args> iterator emplace(const_iterator, Args &&...);
  void push_back(const T &);
  void push_back(T &&);
  iterator insert(const_iterator, const T &);
  iterator insert(const_iterator, T &&);
  iterator insert(const_iterator, size_type, const T &);
  iterator insert(const_iterator, std::initializer_list< value_type >);
  template<typename InputIterator> 
    iterator insert(const_iterator, InputIterator, InputIterator);
  void pop_back() noexcept;
  iterator erase(const_iterator) noexcept;
  iterator erase(const_iterator, const_iterator) noexcept;
  void swap(stable_vector &) noexcept(allocator_traits_type::propagate_on_container_swap::value||allocator_traits_type::is_always_equal::value));
  void clear() noexcept;
  // friend functions
  friend bool operator==(const stable_vector &, const stable_vector &);
  friend bool operator!=(const stable_vector &, const stable_vector &);
  friend bool operator<(const stable_vector &, const stable_vector &);
  friend bool operator>(const stable_vector &, const stable_vector &);
  friend bool operator<=(const stable_vector &, const stable_vector &);
  friend bool operator>=(const stable_vector &, const stable_vector &);
  friend void swap(stable_vector &, stable_vector &);
};

Description

Первоначально разработанный Хоакином М. Лопесом Муньосом,стабильный векторпредставляет собой замену std::vector drop-in, реализованную в виде контейнера узла, предлагающего итератор и эталонную стабильность.

Вот подробности, взятые из блога автора (Введение стабильного вектора):

Стабильный вектор, полностью совместимый с STL стабильный контейнер, который обеспечивает большинство функций std::vector, за исключением смежности элементов.

Общие свойства:Стабильный векторудовлетворяет всем требованиям контейнера, обратимого контейнера и последовательности и обеспечивает все необязательные операции, присутствующие в std::vector. Как и std::vector, итераторы имеют случайный доступ.Стабильный векторне обеспечивает смежность элементов; в обмен на это отсутствие контейнер является стабильным, т.е. ссылки и итераторы на элементstable_vectorостаются действительными до тех пор, пока элемент не стерт, и итератор, которому было присвоено обратное значение конца(), всегда остаются действительными до разрушения связанногоstable_vector..

Сложность операции: Сложные операции с большим Ostable_vectorточно соответствуют операциям с std::vector. В целом, вставка/удаление является постоянным временем в конце последовательности и линейным в другом месте. В отличие от std::vector,stable_vectorне выполняет внутренне никаких операций разрушения, копирования или присвоения типа значения, кроме тех, которые точно соответствуют вставке новых элементов или удалению сохраненных элементов, что иногда может компенсировать с точки зрения производительности дополнительное бремя выполнения большего количества манипуляций с указателями и дополнительного распределения на элемент.

Посколькуstable_vectorвнутренне не копирует элементы вокруг, некоторые операции обеспечивают более сильные гарантии безопасности исключения, чем в std::vector.

Template Parameters

```
typenameT
```
Тип объекта, который хранится вstable_vector
```
typenameAllocator=new_allocator<T>
```
Распределитель, используемый для управления всей внутренней памятью

`stable_vector` public construct/copy/destruct

<
```
stable_vector()noexcept(container_detail::is_nothrow_default_constructible<Allocator>::value));
```
>
Эффекты:<stable_vector>
Бросает: Если проигрывает конструктор по умолчанию Allocator_type.
Сложность: Постоянно.
<
```
explicitstable_vector(constallocator_type&al)noexcept;
```
>
Эффекты: Конструирует<stable_vector>, принимая распределитель в качестве параметра.
Бросает: Ничего
Сложность: Постоянно.
```
explicitstable_vector(size_typen);
```
Эффекты: Конструирует astable_vectorи вставляет n начальных значений.
Бросает: Если по умолчанию конструктор Allocator_type бросает, или по умолчанию T, или конструктор копий бросает.
Сложность: Линейный к n.
```
stable_vector(size_typen,default_init_t);
```
Эффекты: Конструирует astable_vectorи вставляет n начальных значений по умолчанию.
Бросает: Если по умолчанию конструктор Allocator_type бросает, или по умолчанию T, или конструктор копий бросает.
Сложность: Линейный к n.
Примечание: Нестандартное расширение
```
explicitstable_vector(size_typen,constallocator_type&a);
```
Эффекты: Конструируетstable_vector, который будет использовать копию распределителя a и вставляет n начальных значений.
Бросок: Если по умолчанию конструктор Allocator_type бросает, или по умолчанию T, или конструктор копий бросает.
Сложность: Линейный к n.
```
stable_vector(size_typen,default_init_t,constallocator_type&a);
```
Эффекты: Конструируетstable_vector, который будет использовать копию распределителя a и вставляет n начальных значений по умолчанию.
Бросает: Если по умолчанию конструктор Allocator_type бросает, или по умолчанию T, или конструктор копий бросает.
Сложность: Линейный к n.
Примечание: Нестандартное расширение
```
stable_vector(size_typen,constT&t,
             constallocator_type&al=allocator_type());
```
Эффекты: Конструируетstable_vector, который будет использовать копию распределителя a и вставляет n копий значения.
Бросает: Если по умолчанию конструктор Allocator_type бросает, или по умолчанию T, или конструктор копий бросает.
Сложность: Линейный к n.
```
template<typenameInputIterator>
 stable_vector(InputIteratorfirst,InputIteratorlast,
               constallocator_type&al=allocator_type());
```
Эффекты: Конструируетstable_vector, который будет использовать копию распределителя a и вставляет копию диапазона [первый, последний] вstable_vector.
Бросает: Если конструктор по умолчанию Allocator_type бросает или конструктор T принимает отнесенные к нему броски.
Сложность: Линейный к диапазону [первый, последний].
```
stable_vector(conststable_vector&x);
```
Эффекты: Копия конструируетstable_vector.
Посткондиционер: x == *это.
Сложность: Линейные элементы, содержащие x.
```
stable_vector(std::initializer_list<value_type>il,
             constallocator_type&l=allocator_type());
```
Эффекты: Конструируетstable_vector, который будет использовать копию распределителя a и вставляет копию диапазона [il.begin(), il.last()) вstable_vector
Бросает: Если конструктор по умолчанию Allocator_type бросает или конструктор T принимает отложенный инициализатор_list, итератор бросает.
Сложность: Линейный к диапазону [il.begin(), il.end()).
```
stable_vector(stable_vector&&x)noexcept;
```
Эффекты: Переместите конструктор. Переносит ресурсы x на *это.
Бросает: Если выбросить конструктор копий allocator_type
Сложность: Постоянная.
```
stable_vector(conststable_vector&x,constallocator_type&a);
```
Эффекты: Копия конструируетstable_vectorс помощью указанного распределителя.
Посткондиционер: x == *это.
Сложность: Линейные элементы, содержащие x.
```
stable_vector(stable_vector&&x,constallocator_type&a);
```
Эффекты: Переместить конструктор с помощью указанного распределителя. Переносит ресурсы x на *это.
Бросает: Если бросает конструктор копий allocator_type.
Сложность: Постоянная, если a == x.get_allocator(), линейная иначе
```
stable_vector&operator=(conststable_vector&x);
```
Эффекты: Делает *это содержит те же элементы, что и x.
Посткондиция: это->size() == x.size(). * В нем содержится копия каждого из элементов x.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Линейное число элементов в x.
```
stable_vector&
operator=(stable_vector&&x)noexcept(allocator_traits_type::propagate_on_container_move_assignment::value||allocator_traits_type::is_always_equal::value));
```
Эффекты: Перенеси задание. Все значения x переносятся на *это.
Посткондиция: x.empty(). * содержит элементы х, которые были до функции.
Бросок: Если allocator_traits_type::propagate_on_container_move_assignment является ложным и (броски распределения или броски конструктора движения Т)
Сложность: Постоянная, если allocator_traits_type:: propagate_on_container_move_assignment является истинным или это->get>allocator() == x.get_allocator(). Линейное иначе.
<
```
stable_vector&operator=(std::initializer_list<value_type>il);
```
>
Эффекты: Сделать *этот контейнер содержит элементы из ил.
Сложность: Линейный к диапазону [il.begin(), il.end()).
<
```
~stable_vector();
```
>
Эффекты: Уничтожает<stable_vector>. Все сохраненные значения уничтожаются, а используемая память размещается.
Бросает: Ничего.
Сложность: Линейный по количеству элементов.

`stable_vector` public member functions

```
voidassign(size_typen,constT&t);
```
Эффекты: Присваивает n копий вал к *этому.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Линейный к n.
```
template<typenameInputIterator>
 voidassign(InputIteratorfirst,InputIteratorlast);
```
Эффекты: Назначает диапазон [первый, последний] к *этому.
Бросает: Если выделение памяти бросает или T-конструктор от отсылки InpIt бросает.
Сложность: Линейный к n.
```
voidassign(std::initializer_list<value_type>il);
```
Эффекты: Назначает диапазон [il.begin(), il.end()) на *это.
Бросает: Если выделение памяти выбрасывает или T-конструктор из дереференционного инициализатора_список итераторов бросков.
```
allocator_typeget_allocator()const;
```
Эффекты: Возвращает копию внутреннего распределителя.
Бросает: Если копировщик распределителя бросит.
Сложность: Постоянная.
```
conststored_allocator_type&get_stored_allocator()constnoexcept;
```
Эффекты: Возвращает ссылку на внутренний распределитель.
Броски: Ничто
Сложность: Константа.
Примечание: Нестандартное расширение.
```
stored_allocator_type&get_stored_allocator()noexcept;
```
Эффекты: Возвращает ссылку на внутренний распределитель.
Бросает: Ничто
Сложность: Константа.
Примечание: Нестандартное расширение.
```
iteratorbegin()noexcept;
```
Эффекты: Возвращает итератор к первому элементу, содержащемуся вstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
```
const_iteratorbegin()constnoexcept;
```
Эффекты: Возвращает const_iterator к первому элементу, содержащемуся вstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
```
iteratorend()noexcept;
```
Эффекты: Возвращает итератор в конецstable_vector
Бросает: Ничего.
Сложность: Постоянная.
```
const_iteratorend()constnoexcept;
```
Эффекты: Возвращает const_iterator к концуstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
```
reverse_iteratorrbegin()noexcept;
```
Эффекты: Возвращает обратный_iterator, указывающий на начало обратногоstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
```
const_reverse_iteratorrbegin()constnoexcept;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на начало обратногоstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
```
reverse_iteratorrend()noexcept;
```
Эффекты: Возвращает обратный_iterator, указывающий на конец обратногоstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
<
```
const_reverse_iteratorrend()constnoexcept;
```
>
Эффекты: Возвращает const_reverse_iterator, указывающий на конец обратного<stable_vector>.
Бросает: Ничего.
Сложность: Постоянная.
```
const_iteratorcbegin()constnoexcept;
```
Эффекты: Возвращает const_iterator к первому элементу, содержащемуся вstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
```
const_iteratorcend()constnoexcept;
```
Эффекты: Возвращает const_iterator к концуstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
```
const_reverse_iteratorcrbegin()constnoexcept;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на начало обратногоstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
```
const_reverse_iteratorcrend()constnoexcept;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на конец обратногоstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
```
boolempty()constnoexcept;
```
Эффекты: Возвращается, еслиstable_vectorне содержит элементов.
Бросок: Ничего.
Сложность: Постоянно.
```
size_typesize()constnoexcept;
```
Эффекты: Возвращает число элементов, содержащихся вstable_vector.
Бросает: Ничего.
Сложность: Постоянная.
```
size_typemax_size()constnoexcept;
```
Эффекты: Возвращает наибольший возможный размерstable_vector.
Бросает: Ничего.
Сложность: Постоянно.
```
voidresize(size_typen);
```
Эффекты: Вставляет или стирает элементы в конце так, что размер становится n. Новые элементы инициализируются.
Бросок: Если распределение памяти бросает, или инициализация значения Т бросает.
Сложность: Линейная разница между размером () и новым размером.
```
voidresize(size_typen,default_init_t);
```
Эффекты: Вставляет или стирает элементы в конце так, что размер становится n. Новые элементы инициализируются по умолчанию.
Бросает: Если выделение памяти бросает, или T по умолчанию инициализация бросает.
Сложность: Линейная разница между размером () и новым размером.
Примечание: Нестандартное расширение
```
voidresize(size_typen,constT&t);
```
Эффекты: Вставляет или стирает элементы в конце так, что размер становится n. Новые элементы копируются из x.
Броски: Если отбрасывает выделение памяти, или отбрасывает конструктор копий Т.
Сложность: Линейная разница между размером () и новым размером.
```
size_typecapacity()constnoexcept;
```
Эффекты: Количество элементов, для которых выделена память. Вместимость () всегда больше или равна размеру ().
Бросок: Ничего.
Сложность: Постоянная.
```
voidreserve(size_typen);
```
Эффекты: Если n меньше или равно емкости(), этот вызов не имеет эффекта. В противном случае это запрос на выделение дополнительной памяти. Если запрос является успешным, то емкость () больше или равна n; в противном случае емкость () не изменяется. В любом случае размер() не изменяется.
Бросок: Если выделение памяти отбрасывает.
```
voidshrink_to_fit();
```
Эффекты: Пытается справиться с избытком памяти, созданной с помощью предыдущих выделений. Размерstable_vectorне изменился
Бросок: Если отбрасывает память.
Сложность: Линейный размер().
<
```
referencefront()noexcept;
```
>
Требует:!empty()
: Возвращает ссылку на первый элемент контейнера.
Бросок:
Сложность: Постоянная.
<
```
const_referencefront()constnoexcept;
```
>
Требует:!empty()
: Возвращается ссылка на первый элемент контейнера.
Бросает: Ничего.
Сложность: Постоянная.
```
referenceback()noexcept;
```
Требует:!empty()
: Возвращает ссылку на последний элемент контейнера.
Бросает: Ничего.
Сложность: Постоянная.
<
```
const_referenceback()constnoexcept;
```
>
Требует:!empty()
Эффекты: Возвращает ссылку на последний элемент контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
referenceoperator[](size_typen)noexcept;
```
Требуется: размер() >n.
Эффекты: Возвращает ссылку на n-й элемент из начала контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
const_referenceoperator[](size_typen)constnoexcept;
```
Требуется: размер() >n.
Эффекты: Возвращает ссылку на n-й элемент из начала контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
iteratornth(size_typen)noexcept;
```
Требует: размер() >= n.
Эффекты: Возвращает итератор к n-му элементу от начала контейнера. Возвращает конец(), если n == размер().
Бросок: Ничего.
Сложность: Константа.
Примечание: Нестандартное расширение
```
const_iteratornth(size_typen)constnoexcept;
```
Требуется: размер() >= n.
Эффекты: Возвращает const_iterator к n-му элементу с начала контейнера. Возвращает конец(), если n == размер().
Бросает: Ничего.
Сложность: Константа.
Примечание: Нестандартное расширение
```
size_typeindex_of(iteratorp)noexcept;
```
Требуется: start()<= p<= end().
: Возвращает индекс элемента, указываемого p и размером(), если p == конец().
Бросает: Ничего.
Сложность: Постоянная.
Примечание: Нестандартное расширение
```
size_typeindex_of(const_iteratorp)constnoexcept;
```
Требуется: start()<= p<= end().
Эффекты: Возвращает индекс элемента, указанный p и размером(), если p == конец().
Бросок: Ничего.
Сложность: Константа.
Примечание: Нестандартное расширение
```
referenceat(size_typen);
```
Требует: размер() >n.
Эффекты: Возвращает ссылку на n-й элемент из начала контейнера.
Бросок: Разработчик:range_error если n>= размер()
Сложность: Постоянная.
```
const_referenceat(size_typen)const;
```
Требует: размер() >n.
Эффекты: Возвращает ссылку на n-й элемент из начала контейнера.
Бросок: Разработчик:range_error если n>= размер()
Сложность: Постоянная.
```
template<class...Args>referenceemplace_back(Args&&...args);
```
Эффекты: Вставляет объект типа Т, построенный с помощью std::forward(args)... в концеstable_vector.
Возвращение: Ссылка на созданный объект.
Бросает: Если распределение памяти бросает или конструктор на месте бросает.
Сложность: Амортизированное постоянное время.
```
template<class...Args>iteratoremplace(const_iteratorp,Args&&...args);
```
Требуется: p должен быть действительным итератором *этого.
Эффекты: Вставляется объект типа Т, построенный с помощью std::forward(args)... до p
Бросает: Если распределение памяти бросает или конструктор на месте бросает.
Сложность: Если p - конец (), амортизированное постоянное время Линейное время в противном случае.
```
voidpush_back(constT&x);
```
Эффекты: Вставить копию x в концеstable_vector.
Бросок: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Амортизированное постоянное время.
```
voidpush_back(T&&x);
```
Эффекты: Конструирует новый элемент в конце 1125 и перемещает ресурсы x в этот новый элемент.
Бросок: Если выделение памяти бросает.
Сложность: Амортизированное постоянное время.
```
iteratorinsert(const_iteratorp,constT&x);
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Вставить копию x перед p.
Возвращение: Итератор вставленного элемента.
Бросает: Если выделение памяти бросает или копирует конструктор x.
Сложность: Если p - конец (), амортизированное постоянное время Линейное время в противном случае.
```
iteratorinsert(const_iteratorp,T&&x);
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Вставьте новый элемент перед p с ресурсами x.
Возвращает: итератор на вставленный элемент.
Броски: Если выделение памяти бросает.
Сложность: Если p - конец (), амортизированное постоянное время Линейное время в противном случае.
```
iteratorinsert(const_iteratorp,size_typen,constT&t);
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Вставить n копий x перед p.
Возвращение: итератор первого вставленного элемента или p, если n равно 0.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Линейный к n.
```
iteratorinsert(const_iteratorp,std::initializer_list<value_type>il);
```
Требуется: p должен быть действительным итератором этого.
Требуется: p должен быть действительным итератором этого.
Эффекты: Включить копию диапазона [il.begin(), il.end()) до p.
Возвращение: итератор первого вставленного элемента или p, если первый == последний.
Сложность: Линейное расстояние [il.begin(), il.end()).
```
template<typenameInputIterator>
 iteratorinsert(const_iteratorp,InputIteratorfirst,InputIteratorlast);
```
Требуется:
: Вставить копию [первого, последнего] диапазона перед p.
Возвращение: итератор первого вставленного элемента или p, если первый == последний.
Бросает: Если выделение памяти бросает, то T-конструктор из отнесенного к делу InpIt бросает или T-конструктор копирования бросает.
Сложность: Линейное расстояние (первое, последнее).
```
voidpop_back()noexcept;
```
Эффекты: Удаляет последний элемент изstable_vector.
Бросает: Ничего.
Сложность: Постоянное время.
```
iteratorerase(const_iteratorp)noexcept;
```
Эффекты: Стирает элемент по п.
Бросает: Ничего.
Сложность: Линейные элементы между p и последним элементом. Постоянная, если p - последний элемент.
```
iteratorerase(const_iteratorfirst,const_iteratorlast)noexcept;
```
Эффекты: Стирает элементы, указанные [первым, последним].
Бросок: Ничего.
Сложность: Линейное расстояние между первым и последним плюс линейное к элементам между р и последним элементом.

voidswap(stable_vector&x)noexcept(allocator_traits_type::propagate_on_container_swap::value||allocator_traits_type::is_always_equal::value));

Эффекты: Изменяет содержание *это и x.

Бросает: Ничего.

Сложность: Постоянная.

```
voidclear()noexcept;
```
Эффекты: Стирает все элементыstable_vector.
Бросает: Ничего.
Сложность: Линейное число элементов вstable_vector.

`stable_vector` friend functions

```
friendbooloperator==(conststable_vector&x,conststable_vector&y);
```
Эффекты: Верно, если x и y равны
Сложность: Линейный по количеству элементов в контейнере.
```
friendbooloperator!=(conststable_vector&x,conststable_vector&y);
```
Эффекты: Верно, если x и y неравны
Сложность: Линейный по количеству элементов в контейнере.
```
friendbooloperator<(conststable_vector&x,conststable_vector&y);
```
Эффекты: Верно, если x меньше y
Сложность: Линейный по количеству элементов в контейнере.
```
friendbooloperator>(conststable_vector&x,conststable_vector&y);
```
Эффекты: Верно, если x больше y
Сложность: Линейный по количеству элементов в контейнере.
```
friendbooloperator<=(conststable_vector&x,conststable_vector&y);
```
Эффекты: Верно, если x равно или меньше y
Сложность: Линейный по количеству элементов в контейнере.
```
friendbooloperator>=(conststable_vector&x,conststable_vector&y);
```
Эффекты: Верно, если x равно или больше y
Сложность: Линейный по количеству элементов в контейнере.
```
friendvoidswap(stable_vector&x,stable_vector&y);
```
Эффекты: x.swap(y)
Сложность: Постоянная.

Статья Class template stable_vector раздела The Boost C++ Libraries BoostBook Documentation Subset Boost.Container Header Reference может быть полезна для разработчиков на c++ и boost.

Class template stable_vector

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Boost.Container Header Reference

Boost C++ Libraries

Class template stable_vector

Synopsis

Description

Template Parameters

stable_vector public construct/copy/destruct

stable_vector public member functions

stable_vector friend functions

`stable_vector` public construct/copy/destruct

`stable_vector` public member functions

`stable_vector` friend functions