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

Class template set

boost::container::set

Synopsis

// In header: <boost/container/set.hpp>
template<typename Key, typename Compare = std::less<Key>, 
         typename Allocator = new_allocator<Key>, 
         typename Options = tree_assoc_defaults> 
class set {
public:
  // types
  typedef Key                                                                key_type;              
  typedef Key                                                                value_type;            
  typedef Compare                                                            key_compare;           
  typedef Compare                                                            value_compare;         
  typedef ::boost::container::allocator_traits< Allocator >                  allocator_traits_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;
  typedef implementation_defined                                             node_type;             
  typedef implementation_defined                                             insert_return_type;    
  // construct/copy/destruct
  set() noexcept(container_detail::is_nothrow_default_constructible< Allocator >::value &&container_detail::is_nothrow_default_constructible< Compare >::value));
  explicit set(const Compare &, const allocator_type & = allocator_type());
  explicit set(const allocator_type &);
  template<typename InputIterator> 
    set(InputIterator, InputIterator, const Compare & = Compare(), 
        const allocator_type & = allocator_type());
  template<typename InputIterator> 
    set(InputIterator, InputIterator, const allocator_type &);
  template<typename InputIterator> 
    set(ordered_unique_range_t, InputIterator, InputIterator, 
        const Compare & = Compare(), 
        const allocator_type & = allocator_type());
  set(std::initializer_list< value_type >, const Compare & = Compare(), 
      const allocator_type & = allocator_type());
  set(std::initializer_list< value_type >, const allocator_type &);
  set(ordered_unique_range_t, std::initializer_list< value_type >, 
      const Compare & = Compare(), const allocator_type & = allocator_type());
  set(const set &);
  set(set &&) noexcept(boost::container::container_detail::is_nothrow_move_constructible< Compare >::value));
  set(const set &, const allocator_type &);
  set(set &&, const allocator_type &);
  set & operator=(const set &);
  set & operator=(set &&) noexcept((allocator_traits_type::propagate_on_container_move_assignment::value||allocator_traits_type::is_always_equal::value)&&boost::container::container_detail::is_nothrow_move_assignable< Compare >::value));
  set & operator=(std::initializer_list< value_type >);
  // public member functions
  allocator_type get_allocator() const;
  stored_allocator_type & get_stored_allocator();
  const stored_allocator_type & get_stored_allocator() const;
  iterator begin();
  const_iterator begin() const;
  const_iterator cbegin() const;
  iterator end();
  const_iterator end() const;
  const_iterator cend() const;
  reverse_iterator rbegin();
  const_reverse_iterator rbegin() const;
  const_reverse_iterator crbegin() const;
  reverse_iterator rend();
  const_reverse_iterator rend() const;
  const_reverse_iterator crend() const;
  bool empty() const;
  size_type size() const;
  size_type max_size() const;
  template<class... Args> std::pair< iterator, bool > emplace(Args &&...);
  template<class... Args> iterator emplace_hint(const_iterator, Args &&...);
  std::pair< iterator, bool > insert(const value_type &);
  std::pair< iterator, bool > insert(value_type &&);
  iterator insert(const_iterator, const value_type &);
  iterator insert(const_iterator, value_type &&);
  template<typename InputIterator> void insert(InputIterator, InputIterator);
  void insert(std::initializer_list< value_type >);
  insert_return_type insert(node_type &&);
  insert_return_type insert(const_iterator, node_type &&);
  template<typename C2> void merge(set< Key, C2, Allocator, Options > &);
  template<typename C2> void merge(set< Key, C2, Allocator, Options > &&);
  template<typename C2> void merge(multiset< Key, C2, Allocator, Options > &);
  template<typename C2> void merge(multiset< Key, C2, Allocator, Options > &&);
  iterator erase(const_iterator);
  size_type erase(const key_type &);
  iterator erase(const_iterator, const_iterator);
  void swap(set &) noexcept(allocator_traits_type::is_always_equal::value &&boost::container::container_detail::is_nothrow_swappable< Compare >::value));
  void clear();
  key_compare key_comp() const;
  value_compare value_comp() const;
  iterator find(const key_type &);
  const_iterator find(const key_type &) const;
  size_type count(const key_type &) const;
  size_type count(const key_type &);
  iterator lower_bound(const key_type &);
  const_iterator lower_bound(const key_type &) const;
  iterator upper_bound(const key_type &);
  const_iterator upper_bound(const key_type &) const;
  std::pair< iterator, iterator > equal_range(const key_type &);
  std::pair< const_iterator, const_iterator > 
  equal_range(const key_type &) const;
  std::pair< iterator, iterator > equal_range(const key_type &);
  std::pair< const_iterator, const_iterator > 
  equal_range(const key_type &) const;
  void rebalance();
  // friend functions
  friend bool operator==(const set &, const set &);
  friend bool operator!=(const set &, const set &);
  friend bool operator<(const set &, const set &);
  friend bool operator>(const set &, const set &);
  friend bool operator<=(const set &, const set &);
  friend bool operator>=(const set &, const set &);
  friend void swap(set &, set &);
};

Description

Набор представляет собой своего рода ассоциативный контейнер, который поддерживает уникальные ключи (содержит максимум один из каждого ключевого значения) и обеспечивает быстрое извлечение самих ключей. Класс поддерживает двунаправленные итераторы.

Набор удовлетворяет всем требованиям контейнера и обратимого контейнера и ассоциативного контейнера. Набор также предоставляет большинство операций, описанных для уникальных ключей.

Template Parameters

```
typenameKey
```
- тип, который должен быть вставлен в набор, который также является ключевым_типом.
```
typenameCompare=std::less<Key>
```
— сравнительный функтор, используемый для заказа ключей.
```
typenameAllocator=new_allocator<Key>
```
является распределителем, используемым для выделения памяти для этого контейнера.
```
typenameOptions=tree_assoc_defaults
```
- упакованный тип опции, сгенерированный с использованиемboost::container::tree_assoc_options.

`set` public construct/copy/destruct

set()noexcept(container_detail::is_nothrow_default_constructible<Allocator>::value&&container_detail::is_nothrow_default_constructible<Compare>::value));

Эффекты: Дефолт создает пустой набор.

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

```
explicitset(constCompare&comp,
            constallocator_type&a=allocator_type());
```
Эффекты: Постраивает пустой набор с помощью указанного объекта сравнения и распределителя.
Сложность: Постоянно.
```
explicitset(constallocator_type&a);
```
Эффекты: Постраивает пустой набор с помощью указанного объекта распределения.
Сложность: Постоянно.
```
template<typenameInputIterator>
 set(InputIteratorfirst,InputIteratorlast,
     constCompare&comp=Compare(),
     constallocator_type&a=allocator_type());
```
Эффекты: Постраивает пустой набор с помощью указанного объекта сравнения и распределителя и вставляет элементы из диапазона [первый, последний ].
Сложность: Линейный в N, если диапазон [первый, последний] уже отсортирован с использованием comp и иначе N logN, где N последний — первый.
```
template<typenameInputIterator>
 set(InputIteratorfirst,InputIteratorlast,constallocator_type&a);
```
Эффекты: Конструирует пустой набор с помощью указанного распределителя и вставляет элементы из диапазона [первый, последний ]
Сложность: Линейный в N, если диапазон [первый, последний] уже отсортирован с использованием comp и иначе N logN, где N последний — первый.
```
template<typenameInputIterator>
 set(ordered_unique_range_t,InputIteratorfirst,InputIteratorlast,
     constCompare&comp=Compare(),
     constallocator_type&a=allocator_type());
```
Эффекты: Конструирует пустой набор с использованием указанного объекта сравнения и распределителя и вставляет элементы из упорядоченного уникального диапазона [первый, последний]. Эта функция более эффективна, чем создание нормального диапазона для упорядоченных диапазонов.
Требует: [первый, последний] должен быть упорядочен в соответствии с предикатом и должен быть уникальными значениями.
Сложность: Линейный в N.
Примечание: Нестандартное расширение.
```
set(std::initializer_list<value_type>il,constCompare&comp=Compare(),
   constallocator_type&a=allocator_type());
```
Эффекты: Конструирует пустой набор с использованием указанного объекта сравнения и распределителя и вставляет элементы из диапазона [il.begin(), il.end()).
Сложность: Линейный в N, если диапазон [il.begin(), il.end()) уже отсортирован с использованием comp и иначе N logN, где N - il.begin() - il.end().
<
```
set(std::initializer_list<value_type>il,constallocator_type&a);
```
>
Эффекты: Конструирует пустой набор с использованием указанного распределителя и вставляет элементы из диапазона [il.begin(), il.end()).
Сложность: Линейный в N, если диапазон [il.begin(), il.end()) уже отсортирован с использованием comp и иначе N logN, где N - il.begin() - il.end().
```
set(ordered_unique_range_t,std::initializer_list<value_type>il,
   constCompare&comp=Compare(),
   constallocator_type&a=allocator_type());
```
Эффекты: Конструирует пустой набор с использованием указанного объекта сравнения и распределителя и вставляет элементы из упорядоченного уникального диапазона [il.begin(), il.end()). Эта функция более эффективна, чем создание нормального диапазона для упорядоченных диапазонов.
Требует: [il.begin(), il.end()) должны быть упорядочены согласно предикату и должны быть уникальными значениями.
Сложность: Линейный в N.
Примечание: Нестандартное расширение.
```
set(constset&x);
```
Эффекты: Копия конструирует множество.
Сложность: Линейный в x.size().
```
set(set&&x)noexcept(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value));
```
Эффекты: Move создает набор. Конструирует это с использованием ресурсов x.
Сложность: Константа.
Посткондиционное состояние: x опустошено.
```
set(constset&x,constallocator_type&a);
```
Эффекты: Копия конструирует набор с использованием указанного распределителя.
Сложность: Линейный в x.size().
<
```
set(set&&x,constallocator_type&a);
```
>
Эффекты: Перемещение конструирует набор с использованием указанного распределителя. Конструирует это с использованием ресурсов x.
Сложность: Постоянная, если a == x.get_allocator(), линейная иначе.
```
set&operator=(constset&x);
```
Эффекты: Делает это копией x.
Сложность: Линейный в x.size().
```
set&operator=(set&&x)noexcept((allocator_traits_type::propagate_on_container_move_assignment::value||allocator_traits_type::is_always_equal::value)&&boost::container::container_detail::is_nothrow_move_assignable<Compare>::value));
```
Эффекты:
Бросает: Если Allocator_traits_type::propagate_on_container_move_assignment является ложным и (броски распределения или броски конструктора движения Value_type)
Сложность: Постоянная, если allocator_traits_type:: propagate_on_container_move_assignment является истинным или это->get>allocator() == x.get_allocator(). Линейное иначе.
```
set&operator=(std::initializer_list<value_type>il);
```
Эффекты: Копировать все элементы от il до *this.
Сложность: Линейный в il.size().

`set` public member functions

```
allocator_typeget_allocator()const;
```
Эффекты: Возвращает копию распределителя, которая была передана конструктору объекта.
Сложность: Постоянная.
```
stored_allocator_type&get_stored_allocator();
```
Эффекты: Возвращает ссылку на внутренний распределитель.
Бросает: Ничто
Сложность: Константа.
Примечание: Нестандартное расширение.
```
conststored_allocator_type&get_stored_allocator()const;
```
Эффекты: Возвращает ссылку на внутренний распределитель.
Броски: Ничто
Сложность: Константа.
Примечание: Нестандартное расширение.
```
iteratorbegin();
```
Эффекты: возвращает итератор к первому элементу, содержащемуся в контейнере.
Бросок: Ничего.
Сложность: Постоянство
```
const_iteratorbegin()const;
```
Эффекты: Возвращает const_iterator к первому элементу контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
const_iteratorcbegin()const;
```
Эффекты: Возвращает const_iterator к первому элементу контейнера.
Бросок: Ничего.
Сложность: Постоянно.
```
iteratorend();
```
Эффекты: Возвращает итератор в конец контейнера.
Бросает: Ничего.
Сложность: Постоянная.
<
```
const_iteratorend()const;
```
>
Эффекты: Возвращает const_iterator в конец контейнера.
Бросок: Ничего.
Сложность: Постоянно.
```
const_iteratorcend()const;
```
Эффекты: Возвращает const_iterator в конец контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
reverse_iteratorrbegin();
```
Эффекты: Возвращает обратный_iterator, указывающий на начало обратного контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
const_reverse_iteratorrbegin()const;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на начало обратного контейнера.
Бросает: Ничего.
Сложность: Постоянная.
```
const_reverse_iteratorcrbegin()const;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на начало обратного контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
reverse_iteratorrend();
```
Эффекты: Возвращает обратный_iterator, указывающий на конец обратного контейнера.
Бросает: Ничего.
Сложность: Постоянная.
<
```
const_reverse_iteratorrend()const;
```
>
Эффекты: Возвращает const_reverse_iterator, указывающий на конец обратного контейнера.
Бросает: Ничего.
Сложность: Постоянно.
```
const_reverse_iteratorcrend()const;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на конец обратного контейнера.
Бросок: Ничего.
Сложность: Постоянно.
```
boolempty()const;
```
Эффекты: Возвращается, если контейнер не содержит элементов.
Бросок: Ничего.
Сложность: Постоянная.
```
size_typesize()const;
```
Эффекты: Возвращает количество элементов, содержащихся в контейнере.
Бросок: Ничего.
Сложность: Постоянно.
```
size_typemax_size()const;
```
Эффекты: Возвращает максимально возможный размер контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
template<class...Args>std::pair<iterator,bool>emplace(Args&&...args);
```
Эффекты: Вставляется объект x типа Ключ, построенный с помощью std::forward(args)... если и только если в контейнере нет элемента с эквивалентным значением. и возвращает итератор, указывающий на вновь вставленный элемент.
Возвращение: Компонент болта возвращаемой пары верен тогда и только тогда, когда происходит вставка, и компонент итератора пары указывает на элемент с ключом, эквивалентным ключу x.
Бросает: Если выделение памяти бросает или конструктор Ки на месте бросает.
Сложность: Логарифмический.
```
template<class...Args>
 iteratoremplace_hint(const_iteratorp,Args&&...args);
```
Эффекты: Вставляется объект типа Key, построенный с помощью std::forward(args)... если и только если в контейнере нет элемента с эквивалентным значением. p - подсказка, указывающая, где вставка должна начать поиск.
Возвращение: Итератор, указывающий на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмический.
```
std::pair<iterator,bool>insert(constvalue_type&x);
```
Эффекты: Вставляется x тогда и только тогда, когда в контейнере нет элемента с ключом, эквивалентным ключу x.
Возвращается: Компонент болта возвращаемой пары верен тогда и только тогда, когда происходит вставка, и компонент итератора пары указывает на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмический.
```
std::pair<iterator,bool>insert(value_type&&x);
```
Эффекты: Перемещение создает новое значение из x тогда и только тогда, когда в контейнере нет элемента, эквивалентного ключу x.
Возврат: Компонент болта возвращаемой пары верен тогда и только тогда, когда происходит вставка, и компонент итератора пары указывает на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмический.
```
iteratorinsert(const_iteratorp,constvalue_type&x);
```
Эффекты: Вставляет копию x в контейнер, если и только если в контейнере нет элемента с ключом, эквивалентным ключу x. p - подсказка, указывающая, где вставка должна начать поиск.
Возвращение: Итератор, указывающий на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмическая в целом, но амортизированная постоянная, если t вставлено непосредственно перед p.
```
iteratorinsert(const_iteratorp,value_type&&x);
```
Эффекты: Вставляет элемент, выполненный из x в контейнере. p - подсказка, указывающая, где вставка должна начать поиск.
Возвращение: Итератор, указывающий на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмический.
```
template<typenameInputIterator>
 voidinsert(InputIteratorfirst,InputIteratorlast);
```
Требует: во-первых, последние не являются итераторами в *это.
Эффекты: вставляет каждый элемент из диапазона [первый, последний], если и только если нет элемента с ключом, эквивалентным ключу этого элемента.
Сложность: N log(size()+N) (N — расстояние от первого до последнего)
```
voidinsert(std::initializer_list<value_type>il);
```
Эффекты: вставляет каждый элемент из диапазона [il.begin(),il.end()) тогда и только тогда, когда нет элемента с ключом, эквивалентным ключу этого элемента.
Сложность: N log(size()+N) (N — расстояние от il.begin() до il.end())
```
insert_return_typeinsert(node_type&&nh);
```
Эффекты: Вставляется новое значение_тип движения, построенное из пары, если и только если в контейнере нет элемента, эквивалентного ключу x.
Возврат: Компонент болта возвращаемой пары верен тогда и только тогда, когда происходит вставка, и компонент итератора пары указывает на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмический.
<
```
insert_return_typeinsert(const_iteratorhint,node_type&&nh);
```
>
Эффекты: Перемещение создает новое значение из x тогда и только тогда, когда в контейнере нет элемента с ключом, эквивалентным ключу x. p - подсказка, указывающая, где вставка должна начать поиск.
Возвращение: Итератор, указывающий на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмическая в целом, но амортизированная постоянная, если t вставлено непосредственно перед p.
<
```
template<typenameC2>voidmerge(set<Key,C2,Allocator,Options>&source);
```
>
Требуется: this->get_allocator() == source.get_allocator().
Эффекты: Попытки извлечь каждый элемент из источника и вставить его в объект сравнения *это. Если в элементе есть ключ, эквивалентный ключу элемента из источника, то этот элемент не извлекается из источника.
Посткондиционер: Указатели и ссылки на переданные элементы источника относятся к тем же элементам, но как к членам этого. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на их элементы, но теперь они ведут себя как итераторы в это, а не в источник.
Бросок: Ничего, если объект сравнения не бросит.
Сложность: N log(a.size() + N) (N имеет значение source.size())
```
template<typenameC2>voidmerge(set<Key,C2,Allocator,Options>&&source);
```
Требуется: это->get_allocator() == source.get_allocator().
Эффекты: Попытки извлечь каждый элемент из источника и вставить его в объект сравнения *это. Если в элементе есть ключ, эквивалентный ключу элемента из источника, то этот элемент не извлекается из источника.
Посткондиционер: Указатели и ссылки на переданные элементы источника относятся к тем же элементам, но как к членам этого. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на их элементы, но теперь они ведут себя как итераторы в это, а не в источник.
Бросок: Ничего, если объект сравнения не бросит.
Сложность: N log(a.size() + N) (N имеет значение source.size())
<
```
template<typenameC2>
 voidmerge(multiset<Key,C2,Allocator,Options>&source);
```
>
Требуется: это->get_allocator() == source.get_allocator().
Эффекты: Попытки извлечь каждый элемент из источника и вставить его в объект сравнения *это. Если в элементе есть ключ, эквивалентный ключу элемента из источника, то этот элемент не извлекается из источника.
Посткондиционер: Указатели и ссылки на переданные элементы источника относятся к тем же элементам, но как к членам этого. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на их элементы, но теперь они ведут себя как итераторы в * это, а не в источник.
Бросает: Ничего, если объект сравнения не бросит.
Сложность: N log(a.size() + N) (N имеет значение source.size())
```
template<typenameC2>
 voidmerge(multiset<Key,C2,Allocator,Options>&&source);
```
Требуется: это->get_allocator() == source.get_allocator().
Эффекты: Попытки извлечь каждый элемент из источника и вставить его в объект сравнения *это. Если в элементе есть ключ, эквивалентный ключу элемента из источника, то этот элемент не извлекается из источника.
Посткондиционер: Указатели и ссылки на переданные элементы источника относятся к тем же элементам, но как к членам этого. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на их элементы, но теперь они ведут себя как итераторы в это, а не в источник.
Бросок: Ничего, если объект сравнения не бросит.
Сложность: N log(a.size() + N) (N имеет значение source.size())
```
iteratorerase(const_iteratorp);
```
Эффекты: Стирает элемент, на который указывает п.
Возвращение: Возвращает итератор, указывающий на элемент непосредственно после q перед стиранием элемента. Если такого элемента не существует, возвращается конец ().
Сложность: Амортизированное постоянное время
```
size_typeerase(constkey_type&x);
```
Эффекты: Стирает все элементы в контейнере с ключом, эквивалентным x.
Возвращает: Возвращает количество стертых элементов.
Сложность: log(size()) + count(k)
```
iteratorerase(const_iteratorfirst,const_iteratorlast);
```
Эффекты: Стирает все элементы в диапазоне [первый, последний].
Возвращение:
Сложность: log(size())+ где N - расстояние от первого до последнего.

voidswap(set&x)noexcept(allocator_traits_type::is_always_equal::value&&boost::container::container_detail::is_nothrow_swappable<Compare>::value));

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

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

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

```
voidclear();
```
Эффекты: стирание (a.begin(),a.end()).
Посткондиция: размер() == 0.
Сложность: линейный размер().
```
key_comparekey_comp()const;
```
Эффекты: Возвращает объект сравнения, из которого был построен объект сравнения.
Сложность: Постоянная.
```
value_comparevalue_comp()const;
```
Эффекты: Возвращает объект value_compare, построенный из объекта сравнения.
Сложность: Постоянная.
<
```
iteratorfind(constkey_type&x);
```
>
Возвращение: Итератор, указывающий на элемент с ключом, эквивалентным x, или конец(), если такой элемент не найден.
Сложность: Логарифмический.
```
const_iteratorfind(constkey_type&x)const;
```
Возвращение: Const_iterator указывает на элемент с ключом, эквивалентным x, или конец(), если такой элемент не найден.
Сложность: Логарифмический.
```
size_typecount(constkey_type&x)const;
```
Возвращение: Число элементов с ключом, эквивалентным x.
Сложность: log(size())+count(k)
```
size_typecount(constkey_type&x);
```
Возвращение: Число элементов с ключом, эквивалентным x.
Сложность: log(size())+count(k)
```
iteratorlower_bound(constkey_type&x);
```
Возвращение: Итератор, указывающий на первый элемент ключом не менее k, или a.end(), если такой элемент не найден.
Сложность: Логарифмический
<
```
const_iteratorlower_bound(constkey_type&x)const;
```
>
Возвращение: Конст-итератор, указывающий на первый элемент с ключом не менее k, или a.end(), если такой элемент не найден.
Сложность: Логарифмический
```
iteratorupper_bound(constkey_type&x);
```
Возвращение: Итератор, указывающий на первый элемент с ключом не менее x, или конец(), если такой элемент не найден.
Сложность: Логарифмический
```
const_iteratorupper_bound(constkey_type&x)const;
```
Возвращение: Конст-итератор, указывающий на первый элемент с ключом не менее x, или конец(), если такой элемент не найден.
Сложность: Логарифмический
```
std::pair<iterator,iterator>equal_range(constkey_type&x);
```
Эффекты: Эквивалент std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Сложность: Логарифмический
<
```
std::pair<const_iterator,const_iterator>
equal_range(constkey_type&x)const;
```
>
Эффекты: Эквивалент std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Сложность: Логарифмический
```
std::pair<iterator,iterator>equal_range(constkey_type&x);
```
Эффекты: Эквивалент std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Сложность: Логарифмический
```
std::pair<const_iterator,const_iterator>
equal_range(constkey_type&x)const;
```
Эффекты: Эквивалент std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Сложность: Логарифмический
```
voidrebalance();
```
Эффекты: Уравновешивает дерево. Это не для красно-черных и AVL деревьев.
Сложность: Линейный

`set` friend functions

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

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

Class template set

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

Boost C++ Libraries

Class template set

Synopsis

Description

Template Parameters

set public construct/copy/destruct

set public member functions

set friend functions

`set` public construct/copy/destruct

`set` public member functions

`set` friend functions