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

Class template unordered_set

boost::unordered_set — An unordered associative container that stores unique values.

Synopsis

// In header: <boost/unordered_set.hpp>
template<typename Value, typename Hash = boost::hash<Value>, 
         typename Pred = std::equal_to<Value>, 
         typename Alloc = std::allocator<Value> > 
class unordered_set {
public:
  // types
  typedef Value                                  key_type;            
  typedef Value                                  value_type;          
  typedef Hash                                   hasher;              
  typedef Pred                                   key_equal;           
  typedef Alloc                                  allocator_type;      
  typedef typename allocator_type::pointer       pointer;             
  typedef typename allocator_type::const_pointer const_pointer;       
  typedef value_type&                            reference;             // lvalue of value_type.
  typedef value_type const&                      const_reference;       // const lvalue of value_type.
  typedef implementation-defined                 size_type;           
  typedef implementation-defined                 difference_type;     
  typedef implementation-defined                 iterator;            
  typedef implementation-defined                 const_iterator;      
  typedef implementation-defined                 local_iterator;      
  typedef implementation-defined                 const_local_iterator;
  // construct/copy/destruct
  explicit unordered_set(size_type = implementation-defined, 
                         hasher const& = hasher(), 
                         key_equal const& = key_equal(), 
                         allocator_type const& = allocator_type());
  template<typename InputIterator> 
    unordered_set(InputIterator, InputIterator, 
                  size_type = implementation-defined, 
                  hasher const& = hasher(), key_equal const& = key_equal(), 
                  allocator_type const& = allocator_type());
  unordered_set(unordered_set const&);
  unordered_set(unordered_set &&);
  explicit unordered_set(Allocator const&);
  unordered_set(unordered_set const&, Allocator const&);
  ~unordered_set();
  unordered_set& operator=(unordered_set const&);
  unordered_set& operator=(unordered_set &&);
  allocator_type get_allocator() const;
  // size and capacity
  bool empty() const;
  size_type size() const;
  size_type max_size() const;
  // iterators
  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;
  const_iterator cbegin() const;
  const_iterator cend() const;
  // modifiers
  template<typename... Args> std::pair<iterator, bool> emplace(Args&&...);
  template<typename... Args> iterator emplace_hint(const_iterator, Args&&...);
  std::pair<iterator, bool> insert(value_type const&);
  std::pair<iterator, bool> insert(value_type&&);
  iterator insert(const_iterator, value_type const&);
  iterator insert(const_iterator, value_type&&);
  template<typename InputIterator> void insert(InputIterator, InputIterator);
  iterator erase(const_iterator);
  size_type erase(key_type const&);
  iterator erase(const_iterator, const_iterator);
  void quick_erase(const_iterator);
  void erase_return_void(const_iterator);
  void clear();
  void swap(unordered_set&);
  // observers
  hasher hash_function() const;
  key_equal key_eq() const;
  // lookup
  iterator find(key_type const&);
  const_iterator find(key_type const&) const;
  template<typename CompatibleKey, typename CompatibleHash, 
           typename CompatiblePredicate> 
    iterator find(CompatibleKey const&, CompatibleHash const&, 
                  CompatiblePredicate const&);
  template<typename CompatibleKey, typename CompatibleHash, 
           typename CompatiblePredicate> 
    const_iterator 
    find(CompatibleKey const&, CompatibleHash const&, 
         CompatiblePredicate const&) const;
  size_type count(key_type const&) const;
  std::pair<iterator, iterator> equal_range(key_type const&);
  std::pair<const_iterator, const_iterator> equal_range(key_type const&) const;
  // bucket interface
  size_type bucket_count() const;
  size_type max_bucket_count() const;
  size_type bucket_size(size_type) const;
  size_type bucket(key_type const&) const;
  local_iterator begin(size_type);
  const_local_iterator begin(size_type) const;
  local_iterator end(size_type);
  const_local_iterator end(size_type) const;
  const_local_iterator cbegin(size_type) const;
  const_local_iterator cend(size_type);
  // hash policy
  float load_factor() const;
  float max_load_factor() const;
  void max_load_factor(float);
  void rehash(size_type);
  void reserve(size_type);
};
// Equality Comparisons
template<typename Value, typename Hash, typename Pred, typename Alloc> 
  bool operator==(unordered_set<Value, Hash, Pred, Alloc> const&, 
                  unordered_set<Value, Hash, Pred, Alloc> const&);
template<typename Value, typename Hash, typename Pred, typename Alloc> 
  bool operator!=(unordered_set<Value, Hash, Pred, Alloc> const&, 
                  unordered_set<Value, Hash, Pred, Alloc> const&);
// swap
template<typename Value, typename Hash, typename Pred, typename Alloc> 
  void swap(unordered_set<Value, Hash, Pred, Alloc>&, 
            unordered_set<Value, Hash, Pred, Alloc>&);

Description

Параметры шаблонов

Ценность	<`Value`>должно быть<`Erasable`>из контейнера (т.е.<`allocator_traits`>может<`destroy`>).
Хэш	Тип объекта унарной функции, который выполняет хеш-функцию для<`Value`>. Он принимает один аргумент типа<`Value`>и возвращает значение типа std::size_t.
Пред	Объект двоичной функции, реализующий отношение эквивалентности по значениям типа<`Value`>. Объект двоичной функции, индуцирующий отношение эквивалентности на значениях типа<`Value`>. Он принимает два аргумента типа<`Value`>и возвращает значение типа bool.
Аллок	Распределитель, тип значения которого совпадает с типом значения контейнера.

Элементы организованы в ведра. Ключи с одинаковым хеш-кодом хранятся в одном ведре.

Количество ведер может быть автоматически увеличено путем вызова на вставку или в результате вызова рехэша.

`unordered_set` public types

typedeftypenameallocator_type::pointerpointer;
<value_type*>, если<allocator_type::pointer>не определен.
typedeftypenameallocator_type::const_pointerconst_pointer;
<boost::pointer_to_other<pointer, value_type>::type>, если<allocator_type::const_pointer>не определено.
typedefреализация-определенразмер_тип;
Неподписанный интегральный тип.
размер_тип может представлять любое неотрицательное значение разности_типа.
typedefреализация-определенdifference_type;
Подписанный интегральный тип.
Идентичен разностному типу итератора и const_iterator.
typedefреализация-определенитератор;
постоянный итератор, значением которого является значение_тип.
Категория итератора является, по крайней мере, передним итератором.
Конвертируемый в const_iterator.
typedefреализация-определенconst_iterator;
Постоянный итератор, значением которого является значение_type.
Категория итератора является, по крайней мере, передним итератором.
typedefреализация-определенлокальный_iterator;
Итератор с тем же типом значения, типом разности и указателем и эталонным типом, что и итератор.
Для итерации через одно ведро может использоваться локальный_итератор.

typedefреализация-определен const_local_iterator;
Постоянный итератор с тем же типом значений, разностным типом и указателем и эталонным типом, что и const_iterator.
Объект const_local_iterator может использоваться для итерации через одно ведро.

`unordered_set` public construct/copy/destruct

<
```
explicitunordered_set(size_typen=implementation-defined,
                      hasherconst&hf=hasher(),
                      key_equalconst&eq=key_equal(),
                      allocator_typeconst&a=allocator_type());
```
>
Конструирует пустой контейнер с по меньшей мере n ведер, используя hf в качестве хеш-функции, eq в качестве основного предиката равенства, a в качестве распределителя и максимального коэффициента нагрузки 1,0.
Последующие условия:
<size() == 0>
Требуется:

If the defaults are used, hasher, key_equal and allocator_type need to be DefaultConstructible.

[ORIG_END] -->

template<typename InputIterator> 
  unordered_set(InputIterator f, InputIterator l, 
                size_type n = implementation-defined, 
                hasher const& hf = hasher(), 
                key_equal const& eq = key_equal(), 
                allocator_type const& a = allocator_type());

Constructs an empty container with at least n buckets, using hf as the hash function, eq as the key equality predicate, a as the allocator and a maximum load factor of 1.0 and inserts the elements from [f, l) into it.

Требуется:

If the defaults are used, hasher, key_equal and allocator_type need to be DefaultConstructible.

```
unordered_set(unordered_set const&);
```
The copy constructor. Copies the contained elements, hash function, predicate, maximum load factor and allocator.

If Allocator::select_on_container_copy_construction exists and has the right signature, the allocator will be constructed from its result.

Требуется:

<value_type>является копируемым

unordered_set(unordered_set &&);

The move constructor.

Примечания:

This is implemented using Boost.Move.

Требуется:

value_type is move constructible.

On compilers without rvalue reference support the emulation does not support moving without calling boost::move if value_type is not copyable. So, for example, you can't return the container from a function.

<
```
explicitunordered_set(Allocatorconst&a);
```
>
Конструирует пустой контейнер, используя распределитель<a>
.
<
```
unordered_set(unordered_setconst&x,Allocatorconst&a);
```
>
Конструирует контейнер, копируя<x>элементы, хеш-функцию, предикат, максимальный коэффициент нагрузки, но используя распределитель<a>
.
<
```
~unordered_set();
```
>

Оператор назначения. Копии содержат элементы, хеш-функцию, предикат и максимальный коэффициент нагрузки, но не распределитель.

Если<Alloc::propagate_on_container_copy_assignment>существует и<

Alloc::propagate_on_container_copy_assignment::value

>истинно, то распределитель перезаписывается, если не скопированные элементы создаются с помощью существующего распределителя.

Если<Alloc::propagate_on_container_move_assignment>существует и<

Alloc::propagate_on_container_move_assignment::value

>истинно, то распределитель перезаписывается, если не движущиеся элементы создаются с помощью существующего распределителя.

`unordered_set` size and capacity

<
```
boolempty()const;
```
>
Возвращение:
<size() == 0>
<
```
size_typesize()const;
```
>
Возвращение:
<std::distance(begin(),end())>
<
```
size_typemax_size()const;
```
>
Возврат:
<size()>самого большого контейнера.

`unordered_set` iterators

iteratorbegin();
const_iteratorbegin()const;

Возвращение:

Итератор, относящийся к первому элементу контейнера, или если контейнер опорожняет значение прошедшего конца для контейнера.

<
```
iteratorend();
const_iteratorend()const;
```
>
Возвращение:
Итератор, который относится к последнему значению для контейнера.

const_iteratorcbegin()const;

Возвращение:

Постоянный итератор, относящийся к первому элементу контейнера, или если контейнер опорожняет значение «прошлый конец» для контейнера.

<
```
const_iteratorcend()const;
```
>
Возвращение:
Постоянный итератор, который относится к последнему значению для контейнера.

`unordered_set` modifiers

template<typename... Args> std::pair<iterator, bool> emplace(Args&&... args);

Inserts an object, constructed with the arguments args, in the container if and only if there is no element in the container with an equivalent value.

Требуется:	`value_type` is `EmplaceConstructible` into `X` from `args`.
Returns:	The bool component of the return type is true if an insert took place. If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent value.
Throws:	If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
Примечания:	Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. Pointers and references to elements are never invalidated. If the compiler doesn't support variadic template arguments or rvalue references, this is emulated for up to 10 arguments, with no support for rvalue references or move semantics. Since existing `std::pair` implementations don't support `std::piecewise_construct` this emulates it, but using `boost::unordered::piecewise_construct`.

template<typename... Args> 
  iterator emplace_hint(const_iterator hint, Args&&... args);

Inserts an object, constructed with the arguments args, in the container if and only if there is no element in the container with an equivalent value.

hint is a suggestion to where the element should be inserted.

Требуется:	`value_type` is `EmplaceConstructible` into `X` from `args`.
Returns:	If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent value.
Throws:	If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
Примечания:	The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same value. Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. Pointers and references to elements are never invalidated. If the compiler doesn't support variadic template arguments or rvalue references, this is emulated for up to 10 arguments, with no support for rvalue references or move semantics. Since existing `std::pair` implementations don't support `std::piecewise_construct` this emulates it, but using `boost::unordered::piecewise_construct`.

std::pair<iterator, bool> insert(value_type const& obj);

Inserts obj in the container if and only if there is no element in the container with an equivalent value.

Требуется:	`value_type` is `CopyInsertable`.
Returns:	The bool component of the return type is true if an insert took place. If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent value.
Throws:	If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
Примечания:	Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. Pointers and references to elements are never invalidated.

std::pair<iterator,bool>insert(value_type&&obj);

Вставляется<obj>в контейнер, если и только если в контейнере нет элемента с эквивалентным значением.

Предписания: [!-- [ORIG_BEGIN] Требуется: Требуется:	`value_type` is `MoveInsertable`.
Returns:	The bool component of the return type is true if an insert took place. If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent value.
Throws:	If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
Примечания:	Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. Pointers and references to elements are never invalidated.

[ORIG_END] -->

iterator insert(const_iterator hint, value_type const& obj);

Inserts obj in the container if and only if there is no element in the container with an equivalent value.

hint is a suggestion to where the element should be inserted.

Требуется:	`value_type` is `CopyInsertable`.
Returns:	If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent value.
Throws:	If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
Примечания:	The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same value. Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. Pointers and references to elements are never invalidated.

iterator insert(const_iterator hint, value_type&& obj);

Inserts obj in the container if and only if there is no element in the container with an equivalent value.

hint is a suggestion to where the element should be inserted.

Требуется:	`value_type` is `MoveInsertable`.
Returns:	If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent value.
Throws:	If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
Примечания:	The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same value. Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. Pointers and references to elements are never invalidated.

template<typenameInputIterator>
 voidinsert(InputIteratorfirst,InputIteratorlast);

В контейнер вставляется ряд элементов. Элементы вставляются тогда и только тогда, когда в контейнере нет элемента с эквивалентным значением.

Предписания:

Требуется:

value_type is EmplaceConstructible into X from *first.

Throws:

When inserting a single element, if an exception is thrown by an operation other than a call to hasher the function has no effect.

Примечания:

Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.

Pointers and references to elements are never invalidated.

[ORIG_END] -->

iteratorerase(const_iteratorposition);

Удалите элемент, на который указывает<position>.

Возврат:

Итератор, следующий за<position>до стирания.

Броски:

Только бросает исключение, если оно брошено<hasher>или<key_equal>.

[метод:

Примечания:

In older versions this could be inefficient because it had to search through several buckets to find the position of the returned iterator. The data structure has been changed so that this is no longer the case, and the alternative erase methods have been deprecated.

[ORIG_END] -->

<
```
size_typeerase(key_typeconst&k);
```
>
Удалите все элементы с ключом, эквивалентным<k>.
Возвращение:
Количество элементов стерто.
Броски:
Только бросает исключение, если оно брошено<hasher>или<key_equal>.

iteratorerase(const_iteratorfirst,const_iteratorlast);

Стирает элементы в диапазоне от<first>до<last>.

Возврат:

Итератор, следующий за стертыми элементами — т.е.<last>

Броски:

Только бросает исключение, если оно брошено<hasher>или<key_equal>.

В этой реализации эта перегрузка не вызывает ни одного из методов объекта функции, поэтому это не бросок, но это может быть не так в других реализациях.

voidquick_erase(const_iteratorposition);

Удалите элемент, на который указывает<position>.

Бросок:

Исключение делается только в том случае, если его бросают<hasher>или<key_equal>

. В этой реализации эта перегрузка не вызывает ни одного из методов объекта функции, поэтому это не бросок, но это может быть не так в других реализациях.

Примечания:

This method was implemented because returning an iterator to the next element from erase was expensive, but the container has been redesigned so that is no longer the case. So this method is now deprecated.

[ORIG_END] -->

void erase_return_void(const_iterator position);

Erase the element pointed to by position.

Throws:

Only throws an exception if it is thrown by hasher or key_equal.

In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.

Примечания:

<
```
voidclear();
```
>
Стирает все элементы в контейнере.
Пост-условия:
<size() == 0>
Броски:
Никогда не делайте исключений.

voidswap(unordered_set&);

Изменяет содержимое контейнера с параметром.

Если<Allocator::propagate_on_container_swap>объявлено и<Allocator::propagate_on_container_swap::value>истинно, то распределители контейнеров меняются. В противном случае обмен с неравными распределителями приводит к неопределенному поведению.

Броски:

Не выбрасывает исключение, если оно не брошено конструктором копии или оператором присвоения копии<key_equal>или<hasher>.

Примечания:

The exception specifications aren't quite the same as the C++11 standard, as the equality predieate and hash function are swapped using their copy constructors.

[ORIG_END] -->

`unordered_set` observers

<
```
hasherhash_function()const;
```
>
Возвращение:
Функция хеширования контейнера.
<
```
key_equalkey_eq()const;
```
>
Возвращение:
Основной предикат равенства контейнера.

`unordered_set` lookup

iteratorfind(key_typeconst&k);
const_iteratorfind(key_typeconst&k)const;
template<typenameCompatibleKey,typenameCompatibleHash,
        typenameCompatiblePredicate>
 iteratorfind(CompatibleKeyconst&k,CompatibleHashconst&hash,
               CompatiblePredicateconst&eq);
template<typenameCompatibleKey,typenameCompatibleHash,
        typenameCompatiblePredicate>
 const_iterator
 find(CompatibleKeyconst&k,CompatibleHashconst&hash,
      CompatiblePredicateconst&eq)const;

Возвращение:

Итератор, указывающий на элемент с ключом, эквивалентным<k>или<b.end()>, если такой элемент не существует.

Примечания:

The templated overloads are a non-standard extensions which allows you to use a compatible hash function and equality predicate for a key of a different type in order to avoid an expensive type cast. In general, its use is not encouraged.

[ORIG_END] -->

<
```
size_typecount(key_typeconst&k)const;
```
>
Возвращение:
Число элементов с ключом, эквивалентным<k>.

std::pair<iterator,iterator>equal_range(key_typeconst&k);
std::pair<const_iterator,const_iterator>equal_range(key_typeconst&k)const;

Возврат:

Диапазон, содержащий все элементы с ключом, эквивалентным<k>. Если контейнер не содержит таких элементов, возвращается<std::make_pair(b.end(),b.end())>.

`unordered_set` bucket interface

<
```
size_typebucket_count()const;
```
>
Возвращение:
<
```
size_typemax_bucket_count()const;
```
>
Возвращение:
Верхняя граница на число ведер.
<
```
size_typebucket_size(size_typen)const;
```
>
Требуется:

n < bucket_count()

Returns:

The number of elements in bucket n.

[ORIG_END] -->

size_typebucket(key_typeconst&k)const;

Возвращение:	Индекс ведра, который содержал бы элемент с ключом<`k`>.
Постусловия:	Возвратное значение меньше<`bucket_count()`>

```
local_iterator begin(size_type n);
const_local_iterator begin(size_type n) const;
```
Требуется:

n shall be in the range [0, bucket_count()).

Returns:

A local iterator pointing the first element in the bucket with index n.
```
local_iterator end(size_type n);
const_local_iterator end(size_type n) const;
```
Требуется:

n shall be in the range [0, bucket_count()).

Returns:

A local iterator pointing the 'one past the end' element in the bucket with index n.
```
const_local_iterator cbegin(size_type n) const;
```
Требуется:

n shall be in the range [0, bucket_count()).

Returns:

A constant local iterator pointing the first element in the bucket with index n.
```
const_local_iterator cend(size_type n);
```
Требуется:

n shall be in the range [0, bucket_count()).

Returns:

A constant local iterator pointing the 'one past the end' element in the bucket with index n.

`unordered_set` hash policy

<
```
floatload_factor()const;
```
>
Возвращение:
Среднее число элементов на ведро.
<
```
floatmax_load_factor()const;
```
>
Возврат:
Возврат текущего максимального коэффициента нагрузки.
<
```
voidmax_load_factor(floatz);
```
>
Эффекты:
Изменяет максимальный коэффициент загрузки контейнера, используя<z>в качестве подсказки.

voidrehash(size_typen);

Изменяет количество ведер так, чтобы там было хотя бы<n>ведер, и так, чтобы коэффициент нагрузки был меньше максимального коэффициента нагрузки.

Инвалидирует итераторы и изменяет порядок элементов. Указатели и ссылки на элементы не являются недействительными.

Броски:

Функция не имеет эффекта, если забрасывается исключение, если только оно не забрасывается хеш-функцией контейнера или функцией сравнения.

voidreserve(size_typen);

Инвалидирует итераторы и изменяет порядок элементов. Указатели и ссылки на элементы не признаются недействительными.

Броски:

Функция не имеет никакого эффекта, если выбрасывается исключение, если только она не выбрасывается хеш-функцией контейнера или функцией сравнения.

`unordered_set` Equality Comparisons

template<typename Value, typename Hash, typename Pred, typename Alloc> 
  bool operator==(unordered_set<Value, Hash, Pred, Alloc> const& x, 
                  unordered_set<Value, Hash, Pred, Alloc> const& y);

Return true if x.size() == y.size and for every element in x, there is an element in y with the same for the same key, with an equal value (using operator== to compare the value types).

Примечания:

The behavior of this function was changed to match the C++11 standard in Boost 1.48.

Behavior is undefined if the two containers don't have equivalent equality predicates.

template<typenameValue,typenameHash,typenamePred,typenameAlloc>
 booloperator!=(unordered_set<Value,Hash,Pred,Alloc>const&x,
                 unordered_set<Value,Hash,Pred,Alloc>const&y);

Возвращение<false>, если<x.size() == y.size>и для каждого элемента в<x>, есть элемент в<y>с тем же для того же ключа, с равным значением (используя<operator==>для сравнения типов значений).

Примечания:

The behavior of this function was changed to match the C++11 standard in Boost 1.48.

Behavior is undefined if the two containers don't have equivalent equality predicates.

[ORIG_END] -->

`unordered_set` swap

template<typenameValue,typenameHash,typenamePred,typenameAlloc>
 voidswap(unordered_set<Value,Hash,Pred,Alloc>&x,
           unordered_set<Value,Hash,Pred,Alloc>&y);

Измените содержание<x>и<y>

. Если<Allocator::propagate_on_container_swap>объявлено и<Allocator::propagate_on_container_swap::value>верно, то распределители контейнеров меняются. В противном случае обмен неравными распределителями приводит к неопределенному поведению.

Эффекты:

<x.swap(y)>

Броски:

Не выбрасывает исключение, если оно не выброшено конструктором копии или оператором присвоения копии<key_equal>или<hasher>.

Примечания:

The exception specifications aren't quite the same as the C++11 standard, as the equality predieate and hash function are swapped using their copy constructors.

[ORIG_END] -->

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

Время компиляции файла: 2024-08-30 11:47:00
2025-07-05 09:30:22/0.012753009796143/0

Примечания:	На компиляторах без ссылок на значение r это эмулируется с помощью Boost. Пошли. Обратите внимание, что на некоторых компиляторах оператор присвоения копий может использоваться в некоторых обстоятельствах.
Требуется:	<`value_type`>является подвижным конструируемым.

Возвращение:	Количество элементов стерто.
Броски:	Только бросает исключение, если оно брошено<`hasher`>или<`key_equal`>.

Пост-условия:	<`size() == 0`>
Броски:	Никогда не делайте исключений.

Требуется:	`n` shall be in the range `[0, bucket_count())`.
Returns:	A local iterator pointing the first element in the bucket with index `n`.

Class template unordered_set

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

Boost C++ Libraries

Class template unordered_set

Synopsis

Description

unordered_set public types

unordered_set public construct/copy/destruct

unordered_set size and capacity

unordered_set iterators

unordered_set modifiers

unordered_set observers

unordered_set lookup

unordered_set bucket interface

unordered_set hash policy

unordered_set Equality Comparisons

unordered_set swap

`unordered_set` public types

`unordered_set` public construct/copy/destruct

`unordered_set` size and capacity

`unordered_set` iterators

`unordered_set` modifiers

`unordered_set` observers

`unordered_set` lookup

`unordered_set` bucket interface

`unordered_set` hash policy

`unordered_set` Equality Comparisons

`unordered_set` swap