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

Class template deque

boost::container::deque

Synopsis

// In header: <boost/container/deque.hpp>
template<typename T, typename Allocator = new_allocator<T> > 
class deque : protected deque_base< Allocator > {
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 implementation_defined                                             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
  deque() noexcept(container_detail::is_nothrow_default_constructible< Allocator >::value));
  explicit deque(const allocator_type &) noexcept;
  explicit deque(size_type);
  deque(size_type, default_init_t);
  explicit deque(size_type, const allocator_type &);
  deque(size_type, default_init_t, const allocator_type &);
  deque(size_type, const value_type &);
  deque(size_type, const value_type &, const allocator_type &);
  template<typename InIt> deque(InIt, InIt);
  template<typename InIt> deque(InIt, InIt, const allocator_type &);
  deque(std::initializer_list< value_type >, 
        const allocator_type & = allocator_type());
  deque(const deque &);
  deque(deque &&) noexcept;
  deque(const deque &, const allocator_type &);
  deque(deque &&, const allocator_type &);
  deque & operator=(const deque &);
  deque & operator=(deque &&) noexcept(allocator_traits_type::propagate_on_container_move_assignment::value||allocator_traits_type::is_always_equal::value));
  deque & operator=(std::initializer_list< value_type >);
  ~deque();
  // public member functions
  void assign(size_type, const T &);
  template<typename InIt> void assign(InIt, InIt);
  void assign(std::initializer_list< value_type >);
  allocator_type get_allocator() const noexcept;
  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 value_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_front(Args &&...);
  template<class... Args> reference emplace_back(Args &&...);
  template<class... Args> iterator emplace(const_iterator, Args &&...);
  void push_front(const T &);
  void push_front(T &&);
  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 value_type &);
  template<typename InIt> iterator insert(const_iterator, InIt, InIt);
  iterator insert(const_iterator, std::initializer_list< value_type >);
  void pop_front() noexcept;
  void pop_back() noexcept;
  iterator erase(const_iterator) noexcept;
  iterator erase(const_iterator, const_iterator) noexcept;
  void swap(deque &) 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 deque &, const deque &);
  friend bool operator!=(const deque &, const deque &);
  friend bool operator<(const deque &, const deque &);
  friend bool operator>(const deque &, const deque &);
  friend bool operator<=(const deque &, const deque &);
  friend bool operator>=(const deque &, const deque &);
  friend void swap(deque &, deque &);
};

Description

Двухконечная очередь - это последовательность, которая поддерживает случайный доступ к элементам, постоянную вставку времени и удаление элементов в конце последовательности и линейную вставку времени и удаление элементов в середине.

Template Parameters

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

`deque` public construct/copy/destruct

<
```
deque()noexcept(container_detail::is_nothrow_default_constructible<Allocator>::value));
```
>
Эффекты: Конструкторы по умолчанию.
Бросок: Если проигрывает конструктор по умолчанию Allocator_type.
Сложность: Постоянно.
<
```
explicitdeque(constallocator_type&a)noexcept;
```
>
Эффекты: Построение дека, принимая распределитель в качестве параметра.
Бросает: Ничего
Сложность: Постоянно.
```
explicitdeque(size_typen);
```
Эффекты: Конструирует деке и вставляет n начальных значений.
Бросок: Если по умолчанию конструктор Allocator_type бросает или T's value initialization throws.
Сложность: Линейный к n.
```
deque(size_typen,default_init_t);
```
Эффекты: Конструирует деке и вставляет n начальных значений по умолчанию.
Броски: Если конструктор по умолчанию Allocator_type бросает или инициализация по умолчанию T или броски конструктора копий.
Сложность: Линейный к n.
Примечание: Нестандартное расширение
```
explicitdeque(size_typen,constallocator_type&a);
```
Эффекты: Построен деке, который будет использовать копию распределителя a и вставляет n значений инициализированных значений.
Бросает: Если по умолчанию конструктор Allocator_type бросает или T's value initialization throws.
Сложность: Линейный к п.
```
deque(size_typen,default_init_t,constallocator_type&a);
```
Эффекты: Построен деке, который будет использовать копию распределителя a и вставляет n начальных значений по умолчанию.
Бросок: Если конструктор по умолчанию Allocator_type бросает или инициализация по умолчанию T или броски конструктора копий.
Сложность: Линейный к n.
Примечание: Нестандартное расширение
```
deque(size_typen,constvalue_type&value);
```
Эффекты: Построен деке, который будет использовать копию распределителя a и вставляет n копий стоимости.
Бросает: Если конструктор по умолчанию Allocator_type бросает или конструктор копий T бросает.
Сложность: Линейный к n.
```
deque(size_typen,constvalue_type&value,constallocator_type&a);
```
Эффекты: Построен деке, который будет использовать копию распределителя a и вставляет n копий значения.
Бросок: Если конструктор по умолчанию Allocator_type бросает или конструктор копий T бросает.
Сложность: Линейный к n.
```
template<typenameInIt>deque(InItfirst,InItlast);
```
Эффекты: Постраивает деке, который будет использовать копию распределителя а и вставляет копию диапазона [первый, последний] в деке.
Бросает: Если разработчик по умолчанию Allocator_type бросает или разработчик T принимает броски InIt.
Сложность: Линейный к диапазону [первый, последний].
<
```
template<typenameInIt>deque(InItfirst,InItlast,constallocator_type&a);
```
>
Эффекты: Постраивает деке, который будет использовать копию распределителя а и вставляет копию диапазона [первый, последний] в деке.
Бросает: Если разработчик по умолчанию Allocator_type бросает или разработчик T принимает броски InIt.
Сложность: Линейный к диапазону [первый, последний].
```
deque(std::initializer_list<value_type>il,
     constallocator_type&a=allocator_type());
```
Эффекты: Построен деке, который будет использовать копию распределителя а и вставляет копию диапазона [il.begin(), il.end()) в деке.
Бросает: Если конструктор по умолчанию Allocator_type бросает или конструктор T принимает отложенный std::initializer_list iterator throws.
Сложность: Линейный к диапазону [il.begin(), il.end()).
```
deque(constdeque&x);
```
Эффекты: Копия строит деке.
Постусловие: x == *это.
Сложность: Линейные элементы, содержащие x.
```
deque(deque&&x)noexcept;
```
Эффекты: Переместите конструктор. Перемещает ресурсы x на *это.
Бросает: Если бросает конструктор копий allocator_type.
Сложность: Постоянная.
<
```
deque(constdeque&x,constallocator_type&a);
```
>
Эффекты: Копия конструирует вектор с помощью указанного распределителя.
Постусловие: x == *это.
Бросает: Если выделение бросает или копирует конструктор Т бросает.
Сложность: Линейные элементы, содержащие x.
```
deque(deque&&x,constallocator_type&a);
```
Эффекты: Переместить конструктор с помощью указанного распределителя. Перемещает ресурсы x на * это, если a == allocator_type(). В противном случае копирует значения от x до *этого.
Бросает: Если выделение или броски конструктора копии Т.
Сложность: Постоянная, если a == x.get_allocator(), линейная иначе.
```
deque&operator=(constdeque&x);
```
Эффекты: Делает *это содержит те же элементы, что и x.
Посткондиция: это->size() == x.size(). * В нем содержится копия каждого из элементов x.
Бросок: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Линейное число элементов в x.
<
```
deque&operator=(deque&&x)noexcept(allocator_traits_type::propagate_on_container_move_assignment::value||allocator_traits_type::is_always_equal::value));
```
>
Эффекты: Перенеси задание. Все значения x переносятся на *это.
Бросает: Если allocator_traits_type::propagate_on_container_move_assignment является ложным и (броски распределения или броски конструктора движения значения_type)
Сложность: Постоянная, если allocator_traits_type:: propagate_on_container_move_assignment является истинной или это->get>allocator() == x.get_allocator(). Линейное иначе.
```
deque&operator=(std::initializer_list<value_type>il);
```
Эффекты: Содержит те же элементы, что и il.
Пост-условие: это->size() == il.size(). * В нем содержится копия каждого из элементов x.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Линейный по количеству элементов в ил.
```
~deque();
```
Эффекты: Уничтожает реку. Все сохраненные значения уничтожаются, а используемая память размещается.
Бросок: Ничего.
Сложность: Линейный по количеству элементов.

`deque` public member functions

```
voidassign(size_typen,constT&val);
```
Эффекты: Присваивает n копий вал к *этому.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Линейный к n.
```
template<typenameInIt>voidassign(InItfirst,InItlast);
```
Эффекты: Назначает диапазон [первый, последний] к *этому.
Бросает: Если выделение памяти бросает или T-конструктор от отсылки к InIt бросает.
Сложность: Линейный к n.
```
voidassign(std::initializer_list<value_type>il);
```
Эффекты: Назначает диапазон [il.begin(), il.end()) на *это.
Бросает: Если выделение памяти выбрасывает или T-конструктор из дереференции std::initializer_list итератор бросает.
Сложность: Линейный размер ().
```
allocator_typeget_allocator()constnoexcept;
```
Эффекты: Вернет копию внутреннего распределителя.
Бросает: Если копировщик распределителя бросит.
Сложность: Постоянная.
```
conststored_allocator_type&get_stored_allocator()constnoexcept;
```
Эффекты: Возвращает ссылку на внутренний распределитель.
Бросает: Ничто
Сложность: Постоянная.
Примечание: Нестандартное расширение.
```
stored_allocator_type&get_stored_allocator()noexcept;
```
Эффекты: Возвращает ссылку на внутренний распределитель.
Броски: Ничто
Сложность: Константа.
Примечание: Нестандартное расширение.
```
iteratorbegin()noexcept;
```
Эффекты: Возвращает итератор к первому элементу, содержащемуся в деке.
Бросает: Ничего.
Сложность: Постоянно.
```
const_iteratorbegin()constnoexcept;
```
Эффекты: Возвращает const_iterator к первому элементу, содержащемуся в деке.
Бросает: Ничего.
Сложность: Постоянная.
```
iteratorend()noexcept;
```
Эффекты: Возвращает итератор в конец дека.
Бросает: Ничего.
Сложность: Постоянная.
```
const_iteratorend()constnoexcept;
```
Эффекты: Возвращает const_iterator в конец дека.
Бросает: Ничего.
Сложность: Постоянная.
```
reverse_iteratorrbegin()noexcept;
```
: Возвращает обратный_iterator, указывающий на начало обратного знака.
Бросок: Ничего.
Сложность: Постоянно.
```
const_reverse_iteratorrbegin()constnoexcept;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на начало обратного деке.
Бросает: Ничего.
Сложность: Постоянство.
```
reverse_iteratorrend()noexcept;
```
Эффекты: Возвращает обратный_iterator, указывающий на конец обратного знака.
Бросок: Ничего.
Сложность: Постоянно.
```
const_reverse_iteratorrend()constnoexcept;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на конец обратного знака.
Бросок: Ничего.
Сложность: Постоянная.
```
const_iteratorcbegin()constnoexcept;
```
Эффекты: Возвращает const_iterator к первому элементу, содержащемуся в деке.
Бросок: Ничего.
Сложность: Постоянная.
```
const_iteratorcend()constnoexcept;
```
Эффекты: Возвращает const_iterator в конец дека.
Бросает: Ничего.
Сложность: Постоянная.
```
const_reverse_iteratorcrbegin()constnoexcept;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на начало обратного деке.
Бросает: Ничего.
Сложность: Постоянная.
<
```
const_reverse_iteratorcrend()constnoexcept;
```
>
Эффекты: Возвращает const_reverse_iterator, указывающий на конец обратного деке.
Бросает: Ничего.
Сложность: Постоянная.
```
boolempty()constnoexcept;
```
Эффекты: Возвращается верно, если деке не содержит элементов.
Бросок: Ничего.
Сложность: Постоянно.
```
size_typesize()constnoexcept;
```
Эффекты: Возвращает количество элементов, содержащихся в деке.
Бросок: Ничего.
Сложность: Постоянная.
```
size_typemax_size()constnoexcept;
```
Эффекты: Возвращает максимально возможный размер дека.
Бросок: Ничего.
Сложность: Постоянно.
```
voidresize(size_typenew_size);
```
Эффекты: Вставляет или стирает элементы в конце так, что размер становится n. Новые элементы инициализируются.
Бросок: Если выделение памяти бросает, или конструктор Т бросает.
Сложность: Линейная разница между размером () и новым размером.
<
```
voidresize(size_typenew_size,default_init_t);
```
>
Эффекты: Вставляет или стирает элементы в конце так, что размер становится n. Новые элементы инициализируются по умолчанию.
Бросок: Если выделение памяти бросает, или конструктор Т бросает.
Сложность: Линейная разница между размером () и новым размером.
Примечание: Нестандартное расширение
```
voidresize(size_typenew_size,constvalue_type&x);
```
Эффекты: Вставляет или стирает элементы в конце так, что размер становится n. Новые элементы копируются из x.
Броски: Если отбрасывает выделение памяти, или отбрасывает конструктор копий Т.
Сложность: Линейная разница между размером () и новым размером.
```
voidshrink_to_fit();
```
Эффекты: Пытается справиться с избытком памяти, созданной с помощью предыдущих выделений. Размер дека не изменился
Бросок: Если отбрасывает память.
Сложность: Постоянная.
```
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-й элемент из начала контейнера.
Бросает: std::range_error если n>= размер()
Сложность: Постоянная.
```
const_referenceat(size_typen)const;
```
Требует: размер() >n.
Эффекты: Возвращает ссылку на n-й элемент из начала контейнера.
Бросок: Разработчик:range_error если n>= размер()
Сложность: Постоянная.
```
template<class...Args>referenceemplace_front(Args&&...args);
```
Эффекты: Вставляется объект типа Т, построенный с помощью std::forward(args)... в начале дека.
Возвращение: Ссылка на созданный объект.
Бросает: Если распределение памяти бросает или конструктор на месте бросает.
Сложность: Амортизированное постоянное время
```
template<class...Args>referenceemplace_back(Args&&...args);
```
Эффекты: Вставляется объект типа Т, построенный с помощью std::forward(args)... в конце дека.
Возвращение: Ссылка на созданный объект.
Бросок: Если распределение памяти бросает или конструктор на месте бросает.
Сложность: Амортизированное постоянное время
```
template<class...Args>iteratoremplace(const_iteratorp,Args&&...args);
```
Требуется: p должен быть действительным итератором *этого.
Эффекты: Вставляется объект типа Т, построенный с помощью std::forward(args)... до p
Бросает: Если распределение памяти бросает или конструктор на месте бросает.
Сложность: Если p - конец (), амортизированное постоянное время Линейное время в противном случае.
```
voidpush_front(constT&x);
```
Эффекты: Вставляет копию x в передней части дека.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Амортизированное постоянное время.
```
voidpush_front(T&&x);
```
Эффекты: Конструирует новый элемент в передней части дека и перемещает ресурсы x в этот новый элемент.
Бросок: Если выделение памяти бросает.
Сложность: Амортизированное постоянное время.
```
voidpush_back(constT&x);
```
Эффекты: Вставляет копию x в конце дека.
Бросает: Если броски памяти или броски конструктора копии Т.
Сложность: Амортизированное постоянное время.
```
voidpush_back(T&&x);
```
Эффекты: Конструирует новый элемент в конце знака и перемещает ресурсы x к этому новому элементу.
Бросок: Если выделение памяти бросает.
Сложность: Амортизированное постоянное время.
```
iteratorinsert(const_iteratorp,constT&x);
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Вставить копию x перед p.
Возвращает: итератор к вставленному элементу.
Бросок: Если выделение памяти бросает или копирует конструктор x.
Сложность: Если p - конец (), амортизированное постоянное время Линейное время в противном случае.
```
iteratorinsert(const_iteratorp,T&&x);
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Вставьте новый элемент перед p с ресурсами x.
Возвращение: Итератор к вставленному элементу.
Бросок: Если выделение памяти бросает.
Сложность: Если p - конец (), амортизированное постоянное время Линейное время в противном случае.
```
iteratorinsert(const_iteratorpos,size_typen,constvalue_type&x);
```
Требуется:
Эффекты: Вставить n копий x перед pos.
Возвращение: итератор к первому вставленному элементу или посу, если n равно 0.
Бросает: Если броски памяти или броски конструктора копии Т.
Сложность: Линейный к n.
```
template<typenameInIt>
 iteratorinsert(const_iteratorpos,InItfirst,InItlast);
```
Требуется:
Эффекты: Вставить копию [первого, последнего] диапазона перед pos.
Возвращение: итератор к первому вставленному элементу или позу, если первый == последний.
Бросает: Если выделение памяти бросает, конструктор T из отнесенного к нему InIt бросает или конструктор копии T бросает.
Сложность: Линейное расстояние (первое, последнее).
```
iteratorinsert(const_iteratorpos,std::initializer_list<value_type>il);
```
Требуется:
Эффекты: Вставить копию диапазона [il.begin(), il.end()) перед pos.
Возвращение: итератор первого вставленного элемента или поса, если il.begin() == il.end().
Бросает: Если выделение памяти бросает, то T's constructor из отнесенного к разряду std::initializer_list бросает или T's copy constructor throws.
Сложность: Линейное расстояние [il.begin(), il.end()).
```
voidpop_front()noexcept;
```
Эффекты: Удаляет первый элемент с дека.
Бросает: Ничего.
Сложность: Постоянное время.
```
voidpop_back()noexcept;
```
Эффекты: Удаляет последний элемент с дека.
Бросает: Ничего.
Сложность: Постоянное время.
```
iteratorerase(const_iteratorpos)noexcept;
```
Эффекты: Стирает элемент по п.
Бросает: Ничего.
Сложность: Линейный к элементам между pos и последним элементом (если pos находится вблизи конца) или первый элемент, если (pos находится вблизи начала). Постоянны, если по является первым или последним элементом.
```
iteratorerase(const_iteratorfirst,const_iteratorlast)noexcept;
```
Эффекты: Стирает элементы, указанные [первым, последним]
Бросает: Ничего.
Сложность: Линейный к расстоянию между первым и последним плюс элементы между pos и последним элементом (если pos находится вблизи конца) или первый элемент если (pos находится вблизи начала).
```
voidswap(deque&x)noexcept(allocator_traits_type::propagate_on_container_swap::value||allocator_traits_type::is_always_equal::value));
```
Эффекты: Измените содержание *это и x.
Бросает: Ничего.
Сложность: Постоянная.
```
voidclear()noexcept;
```
Эффекты: Стирает все элементы дека.
Бросает: Ничего.
Сложность: Линейный по количеству элементов в деке.

`deque` friend functions

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

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

Class template deque

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

Boost C++ Libraries

Class template deque

Synopsis

Description

Template Parameters

deque public construct/copy/destruct

deque public member functions

deque friend functions

`deque` public construct/copy/destruct

`deque` public member functions

`deque` friend functions