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

Class template unordered_multimap

boost::unordered_multimap — An unordered associative container that associates keys with another value. The same key can be stored multiple times.

Synopsis

// In header: <boost/unordered_map.hpp>
template<typename Key, typename Mapped, typename Hash = boost::hash<Key>, 
         typename Pred = std::equal_to<Key>, 
         typename Alloc = std::allocator<std::pair<Key const, Mapped>> > 
class unordered_multimap {
public:
  // types
  typedef Key                                    key_type;            
  typedef std::pair<Key const, Mapped>           value_type;          
  typedef Mapped                                 mapped_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_multimap(size_type = implementation-defined, 
                              hasher const& = hasher(), 
                              key_equal const& = key_equal(), 
                              allocator_type const& = allocator_type());
  template<typename InputIterator> 
    unordered_multimap(InputIterator, InputIterator, 
                       size_type = implementation-defined, 
                       hasher const& = hasher(), 
                       key_equal const& = key_equal(), 
                       allocator_type const& = allocator_type());
  unordered_multimap(unordered_multimap const&);
  unordered_multimap(unordered_multimap &&);
  explicit unordered_multimap(Allocator const&);
  unordered_multimap(unordered_multimap const&, Allocator const&);
  ~unordered_multimap();
  unordered_multimap& operator=(unordered_multimap const&);
  unordered_multimap& operator=(unordered_multimap &&);
  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> iterator emplace(Args&&...);
  template<typename... Args> iterator emplace_hint(const_iterator, Args&&...);
  iterator insert(value_type const&);
  iterator 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_multimap&);
  // 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 Key, typename Mapped, typename Hash, typename Pred, 
         typename Alloc> 
  bool operator==(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, 
                  unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&);
template<typename Key, typename Mapped, typename Hash, typename Pred, 
         typename Alloc> 
  bool operator!=(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, 
                  unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&);
// swap
template<typename Key, typename Mapped, typename Hash, typename Pred, 
         typename Alloc> 
  void swap(unordered_multimap<Key, Mapped, Hash, Pred, Alloc>&, 
            unordered_multimap<Key, Mapped, Hash, Pred, Alloc>&);

Description

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

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

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

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

`unordered_multimap` 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реализация-определенитератор;
Итератор, типом ценности которого является value_type.
Категория итератора является, по крайней мере, передним итератором.
Конвертируемый в const_iterator.
typedefреализация-определенconst_iterator;
Постоянный итератор, значением которого является значение_type.
Категория итератора является, по крайней мере, передним итератором.
typedefреализация-определенлокальный_iterator;
Итератор с тем же типом значения, типом разности и указателем и эталонным типом, что и итератор.
Для итерации через одно ведро можно использовать локальный объект.
typedefреализация-определенconst_local_iterator;
Постоянный итератор с тем же типом значений, разностным типом и указателем и эталонным типом, что и const_iterator.
Объект const_local_iterator может использоваться для итерации через одно ведро.

`unordered_multimap` public construct/copy/destruct

explicit unordered_multimap(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.

Postconditions:	`size() == 0`
Требуется:	If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be `DefaultConstructible`.

<
```
template<typenameInputIterator>
 unordered_multimap(InputIteratorf,InputIteratorl,
                    size_typen=implementation-defined,
                    hasherconst&hf=hasher(),
                    key_equalconst&eq=key_equal(),
                    allocator_typeconst&a=allocator_type());
```
>
Конструирует пустой контейнер с по меньшей мере n ведер, используя hf в качестве хеш-функции, eq в качестве основного предиката равенства, a в качестве распределителя и максимального коэффициента нагрузки 1,0 и вставляет в него элементы из [f, l].
Требуется:

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

[ORIG_END] -->
```
unordered_multimap(unordered_multimap 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_multimap(unordered_multimap &&);

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_multimap(Allocatorconst&a);
```
>
Конструирует пустой контейнер, используя распределитель<a>
.
<
```
unordered_multimap(unordered_multimapconst&x,Allocatorconst&a);
```
>
Конструирует контейнер, копируя элементы<x>, хеш-функцию, предикат, максимальный коэффициент нагрузки, но используя распределитель<a>
.
<
```
~unordered_multimap();
```
>
Примечания:

The destructor is applied to every element, and all memory is deallocated

[ORIG_END] -->

unordered_multimap& operator=(unordered_multimap const&);

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

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

Требуется:

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

unordered_multimap& operator=(unordered_multimap &&);

Оператор переезда.

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

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

allocator_type get_allocator() const;

`unordered_multimap` size and capacity

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

`unordered_multimap` iterators

iteratorbegin();
const_iteratorbegin()const;

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

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

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

const_iteratorcbegin()const;

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

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

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

`unordered_multimap` modifiers

template<typename... Args> iterator emplace(Args&&... args);

Inserts an object, constructed with the arguments args, in the container.

Требуется:	`value_type` is `EmplaceConstructible` into `X` from `args`.
Returns:	An iterator pointing to the inserted element.
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.

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

Требуется:	`value_type` is `EmplaceConstructible` into `X` from `args`.
Returns:	An iterator pointing to the inserted element.
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 key. 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`.

iterator insert(value_type const& obj);

Inserts obj in the container.

Требуется:	`value_type` is `CopyInsertable`.
Returns:	An iterator pointing to the inserted element.
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.

iterator insert(value_type&& obj);

Inserts obj in the container.

Требуется:	`value_type` is `MoveInsertable`.
Returns:	An iterator pointing to the inserted element.
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.

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

Inserts obj in the container.

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

Требуется:	`value_type` is `CopyInsertable`.
Returns:	An iterator pointing to the inserted element.
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 key. 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.

iteratorinsert(const_iteratorhint,value_type&&obj);

Вставляется<obj>в контейнер.

подсказка - это предложение о том, где элемент должен быть вставлен.

Требуется:	`value_type` is `MoveInsertable`.
Returns:	An iterator pointing to the inserted element.
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 key. 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] -->

template<typename InputIterator> 
  void insert(InputIterator first, InputIterator last);

Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key.

Требуется:

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.

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>

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

void quick_erase(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.

Примечания:

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.

voiderase_return_void(const_iteratorposition);

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

Бросок:

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

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

Примечания:

[ORIG_END] -->

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

voidswap(unordered_multimap&);

Содержимое контейнера изменяется с помощью параметра.

Если<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_multimap` observers

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

`unordered_multimap` 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_multimap` bucket interface

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

n < bucket_count()

Returns:

The number of elements in bucket n.

size_typebucket(key_typeconst&k)const;

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

<
```
local_iteratorbegin(size_typen);
const_local_iteratorbegin(size_typen)const;
```
>
Требуется:

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

Returns:

A local iterator pointing the first element in the bucket with index n.

[ORIG_END] -->
<
```
local_iteratorend(size_typen);
const_local_iteratorend(size_typen)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.

[ORIG_END] -->
```
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_multimap` hash policy

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

voidrehash(size_typen);

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

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

Броски:

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

voidreserve(size_typen);

Броски:

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

`unordered_multimap` Equality Comparisons

template<typename Key, typename Mapped, typename Hash, typename Pred, 
         typename Alloc> 
  bool operator==(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const& x, 
                  unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const& y);

Return true if x.size() == y.size and for every equivalent key group in x, there is a group in y for the same key, which is a permutation (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<typenameKey,typenameMapped,typenameHash,typenamePred,
        typenameAlloc>
 booloperator!=(unordered_multimap<Key,Mapped,Hash,Pred,Alloc>const&x,
                 unordered_multimap<Key,Mapped,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_multimap` swap

template<typenameKey,typenameMapped,typenameHash,typenamePred,
        typenameAlloc>
 voidswap(unordered_multimap<Key,Mapped,Hash,Pred,Alloc>&x,
           unordered_multimap<Key,Mapped,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_multimap раздела The Boost C++ Libraries BoostBook Documentation Subset Reference может быть полезна для разработчиков на c++ и boost.

Class template unordered_multimap

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

Boost C++ Libraries

Class template unordered_multimap

Synopsis

Description

unordered_multimap public types

unordered_multimap public construct/copy/destruct

unordered_multimap size and capacity

unordered_multimap iterators

unordered_multimap modifiers

unordered_multimap observers

unordered_multimap lookup

unordered_multimap bucket interface

unordered_multimap hash policy

unordered_multimap Equality Comparisons

unordered_multimap swap

`unordered_multimap` public types

`unordered_multimap` public construct/copy/destruct

`unordered_multimap` size and capacity

`unordered_multimap` iterators

`unordered_multimap` modifiers

`unordered_multimap` observers

`unordered_multimap` lookup

`unordered_multimap` bucket interface

`unordered_multimap` hash policy

`unordered_multimap` Equality Comparisons

`unordered_multimap` swap