Class template sg_set . Boost , The Boost C++ Libraries BoostBook Documentation Subset , Reference

Class template sg_set

boost::intrusive::sg_set

Synopsis

// In header: <boost/intrusive/sg_set.hpp>
template<typename T, class... Options> 
class sg_set {
public:
  // types
  typedef implementation_defined::value_type             value_type;            
  typedef implementation_defined::key_type               key_type;              
  typedef implementation_defined::key_of_value           key_of_value;          
  typedef implementation_defined::value_traits           value_traits;          
  typedef implementation_defined::pointer                pointer;               
  typedef implementation_defined::const_pointer          const_pointer;         
  typedef implementation_defined::reference              reference;             
  typedef implementation_defined::const_reference        const_reference;       
  typedef implementation_defined::difference_type        difference_type;       
  typedef implementation_defined::size_type              size_type;             
  typedef implementation_defined::value_compare          value_compare;         
  typedef implementation_defined::key_compare            key_compare;           
  typedef implementation_defined::iterator               iterator;              
  typedef implementation_defined::const_iterator         const_iterator;        
  typedef implementation_defined::reverse_iterator       reverse_iterator;      
  typedef implementation_defined::const_reverse_iterator const_reverse_iterator;
  typedef implementation_defined::insert_commit_data     insert_commit_data;    
  typedef implementation_defined::node_traits            node_traits;           
  typedef implementation_defined::node                   node;                  
  typedef implementation_defined::node_ptr               node_ptr;              
  typedef implementation_defined::const_node_ptr         const_node_ptr;        
  typedef implementation_defined::node_algorithms        node_algorithms;       
  // construct/copy/destruct
  sg_set();
  explicit sg_set(const key_compare &, const value_traits & = value_traits());
  template<typename Iterator> 
    sg_set(Iterator, Iterator, const key_compare & = key_compare(), 
           const value_traits & = value_traits());
  sg_set(sg_set &&);
  sg_set & operator=(sg_set &&);
  ~sg_set();
  // public member functions
  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;
  iterator root();
  const_iterator root() const;
  const_iterator croot() const;
  key_compare key_comp() const;
  value_compare value_comp() const;
  bool empty() const;
  size_type size() const;
  void swap(sg_set &);
  template<typename Cloner, typename Disposer> 
    void clone_from(const sg_set &, Cloner, Disposer);
  template<typename Cloner, typename Disposer> 
    void clone_from(sg_set &&, Cloner, Disposer);
  std::pair< iterator, bool > insert(reference);
  iterator insert(const_iterator, reference);
  std::pair< iterator, bool > 
  insert_check(const key_type &, insert_commit_data &);
  std::pair< iterator, bool > 
  insert_check(const_iterator, const key_type &, insert_commit_data &);
  template<typename KeyType, typename KeyTypeKeyCompare> 
    std::pair< iterator, bool > 
    insert_check(const KeyType &, KeyTypeKeyCompare, insert_commit_data &);
  template<typename KeyType, typename KeyTypeKeyCompare> 
    std::pair< iterator, bool > 
    insert_check(const_iterator, const KeyType &, KeyTypeKeyCompare, 
                 insert_commit_data &);
  template<typename Iterator> void insert(Iterator, Iterator);
  iterator insert_commit(reference, const insert_commit_data &);
  iterator insert_before(const_iterator, reference);
  void push_back(reference);
  void push_front(reference);
  iterator erase(const_iterator);
  iterator erase(const_iterator, const_iterator);
  size_type erase(const key_type &);
  template<typename KeyType, typename KeyTypeKeyCompare> 
    size_type erase(const KeyType &, KeyTypeKeyCompare);
  template<typename Disposer> 
    iterator erase_and_dispose(const_iterator, Disposer);
  template<typename Disposer> 
    iterator erase_and_dispose(const_iterator, const_iterator, Disposer);
  template<typename Disposer> 
    size_type erase_and_dispose(const key_type &, Disposer);
  template<typename KeyType, typename KeyTypeKeyCompare, typename Disposer> 
    size_type erase_and_dispose(const KeyType &, KeyTypeKeyCompare, Disposer);
  void clear();
  template<typename Disposer> void clear_and_dispose(Disposer);
  size_type count(const key_type &) const;
  template<typename KeyType, typename KeyTypeKeyCompare> 
    size_type count(const KeyType &, KeyTypeKeyCompare) const;
  iterator lower_bound(const key_type &);
  template<typename KeyType, typename KeyTypeKeyCompare> 
    iterator lower_bound(const KeyType &, KeyTypeKeyCompare);
  const_iterator lower_bound(const key_type &) const;
  template<typename KeyType, typename KeyTypeKeyCompare> 
    const_iterator lower_bound(const KeyType &, KeyTypeKeyCompare) const;
  iterator upper_bound(const key_type &);
  template<typename KeyType, typename KeyTypeKeyCompare> 
    iterator upper_bound(const KeyType &, KeyTypeKeyCompare);
  const_iterator upper_bound(const key_type &) const;
  template<typename KeyType, typename KeyTypeKeyCompare> 
    const_iterator upper_bound(const KeyType &, KeyTypeKeyCompare) const;
  iterator find(const key_type &);
  template<typename KeyType, typename KeyTypeKeyCompare> 
    iterator find(const KeyType &, KeyTypeKeyCompare);
  const_iterator find(const key_type &) const;
  template<typename KeyType, typename KeyTypeKeyCompare> 
    const_iterator find(const KeyType &, KeyTypeKeyCompare) const;
  std::pair< iterator, iterator > equal_range(const key_type &);
  template<typename KeyType, typename KeyTypeKeyCompare> 
    std::pair< iterator, iterator > 
    equal_range(const KeyType &, KeyTypeKeyCompare);
  std::pair< const_iterator, const_iterator > 
  equal_range(const key_type &) const;
  template<typename KeyType, typename KeyTypeKeyCompare> 
    std::pair< const_iterator, const_iterator > 
    equal_range(const KeyType &, KeyTypeKeyCompare) const;
  std::pair< iterator, iterator > 
  bounded_range(const key_type &, const key_type &, bool, bool);
  template<typename KeyType, typename KeyTypeKeyCompare> 
    std::pair< iterator, iterator > 
    bounded_range(const KeyType &, const KeyType &, KeyTypeKeyCompare, bool, 
                  bool);
  std::pair< const_iterator, const_iterator > 
  bounded_range(const key_type &, const key_type &, bool, bool) const;
  template<typename KeyType, typename KeyTypeKeyCompare> 
    std::pair< const_iterator, const_iterator > 
    bounded_range(const KeyType &, const KeyType &, KeyTypeKeyCompare, bool, 
                  bool) const;
  iterator iterator_to(reference);
  const_iterator iterator_to(const_reference) const;
  pointer unlink_leftmost_without_rebalance();
  void replace_node(iterator, reference);
  void remove_node(reference);
  void rebalance();
  iterator rebalance_subtree(iterator);
  float balance_factor() const;
  void balance_factor(float);
  template<class... Options2> void merge(sg_set< T, Options2...> &);
  template<class... Options2> void merge(sg_multiset< T, Options2...> &);
  // public static functions
  static sg_set & container_from_end_iterator(iterator);
  static const sg_set & container_from_end_iterator(const_iterator);
  static sg_set & container_from_iterator(iterator);
  static const sg_set & container_from_iterator(const_iterator);
  static iterator s_iterator_to(reference);
  static const_iterator s_iterator_to(const_reference);
  static void init_node(reference);
  // public data members
  static const bool constant_time_size;
};

Description

Шаблон класса sg_set является интрузивным контейнером, который имитирует большую часть интерфейса std::sg_set, как описано в стандарте C++.

Параметр шаблона T - это тип, которым должен управлять контейнер. Пользователь может указать дополнительные опции и если не предусмотрены параметры по умолчанию.

Контейнер поддерживает следующие варианты: base_hook<>/member_hook<>/value_traits<>, floating_point<>, size_type<> и compare<>.

`sg_set` public construct/copy/destruct

```
sg_set();
```
Effects: Constructs an empty container.

Complexity: Constant.

>>
Throws: Если value_traitsnode_traitsarerusare_traits::node конструкторы (это не происходит с крюкомпозицией). Базовая гарантия.

  >> >>> >> > > >> & cmp, > >> >>>>>>>>>>>>>> Базовая гарантия.

> > >> >> >> >> > >>> >> >>> >>>> >>>> >>> >>>>> >>>> >>>>> cmp должна быть функцией сравнения, которая вызывает строгий слабый заказ.

Следы: Конструирует пустой контейнер и вставляет элементы из [b, e).

Сложность: Линейный в N, если [b, e) уже сортируется с помощью компа и в противном случае N * log N, где N - расстояние между первым и последним.

Throws Интрузивные крючки) или копировальный конструктор/оператор () бросков объекта Key_compare. Базовая гарантия.

```
sg_set(sg_set & x);
```
Effects: to-do
```
sg_set & оператор=(sg_set & x);
```
Effects: to-do
```
~sg_set();
```
Effects: Detaches all elements from this. Объекты в наборе не удаляются (т. е. не называются деструкторами), но узлы в соответствии с параметром шаблона value_traits являются восстановленными и, таким образом, могут быть повторно использованы.

комплексность: Линейный к элементам, содержащимся в *это.

Throws: Ничего.

`sg_set` public member functions

```
iterator begin();
```
Effects: Returns an iterator indicating to the beginning of the container.

Complexity: Constant.

Throws Ничего.
```
const_iterator begin() const;
```
Effects: Returns a const_iterator, указывающий на начало контейнера.

Complexity: Constant.

Throw
```
const_iterator cbegin() const;
```
Effects: Returns a const_iterator, указывающий на начало контейнера.

Complexity: Constant.

<1718>
```
iterator end();
```
Effects: Returns an iterator indicating to the end of the container.

Complexity: Constant.

Throws: Nothing.
```
const_iterator end() const;
```
Effects: Returns a const_iterator указывающий на конец контейнера.

Complexity: Constant.

ThrowsНичего не >>>>>>>

const_iterator cend() const;

Effects: Returns a const_iterator, указывающий на конец контейнера.

Complexity: Constant.

Throw
```
reverse_iterator rbegin();
```
Effects: Returns a reverse_iterator указывающий на начало обратного контейнера.

Complexity: Constant.

Throws<172> Ничего.

const_reverse_iterator rbegin() const;

Effects: Returns a const_reverse_iterator указывающий на начало обратного контейнера.

Complexity: Constant.
```
const_reverse_iterator crbegin() const;
```
Effects: Returns a const_reverse_iterator указывающий на начало обратного контейнера.

Complexity: Constant.
```
reverse_iterator rend();
```
Effects: Returns a reverse_iterator, указывающий на конец обратного контейнера.

Complexity: Constant.

Throws
```
const_reverse_iterator rend() const;
```
Effects: Returns a const_reverse_iterator указывающий на конец обратного контейнера.

complexity: Constant.
```
const_reverse_iterator crend() const;
```
Effects: Returns a const_reverse_iterator указывающий на конец обратного контейнера.

complexity: Constant.
```
iterator root();
```
Effects: Returns a iterator indicating to the root node of the container or end() if not present.

Complexity: Constant.

Throws<172> Ничего.

const_iterator root() const;

Effects: Returns a const_iterator указывающий на корневой узел контейнера или cend() если не присутствует.
Complexity: Constant.
```
const_iterator croot()const;
```
Effects: Returns a const_iterator указывающий на корневой узел контейнера или cend() если не присутствует.

Complexity: Constant.
```
key_compare key_comp() const;
```
Effects: Returns the key_compare object used by the container.

Complex: Constant.

Throws>>>>>> Если Key_compare выбрасывает копи-конструктор.
```
 value_compare  value_comp() const;
```
Effects: Returns the value_compare object used by the container.

Complex: Constant.

Throws>>>>> Если value_compare copy-constructor бросает.
```
bool пустая() const;
```
Следы: возвраты верны, если контейнер пуст.

Complexity: Constant.

Throws
```
size_type size() const;
```
Effects: Возвращает количество элементов, хранящихся в контейнере.

Complexity: Линейный к элементам, содержащимся в *это при отключении варианта постоянного времени. Постоянное время в противном случае.

Торы: Ничего.
```
void swap(sg_set & другие);
```
Следы: Перекрывает содержимое двух контейнеров.

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

20>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Если своп-звонок фанктора сравнения бросится.

 Шаблон Dis>void clone_ from(const sg_set & src, Cloner Cloner должен уступить узлам, эквивалентным исходным узлам.
 Следы: Erases all the elements from *This call Disposer::operator() (pointer), клонирует все элементы из src, звонящего Cloner::operator() (const_reference) и вставляет их на *это. 
 Комплексность: Линейный для стерты плюс вставленные элементы.
 Throws: Если клонист бросает или предикатирует присвоение копий. Базовая гарантия. Дополнительные примечания: он также копирует альфа-фактор из исходного контейнера.

 Шаблон>void clone_from(sg_set>>>>>>>%2> Cloner должен уступить узлам, эквивалентным исходным узлам.
 Следы: Erases all the elements from *This call Disposer::operator() (pointer), клонирует все элементы из src call Cloner::operator (reference) и вставляет их на *это. 
 <340>Комплексность: Линейный для стерты плюс вставленные элементы.
 <340>Throws: Если клонист бросает или предикатное копирование. Базовая гарантия.
 Note: Эта версия может изменить исходный контейнер, полезный для реализации семантики перемещения. Дополнительные примечания: он также копирует альфа-фактор из исходного контейнера.

Средние ссылки> >>>>> >> >>> >>> >> >>332> >>>2> >>>2>>>>>>>>>>>>>>>>>>2>>>>>2>>>2>>>>>30>>30>>>30> Никаких копирайтеров не называют.
>>>>>>>>>>>>2>>>>>>>>>2>20>
>20>20>000>0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 Никаких копирайтеров не называют.
> > > >>> > >>>> > > > > > > >>> >>> >>> >>>>>> >> >> >>> Если значение может быть добавлено, то оно верно в возвратной паре боролеана и заполняет «commit_data», которая предназначена для использования с функцией «insert_commit».

Complexity: Средняя сложность в большинстве логарифмических.

Throws: Если функция композаказания бросается. Сильная гарантия.
> >> >> >>> >>> 18>>> >> > >> >> > >> >>>> Если значение может быть добавлено, то оно верно в возвратной паре боролеана и заполняет «commit_data», которая предназначена для использования с функцией «insert_commit».

Complexity: Logarithmic в целом, но это амортизированное постоянное время, если t вставляется непосредственно перед подсказкой.

Throws: Если функция компоринга бросается. Сильная гарантия.

template<имя типа > >> > > > >> >> >> > >> > >>>>>>>>>>>>> Различие заключается в том, что комп сравнивает произвольный ключ с содержащимися значениями.

Следы: Проверяет, может ли значение быть вставлено в контейнер, используя предоставленный пользователем ключ вместо самого значения.

Возвращения: Если есть эквивалентное значение возвращает пару, содержащую итератор, к уже существующему значению и ложному. Если значение может быть добавлено, то оно верно в возвратной паре боролеана и заполняет «commit_data», которая предназначена для использования с функцией «insert_commit».

Сложность: Средняя сложность в большинстве логарифмических.

Throws: Если функция композаказывания бросается. Сильная гарантия.

Заметки: Эта функция используется для улучшения производительности при построении значения_типа дорого: если есть эквивалентное значение, то построенный объект должен быть отброшен. Много раз часть узла, которая используется для наложения заказа, намного дешевле для построения, чем тип value_, и эта функция предлагает возможность использовать эту часть, чтобы проверить, будет ли вставка успешной.

Если проверка успешена, пользователь может конструировать значение_type и использовать "insert_commit" для вставки объекта в постоянное время. Это дает полную логарифмическую сложность для вставки: check(O(log(N)) + commit(O(1)).

"commit_data" остается действительным для последующего "insert_commit" только в том случае, если больше объектов не вставлены или стерты из контейнера.

template<имя типа > > > > >>> >>> >>> >> >> >>> > > > >>> >>>>>>>> >> > >> Различие заключается в том, что комп сравнивает произвольный ключ с содержащимися значениями.

Следы: Проверяет, может ли значение быть вставлено в контейнер, используя предоставленный пользователем ключ вместо самого значения, используя «синт» в качестве намека на то, где он будет вставлен.

Возвращение: Если есть эквивалентное значение возвращает пару, содержащую итератор, к уже существующему значению и ложному. Если значение может быть добавлено, то оно верно в возвратной паре боролеана и заполняет «commit_data», которая предназначена для использования с функцией «insert_commit».

Complexity: Logarithmic в целом, но это амортизированное постоянное время, если t вставляется непосредственно перед подсказкой.

Throws: Если функция компоринга бросается. Сильная гарантия.

Заметки: Эта функция используется для улучшения производительности при построении значения_типа дорого: если есть эквивалентное значение, то построенный объект должен быть отброшен. Много раз часть конструкции, которая используется для наложения заказа, намного дешевле для построения, чем тип value_, и эта функция предлагает возможность использовать этот ключ, чтобы проверить, будет ли вставка успешной.

Если проверка успешена, пользователь может построить параметр value_type и использовать "insert_commit" для вставки объекта в постоянное время. Это может дать полную сложность постоянного времени для вставки: check(O(1)) + commit(O(1)).

```
 Шаблон<имя  Итератор> void insert(Итатор b, Итатор e>>
```
<2930>Рекверы<312> Однако это линейно в N, если диапазон уже отсортирован по value_comp().

Throws: Nothing.

<330>Note: Не влияет на действительность итераторов и ссылок. Никаких копирайтеров не называют.

```
iterator insert_commit(reference value, const insert_commit_data & commit_data);
```
Requires: значение должно быть значением l value_type. commit_data, должно быть, был получен из предыдущего звонка на «insert_check».
>
Ревки: Вставка значения в контейнере с помощью информации, полученной из "commit_data", которую заполнили предыдущие "insert_check".
>>РевацииИсполнители: Итератор для вновь вставленного объекта.
>>>>>>> Никакое значение не должно быть вставлено или стерто между вызовами "insert_check" и "insert_commit".
>> 1>insert_ before (const_iterator pos, reference value7>;
Requires: значение должно быть l value, "pos" должен быть действительным итератором (или концом) и должен быть успецесором значения, вставленным в соответствии с предикатом
>>>
>>>>
>>>>>>
>>>>>
>>>>>>>>> Это низкоуровневая функция, которая будет использоваться только по причинам производительности продвинутыми пользователями.
```
void push_back(reference value);
```
Requires: значение должно быть l value, и оно должно быть не меньше, чем наибольший вставленный ключ
Effects Эта функция немного более эффективна, чем использование «insert_ before». Это низкоуровневая функция, которая будет использоваться только по причинам производительности продвинутыми пользователями.
```
void push_front(reference value);
```
Requires: значение должно быть l value, и оно должно быть не больше, чем минимальный вставленный ключ

Effects Эта функция немного более эффективна, чем использование «insert_ before». Это низкоуровневая функция, которая будет использоваться только по причинам производительности продвинутыми пользователями.
```
iterator erase(const_iterator i);
```
Effects: Erases элемент, на который указывает i.

Complexity Средняя сложность для стерточного элемента - постоянное время.
Не называются деструкторы.

> >>> > ;
Effects: Erases the range pointed to b end e.

Complexity<232> Не называются деструкторы.

ОноОно> >> >>>>> >2>>>2>>>2>2>>2>2>20>
2>20
20>20>20>20000>2000>200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 Не называются деструкторы.

template<имя типа KeyType> KeyType erase(const KeyType & key, KeyTypeKeyCompare compkey;

Requirestype По данным сравнечного функтора «comp».

<338>Возвращение: Количество стертых элементов.

<338>Сложность: O(log(size() + N).

Throws: Nothing.

<338>Note: Invalidates iterators (не ссылки на стертение). Не называются деструкторы.

  >> >> >> > > 2>> >>> >> 2>> 29>> 
>>30>

> >> > >> > > > > > > >

 Шаблон<имя  Disposer> size_type erase_and_dispose(constkey_type & key,Disposer Disposer::operator() (pointer) призван к удаленным элементам.
 <33334>Возвращение: Число стертых элементов.
 <33334>Сложность: O(log(size() + N).
 <334>Throws: Nothing.
 <334>Note Не называются деструкторы.

ОноОноОно>Оно>>Оно>>>> согласно сопоставлению фанктора «Комп». Disposer::operator() (pointer) предназначен для удаленных элементов.

Возвращения: Число стертых элементов.

Сложность: O(log(size() + N).

Throws: Nothing.
<44445>Note
```
void clear();
```
Effects: Erases all of the elements.

Complexity: Linear to the number of elements on the container. если это безопасный или авто-unlink value_type. Постоянное время в противном случае.

Торы: Ничего.

Note: Инвалидирует итераторы (но не ссылки) на стертые элементы. Не называются деструкторы.
```
template<typename Disposer> void clear_and_dispose(DisposerИсполнитель;;
```
>
Effects: Erases all of the elements callingr(p) Сложность: Средняя сложность для большинства O(log(size() + N)), где N - число элементов в контейнере.

Throws: Nothing.

Note: Инвалидирует итераторы (но не ссылки) на стертые элементы. Призывы Время от времени до фанктора.

size_type count(const key_type & key) const;

Effects>

template<имя типа  > >>        >> >           >  >>> >>337>

```
iterator lower_bound(const key_type & key;
```
Effects: Возвращает итератор к первому элементу, ключ которого не меньше k или конца(), если этого элемента не существует

<212>

template<имя типа keyCompare> iterator lower_bound(const KeyType & key, KeyTypeKeyCompare comp>Effect<392>>

const_iterator lower_bound(const key_type & key) const;

Effects: возвратит итератор к первому элементу, ключ которого не меньше kmic или endplex, если этого элемента не существует
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

template<имя типа keyCompare> const_iterator lower_bound><>(consare KeyType & key, KeyType

iterator upper_bound (const key_type & key;

Effects: Возвращает итератор к первому элементу, ключ которого больше k или конца(), если этого элемента не существует.

<2222>

template<имя типа > >> > > > >> >> > > > >> >> >>>
37>

const_iterator upper_bound(const key_type & key) const;

Effects: возвратит итератор к первому элементу, ключ которого больше k или end(plex), если этого элемента не существует.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

template<имя типа Клавиатуре> KeyType >> , Клавиатуре

iterator find(const key_type & key;

Effects: Находится итератор на первый элемент, ключом которого является k или конец(), если этого элемента не существует.

Сложность: Logarithmic.

Throws: Если key_compare бросает.

template<имя типа Найти > Тиератор 16>Финд(>Киаг>> KeyType ключ, KeyTypeKeyCompare

const_iterator find (const key_type & key) const;

Effects: Найти итератор к первому элементу, ключ которого k или end() не существует.

template<имя типа >> > > >> > > >>

std::pair< iterator, iterator > equal_range(const key_type & key>; >>>>>>>>>3>>>>>>>>>>>>>>3>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>3>>>>>>>>3>>>>>>>>>>>>>>3>>>>>>>>>>>>>>>>>3>>>>>>>>3>>>>>> Находится диапазон, содержащий все элементы, ключ которых k или пустой диапазон, который указывает положение, где эти элементы будут, если нет элементов с ключом k.
 <336>Сложность: Logarithmic.
 Throws: Если key_compare бросить.

template<имя типа > >  > >>> > >> >>>> > >   >  > >>>>>>>>>> Находится диапазон, содержащий все элементы, ключ которых k или пустой диапазон, который указывает положение, где эти элементы будут, если нет элементов с ключом k.
 Сложность: Logarithmic.
 Throws: Если comp бросает.

std::Паир< const_iterator, const_iterator > e_range(const_type

template<имя типа  > > > >   > >  =2>      >  >> >>>

> > > >> >> > > > > > >

первый = нижний предел (нижний ключ) если левый, верхний_подъемный (нижний ключ) в противном случае

второй = верхний_привод (upper_key)>

template<имя типа   >          >  >         
 16> = нижний_округ (нижний_ключ, комп) если левый_закрытый, верхний_обратный(нижний_округ, комп)

> > > >> > > > > > >

Следы: Возвращает пару со следующими критериями:

первый = нижний предел (нижний ключ) если левый, верхний_привод (нижний ключ) в противном случае

секундный = верхний_привод (upper_key) если правый, нижний_привод (upper_key)

template<имя типа < 3> < 3> < 2> < 13> < 2> > >

первый = нижний (нижний) ключ, комп) если левый_закрытый, верхний_прицеп (нижний_под ключ, комк)

iterator iterator_to(reference value);

Requires: значение должно быть l value и должно быть в наборе подходящего типа. В противном случае поведение не определено.

Следы: Возврат: действительный итератор i, принадлежащий к набору, который указывает на значение

комплексность: Постоян.

Throws: Ничего.
```
const_iterator iterator_to(const_reference value) const;
```
Requires: значение должно быть l value и должно быть в наборе соответствующего типа. В противном случае поведение не определено.

Следы: Возвращение: действительный конст-итератор i, принадлежащий к набору, который указывает на значение

комплексность: Постоян.

Throws: Ничего.
```
pointer unlink_leftmost_ without_re balance();
```
Effects: Unlinks the leftmost node from the container.

>Complexity Средняя сложность - постоянное время.

Throws Эта функция обычно используется для достижения поэтапного контролируемого уничтожения контейнера.
```
void replace_node(iterator replace_this, reference with_this;
```
Requires: replace_ this must be a valid iterator of *this and with_this must not be included in any container.

Eff>< Контейнер не нуждается в перебалансировке.

Комплексность: Постоян.

Throws: Nothing.

Note: Данная функция будет нарушать порядок контейнера инвариантов, если с_это не эквивалентно *заменить это согласно правилам заказа. Эта функция быстрее, чем стирание и вставка узла, поскольку не требуется перебалансировки или сравнения.

void remove_node(reference value);

Effects: удалить "значение" из контейнера.

Throws: Nothing.

void баланс();

Следы: Ребалансы дерево.

Throws: Nothing.

Complexity: Linear.

1>2> > re balance_subtree(iterator root);
Requires: old_root является узлом дерева.

Effects
```
float баланс_factor()const;
```
Returns: Баланс-фактор (альфа) используется в этом дереве

Throws: Nothing.

Комплексность
```
void баланс_factor(float new_alpha);
```
Требуются: new_alpha должно быть значением между 0.5 и 1.0

Effects: устанавливает новый баланс (alpha) и rerow><

 <класс... Варианты2> void 15>merge(sg_set<T, Если есть элемент в ключе, эквивалентном ключу элемента из источника, то этот элемент не извлекается из источника.
 Почтовые условия: Указательные элементы и ссылки на переданные элементы источника относятся к тем же элементам, но как члены *это. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на их элементы, но теперь они ведут себя как итераторы в *это, а не в источник.
  Throws: Ничего, если объект сравнения не бросает.
 Сложность: N log(a.size() + N) (N имеет источник значений.size()

  >> >>> 14>> > > 14>> >> 3> >> > >> > >>>>>>>>>>>>>>>>>> Если есть элемент в ключе, эквивалентном ключу элемента из источника, то этот элемент не извлекается из источника.
 Почтовые условия: Указательные элементы и ссылки на переданные элементы источника относятся к тем же элементам, но как члены *это. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на их элементы, но теперь они ведут себя как итераторы в *это, а не в источник.
  Throws: Ничего, если объект сравнения не бросает.
 Сложность: N log(a.size() + N) (N имеет источник значений.size()

`sg_set` public static functions

КонтейнерКонтейнерКонтейнерКонтрактор2>Контрактор2>КонтейнерКонтейнерКонтрактор2>Контрактор2>Контрактор>20>

>2>>>2>>>2>>2>>2>>2>>2>>>2>>>2>>2>>>2>>2>>>22>>22>25>2>2>20>20>20>20>2>2>>2>>2>>2>>>2>>>2>>>>>>>>2>>>>>2>>>>>22>>>>22>>>2>>2>>2>>>>2>>2>>>>>2>>>>>>>>>>>>2>>>>>>>>>>>>>>>>>2>>>>>>>>>>>>>>>>>>>>>2>>>>>>>>>>>>>>>>>>>>>>>>>2>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

статический sg_set & контейнер_из_итератор(итератор он);

Контейнер<232>>><>>>>>>

статический const sg_set & 11>контейнер_из_итератора(const_iterator );

Условие>Установить>

```
статический итатор s_iterator_to(reference value);
```
Requires: значение должно быть l value и должно быть в наборе соответствующего типа. В противном случае поведение не определено.

Следы: Возврат: действительный итератор i, принадлежащий к набору, который указывает на значение

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

Throws: Ничего.

Ноте: Эта статическая функция доступна только в том случае, если >>
```
статический const_iterator s_iterator_to(const_reference value);
```
Requires: значение должно быть l value и должно быть в наборе соответствующего типа. В противном случае поведение не определено.

Следы: Возврат: действительный итератор i, принадлежащий к набору, который указывает на значение

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

Throws: Ничего.

Ноте: Эта статическая функция доступна только в том случае, если >>
```
статический void init_node(reference value);
```
<120>Requires: значение не должно быть в контейнере.

20>Следы>

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

Class template sg_set

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Reference

Boost C++ Libraries

Class template sg_set

Synopsis

Description

sg_set public construct/copy/destruct

sg_set public member functions

sg_set public static functions

`sg_set` public construct/copy/destruct

`sg_set` public member functions

`sg_set` public static functions