类模板 unordered_multimap
:idprefix: unordered_multimap_
`boost::unordered_multimap` — 一个无序关联容器，将键与对应值相关联。同一个键可以多次存储。
概要
---
描述
*模板参数*
_键_
`Key` 必须可以从容器中 https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^]（即 `allocator_traits` 能够销毁它）。
_T_
`T` 必须可以从容器中 https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^]（即 `allocator_traits` 能够销毁它）。
_Hash_
一个一元函数对象类型，用作 `Key` 的哈希函数。它接受一个 `Key` 类型的参数，并返回一个 `std::size_t` 类型的值。
_Pred_
一个二元函数对象，用于在 `Key` 类型的值上实现等价关系。它接受两个 `Key` 类型的参数，并返回一个 `bool` 类型的值。
_Allocator_
一个分配器，其值类型与容器的值类型相同。
支持使用 https://en.cppreference.com/w/cpp/named_req/Allocator#Fancy_pointers[异形指针] 的分配器。
元素被组织到桶中。具有相同哈希码的键存储在同一桶中。
桶的数量可以通过调用 insert 自动增加，或者作为调用 rehash 的结果。
配置宏
`BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0`
全局定义此宏以支持加载由 Boost 1.84 之前版本的 Boost 保存到 Boost.Serialization 归档中的 `unordered_multimap`。
类型定义
一种迭代器，其值类型为 `value_type` 。
迭代器类别至少为前向迭代器。
可转换为 `const_iterator` 。
---
一个常量迭代器，其值类型为 `value_type` 。
迭代器类别至少为前向迭代器。
---
一种迭代器，其值类型、差值类型以及指针和引用类型均与 iterator 相同。
`local_iterator` 对象可用于遍历单个桶内的元素。
---
一个常量迭代器，其值类型、差类型、指针类型和引用类型与 `const_iterator` 相同。
`const_local_iterator` 对象可用于遍历单个桶。
---
详见 `node_handle_map`。
---
构造函数
默认构造函数
```c++ unordered_multimap(); ```
使用 `hasher()` 作为哈希函数，`key_equal()` 作为键相等谓词，`allocator_type()` 作为分配器，以及最大负载因子 `1.0` 构造一个空容器。
后置条件：`size() == 0` \n要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
桶数构造函数
```c++ explicit unordered_multimap(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); ```
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，`eql` 作为键相等谓词，`a` 作为分配器，以及最大负载因子 `1.0`。
后置条件：`size() == 0` \n要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
迭代器范围构造函数
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，`eql` 作为键相等谓词，`a` 作为分配器，以及最大负载因子 `1.0`，并将 `[f, l)` 范围内的元素插入其中。
要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
复制构造函数
```c++ unordered_multimap(const unordered_multimap& other); ```
拷贝构造函数。拷贝所包含的元素、哈希函数、谓词、最大负载因子和分配器。
如果 `Allocator::select_on_container_copy_construction` 存在且具有正确的签名，则分配器将根据其结果进行构造。
要求：`value_type` 可拷贝构造。
---
移动构造函数
```c++ unordered_multimap(unordered_multimap&& other); ```
移动构造函数。
注意：此函数使用 Boost.Move 实现。 \n要求：`value_type` 可移动构造。
---
带分配器的迭代器范围构造函数
```c++ template unordered_multimap(InputIterator f, InputIterator l, const allocator_type& a); ```
使用 `a` 作为分配器，以默认哈希函数、默认键相等谓词和最大负载因子 `1.0` 构造一个空容器，并将 `[f, l)` 范围内的元素插入其中。
要求：`hasher`、`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
分配器构造函数
```c++ explicit unordered_multimap(const Allocator& a); ```
使用分配器 `a` 构造一个空容器。
---
带分配器的复制构造函数
```c++ unordered_multimap(const unordered_multimap& other, const Allocator& a); ```
构造一个容器，拷贝 `other` 所包含的元素、哈希函数、谓词和最大负载因子，但使用分配器 `a`。
---
带分配器的移动构造函数
```c++ unordered_multimap(unordered_multimap&& other, const Allocator& a); ```
构造一个容器，移动 `other` 所包含的元素，并使用其哈希函数、谓词和最大负载因子，但使用分配器 `a`。
注意：此函数使用 Boost.Move 实现。 \n要求：`value_type` 可移动插入。
---
初始化列表构造函数
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等性谓词、及 `a` 作为分配器，并设置最大负载因子为 `1.0` ，随后将 `il` 中的元素插入该容器。
要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
带分配器的桶数构造函数
```c++ unordered_multimap(size_type n, const allocator_type& a); ```
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，使用默认的哈希函数和键相等谓词，`a` 作为分配器，以及最大负载因子 `1.0`。
后置条件：`size() == 0` \n要求：`hasher` 和 `key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
带哈希函数和分配器的桶数构造函数
```c++ unordered_multimap(size_type n, const hasher& hf, const allocator_type& a); ```
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，使用默认的键相等谓词，`a` 作为分配器，以及最大负载因子 `1.0`。
后置条件：`size() == 0` \n要求：`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
带桶数和分配器的迭代器范围构造函数
构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器，使用默认的哈希函数、默认的键相等谓词以及最大负载因子 `1.0`，并将 `[f, l)` 范围内的元素插入其中。
要求：`hasher`、`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
带桶数和哈希函数的迭代器范围构造函数
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、默认的键相等性谓词、 `a` 作为分配器，并设置最大负载因子为 `1.0` ，随后将区间 `[f, l)` 中的元素插入该容器。
要求;; `key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。
---
带分配器的初始化列表构造函数
```c++ unordered_multimap(std::initializer_list il, const allocator_type& a); ```
使用 `a` 作为分配器，最大负载因子为 `1.0`，构造一个空容器，并将 `il` 中的元素插入其中。
要求：`hasher` 和 `key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
带桶数和分配器的初始化列表构造函数
```c++ unordered_multimap(std::initializer_list il, size_type n, const allocator_type& a); ```
使用 `a` 作为分配器，最大负载因子为 `1.0`，构造一个至少包含 `n` 个桶的空容器，并将 `il` 中的元素插入其中。
要求：`hasher` 和 `key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
带桶数、哈希函数和分配器的初始化列表构造函数
```c++ unordered_multimap(std::initializer_list il, size_type n, const hasher& hf, const allocator_type& a); ```
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，`a` 作为分配器，最大负载因子为 `1.0`，并将 `il` 中的元素插入其中。
要求：`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。
---
析构函数
```c++ ~unordered_multimap(); ```
注意：析构函数会应用于每个元素，并且所有内存都会被释放。
---
赋值操作
拷贝赋值
```c++ unordered_multimap& operator=(const unordered_multimap& other); ```
赋值运算符。拷贝所包含的元素、哈希函数、谓词和最大负载因子，但不拷贝分配器。
如果 `Alloc::propagate_on_container_copy_assignment` 存在且 `Alloc::propagate_on_container_copy_assignment::value` 为 `true`，则分配器会被覆盖；否则，拷贝的元素将使用现有的分配器创建。
要求：`value_type` 可拷贝构造。
---
移动赋值
```c++ unordered_multimap& operator=(unordered_multimap&& other) noexcept(boost::allocator_traits::is_always_equal::value && boost::is_nothrow_move_assignable_v && boost::is_nothrow_move_assignable_v); ``` The move assignment operator.
如果 `Alloc::propagate_on_container_move_assignment` 存在且 `Alloc::propagate_on_container_move_assignment::value` 为 `true`，则分配器会被覆盖；否则，移动的元素将使用现有的分配器创建。
要求：`value_type` 可移动构造。
---
初始化列表赋值
```c++ unordered_multimap& operator=(std::initializer_list il); ```
从初始化列表中的值进行赋值。所有现有元素要么被新元素覆盖，要么被销毁。
要求：`value_type` 必须能够从容器中 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^] 并且满足 https://en.cppreference.com/w/cpp/named_req/CopyAssignable[可拷贝赋值^]。
迭代器
开始
```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```
返回：指向容器第一个元素的迭代器，如果容器为空则返回容器的尾后迭代器。
---
结束
"```c++ iterator end() noexcept; const_iterator end() const noexcept; ```"
返回：指向容器尾后值的迭代器。
---
cbegin
```c++ const_iterator cbegin() const noexcept; ```
返回：指向容器第一个元素的 `const_iterator`，如果容器为空则返回容器的尾后值。
---
cend
```c++ const_iterator cend() const noexcept; ```
返回：指向容器尾后值的 `const_iterator`。
---
大小与容量
空
```c++ [[nodiscard]] bool empty() const noexcept; ```
返回：`size() == 0`。
---
大小
```c++ size_type size() const noexcept; ```
返回：`std::distance(begin(), end())`。
---
max_size
```c++ size_type max_size() const noexcept; ```
返回：可能的最大容器的 `size()`。
---
修改器
原地构造
```c++ template iterator emplace(Args&&... args); ```
插入一个使用参数 `args` 构造的对象到容器中。
要求：`value_type` 必须可以从 `args` 出发在 `X` 中进行 https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。 \n返回：指向已插入元素的迭代器。 \n抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。
---
emplace_hint
```c++ template iterator emplace_hint(const_iterator position, Args&&... args); ```
插入一个使用参数 `args` 构造的对象到容器中。
`position` 是关于元素插入位置的建议。
要求：`value_type` 必须可以从 `args` 出发在 `X` 中进行 https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。 \n返回：指向已插入元素的迭代器。 \n抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n注意：标准关于 `position` 的含义表述相当模糊。但唯一实际的使用方式，也是 Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。 \n可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。
---
拷贝插入
```c++ iterator insert(const value_type& obj); ```
将 `obj` 插入容器中。
要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^]。 \n返回：指向已插入元素的迭代器。 \n抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。
---
移动插入
```c++ iterator insert(value_type&& obj); ```
将 `obj` 插入容器中。
要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入^]。 \n返回：指向已插入元素的迭代器。 \n抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。
---
原地插入
```c++ template iterator insert(P&& obj); ```
通过执行 `emplace(std::forward(value))` 向容器中插入一个元素。
仅在 `std::is_constructible<value_type, p&&=\"\">::value` 为 `true` 时参与重载决议。</value_type,>
返回：指向已插入元素的迭代器。
---
带提示的拷贝插入
```c++iterator insert(const_iterator hint, const value_type& obj);```\n将 `obj` 插入容器中。
`hint` 是关于元素插入位置的建议。
要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^]。 \n返回：指向已插入元素的迭代器。 \n抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。 \n可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。
---
带提示的移动插入
```c++ iterator insert(const_iterator hint, value_type&& obj); ```
将 `obj` 插入容器中。
`hint` 是关于元素插入位置的建议。
要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入^]。 \n返回：指向已插入元素的迭代器。 \n抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。 \n可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。
---
带提示的原地插入
```c++ template iterator insert(const_iterator hint, P&& obj); ```
通过执行 `emplace_hint(hint, std::forward(value))` 向容器中插入一个元素。
仅在 `std::is_constructible<value_type, p&&=\"\">::value` 为 `true` 时参与重载决议。</value_type,>
`hint` 是关于元素插入位置的建议。
返回：指向已插入元素的迭代器。 \n注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。 \n可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。
---
迭代器范围插入
```c++ template void insert(InputIterator first, InputIterator last); ```
将一个范围内的元素插入容器中。
要求：`value_type` 必须可以从 `*first` 出发在 `X` 中进行 https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。 \n抛出：当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。
---
初始化列表插入
```c++ void insert(std::initializer_list il); ```
将一个范围内的元素插入容器中。
要求：`value_type` 可以在容器中进行 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^]。 \n抛出：当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。
---
通过迭代器提取
```c++ node_type extract(const_iterator position); ```
移除 `position` 所指向的元素。
返回：一个拥有该元素的 `node_type`。 \n注意：通过此方法提取的节点可以插入到兼容的 `unordered_map` 中。
---
通过键提取
```c++ node_type extract(const key_type& k); template node_type extract(K&& k); ```
移除一个键与 `k` 等价的元素。
返回：如果找到该元素，则返回一个拥有该元素的 `node_type`；否则返回一个空的 `node_type`。 \n抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n注意：通过此方法提取的节点可以插入到兼容的 `unordered_map` 中。 \n\n`template` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。
---
通过 `node_handle` 插入
```c++ iterator insert(node_type&& nh); ```
如果 `nh` 为空，则无效果。
否则，插入 `nh` 所拥有的元素。
要求：`nh` 为空，或者 `nh.get_allocator()` 等于容器的分配器。 \n返回：如果 `nh` 为空，则返回 `end()`。 \n否则，返回指向新插入元素的迭代器。 \n抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。 \n此函数可用于插入从兼容的 `unordered_map` 中提取的节点。
---
带提示和 `node_handle` 的插入
```c++ iterator insert(const_iterator hint, node_type&& nh); ```
如果 `nh` 为空，则无效果。
否则，插入 `nh` 所拥有的元素。
`hint` 是关于元素插入位置的建议。
要求：`nh` 为空，或者 `nh.get_allocator()` 等于容器的分配器。 \n返回：如果 `nh` 为空，则返回 `end()`；否则，返回指向新插入元素的迭代器。 \n抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。 \n可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 \n指向元素的指针和引用永远不会失效。 \n此函数可用于插入从兼容的 `unordered_map` 中提取的节点。
---
通过位置擦除
```c++ iterator erase(iterator position); iterator erase(const_iterator position); ```
擦除 `position` 所指向的元素。
返回：`position` 在被擦除之前的后一个迭代器。 \n抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n注意：在旧版本中，此操作可能效率较低，因为它需要搜索多个桶以找到返回迭代器的位置。数据结构已经更改，不再是这种情况，并且备用的擦除方法已被弃用。
---
通过键擦除
```c++ size_type erase(const key_type& k); template size_type erase(K&& k); ```
擦除所有键与 `k` 等价的元素。
返回：被擦除的元素数量。 \n抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n注意：`template` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。
---
范围擦除
```c++ iterator erase(const_iterator first, const_iterator last); ```
擦除从 `first` 到 `last` 范围内的元素。
返回：被擦除元素之后的迭代器——即 `last`。 \n抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n在此实现中，此重载不会调用任何函数对象的方法，因此不会抛出异常，但这在其他实现中可能并不成立。
---
quick_erase
```c++ void quick_erase(const_iterator position); ```
擦除 `position` 所指向的元素。
抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n在此实现中，此重载不会调用任何函数对象的方法，因此不会抛出异常，但这在其他实现中可能并不成立。 \n注意：引入此方法是因为从 `erase` 返回指向下一个元素的迭代器成本较高，但容器已经过重新设计，不再存在这种情况。因此，此方法现已弃用。
---
erase_return_void
```c++ void erase_return_void(const_iterator position); ```
擦除 position 所指向的元素。
抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n\n在此实现中，此重载不会调用任何函数对象的方法，因此不会抛出异常，但这在其他实现中可能并不成立。 \n\n注意：引入此方法是因为从 `erase` 返回指向下一个元素的迭代器成本较高，但容器已经过重新设计，不再存在这种情况。因此，此方法现已弃用。
---
交换
```c++ void swap(unordered_multimap& other) noexcept(boost::allocator_traits::is_always_equal::value && boost::is_nothrow_swappable_v && boost::is_nothrow_swappable_v); ```
交换容器的内容与参数的内容。
如果 `Allocator::propagate_on_container_swap` 被声明且 `Allocator::propagate_on_container_swap::value` 为 `true`，则交换容器的分配器。否则，使用不相等的分配器进行交换将导致未定义行为。
抛出：除非 `key_equal` 或 `hasher` 的拷贝构造函数或拷贝赋值运算符抛出异常，否则不抛出任何异常。 \n注意：异常规范与 C++11 标准不完全相同，因为相等谓词和哈希函数是使用其拷贝构造函数进行交换的。
---
清空
```c++ void clear() noexcept; ```
擦除容器中的所有元素。
后置条件：`size() == 0` \n抛出：永不抛出异常。
---
合并
```c++ template<class h2,=\"\" class=\"\" p2=\"\"> void merge(unordered_multimap<key, t,=\"\" h2,=\"\" p2,=\"\" allocator=\"\">& source); template<class h2,=\"\" class=\"\" p2=\"\"> void merge(unordered_multimap<key, t,=\"\" h2,=\"\" p2,=\"\" allocator=\"\">&& source); template<class h2,=\"\" class=\"\" p2=\"\"> void merge(unordered_map<key, t,=\"\" h2,=\"\" p2,=\"\" allocator=\"\">& source); template<class h2,=\"\" class=\"\" p2=\"\"> void merge(unordered_map<key, t,=\"\" h2,=\"\" p2,=\"\" allocator=\"\">&& source); ```</key,></class></key,></class></key,></class></key,></class>
尝试“合并”两个容器：遍历 `source`，提取 `source` 中的所有节点，并将它们插入到 `*this` 中。
由于 `source` 可能具有不同的哈希函数和键相等谓词，因此 `source` 中每个节点的键都会使用 `this->hash_function()` 重新计算哈希值，然后在必要时使用 `this->key_eq()` 进行比较。
如果 `this->get_allocator() != source.get_allocator()`，则此函数的行为未定义。
此函数不会拷贝或移动任何元素，而是仅仅将节点从 `source` 重新定位到 `*this` 中。
注意:;; + --
指向被转移元素的指针和引用保持有效。
使被转移元素的迭代器失效。
使属于 `*this` 的迭代器失效。
指向 `source` 中未被转移元素的迭代器保持有效。
--
---
观察器
get_allocator
``` allocator_type get_allocator() const; ```
---
哈希函数
``` hasher hash_function() const; ```
返回：容器的哈希函数。
---
key_eq
``` key_equal key_eq() const; ```
返回：容器的键相等谓词。
---
查找
find
"```c++ iterator find(const key_type& k); const_iterator find(const key_type& k) const; template<class k=\"\"> iterator find(const K& k); template<class k=\"\"> const_iterator find(const K& k) const; template<typename compatiblekey,=\"\" typename=\"\" compatiblehash,=\"\" compatiblepredicate=\"\"> iterator find(CompatibleKey const& k, CompatibleHash const& hash, CompatiblePredicate const& eq); template<typename compatiblekey,=\"\" typename=\"\" compatiblehash,=\"\" compatiblepredicate=\"\"> const_iterator find(CompatibleKey const& k, CompatibleHash const& hash, CompatiblePredicate const& eq) const;</typename></typename></class></class>"
```
返回：指向键与 `k` 等价的元素的迭代器；如果不存在这样的元素，则返回 `b.end()`。 \n注意：包含 `CompatibleKey`、`CompatibleHash` 和 `CompatiblePredicate` 的模板化重载是非标准扩展，允许您为不同类型的键使用兼容的哈希函数和相等谓词，以避免昂贵的类型转换。通常不鼓励使用它们，而应使用 `K` 成员函数模板。 \u0020`template` 重载仅在 `Hash::is_transparent` `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。
---
count
```c++ size_type \u0020 \u0020 \u0020 \u0020count(const key_type& k) const; template size_type \u0020 \u0020 \u0020count(const K& k) const; ```
返回：键与 `k` 等价的元素数量。 \n注意：`template` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。
---
包含
```c++ bool \u0020 \u0020 \u0020 \u0020 \u0020 \u0020 contains(const key_type& k) const; template bool \u0020 \u0020 \u0020 \u0020 \u0020 contains(const K& k) const; ```
返回：一个布尔值，指示容器中是否存在键等于 `key` 的元素。 \n注意：`template` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。
---
equal_range
"```c++ std::pair<iterator, iterator=\"\"> equal_range(const key_type& k); std::pair<const_iterator, const_iterator=\"\"> equal_range(const key_type& k) const; template<class k=\"\"> std::pair<iterator, iterator=\"\"> equal_range(const K& k); template<class k=\"\"> std::pair<const_iterator, const_iterator=\"\"> equal_range(const K& k) const; ```</const_iterator,></class></iterator,></class></const_iterator,></iterator,>"
返回：包含所有键与 `k` 等价的元素的范围。如果容器不包含任何此类元素，则返回 `std::make_pair(b.end(), b.end())`。 \n注意：`template` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。
---
桶接口
bucket_count
```c++ size_type bucket_count() const noexcept; ```
返回：桶的数量。
---
max_bucket_count
```c++ size_type max_bucket_count() const noexcept; ```
返回：桶数量的上界。
---
桶大小
```c++ size_type bucket_size(size_type n) const; ```
要求：`n < bucket_count()` \n返回：桶 `n` 中的元素数量。
---
桶
```c++ size_type bucket(const key_type& k) const; template size_type bucket(const K& k) const; ```
返回：将包含键为 `k` 的元素的桶的索引。 \n后置条件：返回值小于 `bucket_count()`。 \n\n注意：`template` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。
---
开始
```c++ local_iterator begin(size_type n); const_local_iterator begin(size_type n) const; ```
要求：`n` 必须在 `[0, bucket_count())` 范围内。 \n返回：指向索引为 `n` 的桶中第一个元素的局部迭代器。
---
结束
```c++ local_iterator end(size_type n); const_local_iterator end(size_type n) const; ```
要求：`n` 必须在 `[0, bucket_count())` 范围内。 \n返回：指向索引为 `n` 的桶中“尾后”元素的局部迭代器。
---
cbegin
```c++ const_local_iterator cbegin(size_type n) const; ```
要求：`n` 必须在 `[0, bucket_count())` 范围内。 \n返回：指向索引为 `n` 的桶中第一个元素的常量局部迭代器。
---
cend
```c++ const_local_iterator cend(size_type n) const; ```
要求：`n` 必须在 `[0, bucket_count())` 范围内。 \n返回：指向索引为 `n` 的桶中“尾后”元素的常量局部迭代器。
---
哈希策略
负载因子
```c++ float load_factor() const noexcept; ```
返回：每个桶的平均元素数量。
---
max_load_factor
```c++ float max_load_factor() const noexcept; ```
返回：当前最大负载因子。
---
设置最大负载因子
```c++ void max_load_factor(float z); ```
效果：使用 `z` 作为提示，更改容器的最大负载因子。
---
重哈希
```c++ void rehash(size_type n); ```
更改桶的数量，使其至少包含 `n` 个桶，并且使得负载因子小于或等于最大负载因子。在适用的情况下，这将增大或缩小与容器关联的 `bucket_count()`。
当 `size() == 0` 时，`rehash(0)` 将释放底层的桶数组。
使迭代器失效，并改变元素的顺序。指向元素的指针和引用不会失效。
抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果。
---
保留
```c++ void reserve(size_type n); ```
等价于 `a.rehash(ceil(n / a.max_load_factor()))`；如果 `n > 0` 且 `a.max_load_factor() == std::numeric_limits::infinity()`，则等价于 `a.rehash(1)`。
与 `rehash` 类似，此函数可用于增大或缩小容器中的桶数量。
使迭代器失效，并改变元素的顺序。指向元素的指针和引用不会失效。
抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果。
---
推导指引
如果满足以下任一条件，则推导指引不会参与重载决议：
- 它具有一个 `InputIterator` 模板参数，并且为该参数推导出的类型不符合输入迭代器的要求。\n- 它具有一个 `Allocator` 模板参数，并且为该参数推导出的类型不符合分配器的要求。\n- 它具有一个 `Hash` 模板参数，并且为该参数推导出的类型是整数类型或符合分配器的要求。\n- 它具有一个 `Pred` 模板参数，并且为该参数推导出的类型符合分配器的要求。
推导指引中的 `size_type` 参数类型指的是由该推导指引所推导出的容器类型的 `size_type` 成员类型。其默认值与所选构造函数的默认值一致。
_iter-value-type_
__iter-key-type__
__iter-mapped-type__
__iter-to-alloc-type__
相等性比较
运算符
```c++ template<class key,=\"\" class=\"\" t,=\"\" hash,=\"\" pred,=\"\" alloc=\"\"> bool operator==(const unordered_multimap<key, t,=\"\" hash,=\"\" pred,=\"\" alloc=\"\">& x, const unordered_multimap<key, t,=\"\" hash,=\"\" pred,=\"\" alloc=\"\">& y); ```</key,></key,></class>
若 `x.size() == y.size()` 且对于 `x` 中的每个等价键组，在 `y` 中均存在一个具有相同键的组，并且该组是 `x` 中对应组的置换（使用 `operator==` 比较值类型），则返回 `true`。
注意：如果两个容器不具有等价的相等谓词，则行为未定义。
---
operator!
```c++ template<class key,=\"\" class=\"\" t,=\"\" hash,=\"\" pred,=\"\" alloc=\"\"> bool operator!=(const unordered_multimap<key, t,=\"\" hash,=\"\" pred,=\"\" alloc=\"\">& x, const unordered_multimap<key, t,=\"\" hash,=\"\" pred,=\"\" alloc=\"\">& y); ```</key,></key,></class>
若 `x.size() == y.size()` 且对于 `x` 中的每个等价键组，在 `y` 中均存在一个具有相同键的组，并且该组是 `x` 中对应组的置换（使用 `operator==` 比较值类型），则返回 `false`。
注意：如果两个容器不具有等价的相等谓词，则行为未定义。
---
交换
```c++ template<class key,=\"\" class=\"\" t,=\"\" hash,=\"\" pred,=\"\" alloc=\"\"> void swap(unordered_multimap<key, t,=\"\" hash,=\"\" pred,=\"\" alloc=\"\">& x, unordered_multimap<key, t,=\"\" hash,=\"\" pred,=\"\" alloc=\"\">& y) noexcept(noexcept(x.swap(y))); ```</key,></key,></class>
交换 x 和 y 的内容。
如果 `Allocator::propagate_on_container_swap` 被声明且 `Allocator::propagate_on_container_swap::value` 为 `true`，则交换容器的分配器。否则，使用不相等的分配器进行交换将导致未定义行为。
效果：`x.swap(y)` \n抛出：除非 `key_equal` 或 `hasher` 的拷贝构造函数或拷贝赋值运算符抛出异常，否则不抛出任何异常。 \n注意：异常规范与 C++11 标准不完全相同，因为相等谓词和哈希函数是使用其拷贝构造函数进行交换的。
---
erase_if
```c++ template<class k,=\"\" class=\"\" t,=\"\" h,=\"\" p,=\"\" a,=\"\" predicate=\"\"> typename unordered_multimap<k, t,=\"\" h,=\"\" p,=\"\" a=\"\">::size_type erase_if(unordered_multimap<k, t,=\"\" h,=\"\" p,=\"\" a=\"\">& c, Predicate pred); ```</k,></k,></class>
遍历容器 `c`，并移除所有使给定谓词返回 `true` 的元素。
"返回：被擦除的元素数量。 注意：等价于： \n```c++auto original_size = c.size();for (auto i = c.begin(), last = c.end(); i != last; ) {if (pred(*i)) {i = c.erase(i);} else {++i;}}return original_size - c.size();\n``` 注意，传递给 `pred` 的引用是非常量的。"
序列化
`unordered_multimap` 可以通过本库提供的 API，借助 link:../../../../../serialization/index.html[Boost.Serialization^] 进行归档/恢复。支持常规归档和 XML 归档。
将 unordered_multimap 保存到归档
将 `unordered_multimap` 容器 `x` 的所有元素保存到归档（XML 归档） `ar` 中。
要求：`std::remove_const::type` 和 `std::remove_const::type` 必须是可序列化的（对于 XML 归档需支持 XML 序列化），并且它们必须支持 Boost.Serialization 的 `save_construct_data`/`load_construct_data` 协议（该协议由满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 的类型自动支持）。
---
从归档加载 unordered_multimap
删除 `unordered_multimap` 容器 `x` 中所有已存在的元素，并从归档（XML 归档）`ar` 中插入从原始 `unordered_multimap` 容器 `other` 保存到 `ar` 所读取存储中的元素恢复出的副本。
要求：`value_type` 必须可以从 `(std::remove_const::type&&, std::remove_const::type&&)` 进行 https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。`x.key_equal()` 在功能上必须等价于 `other.key_equal()`。 \n注意：如果归档是使用 Boost 1.84 之前版本的 Boost 保存的，则必须全局定义配置宏 `BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0` 才能使此操作成功；否则，将抛出异常。
---
将迭代器/常量迭代器保存到归档
将迭代器（或常量迭代器）`it` 的位置信息保存到归档（XML 归档）`ar` 中。`it` 可以是一个 `end()` 迭代器。
要求：`it` 所指向的 `unordered_multimap` 容器 `x` 必须先被保存到 `ar` 中，并且在保存 `x` 和保存 `it` 之间，不能对 `x` 执行任何修改操作。
---
从归档加载迭代器/常量迭代器
使迭代器（或常量迭代器）`it` 指向原始迭代器（或常量迭代器）被保存到归档（XML 归档）`ar` 所读取存储中的位置恢复后的位置。
要求：如果 `x` 是 `it` 所指向的 `unordered_multimap` 容器，则在加载 `x` 和加载 `it` 之间，不能对 `x` 执行任何修改操作。