234 strings / 4093 words

Translation Key Source string Target string
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ iterator insert(const_iterator hint, node_type&& nh); ```
```c++ iterator insert(const_iterator hint, node_type&& nh); ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; The iterator returned is `end()` if `nh` is empty. If insertion took place, then the iterator points to the newly inserted element; otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Behavior is undefined if `nh` is not empty and the allocators of `nh` and the container are not equal.
返回：如果 `nh` 为空，则返回的迭代器为 `end()`。如果插入发生，则迭代器指向新插入的元素；否则，指向具有等价键的元素。
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：如果 `nh` 非空且 `nh` 与容器的分配器不相等，则行为未定义。
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:968
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
try_emplace
try_emplace
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — English
```c++ template<class... Args> std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); template<class... Args> std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); template<class K, class... Args> std::pair<iterator, bool> try_emplace(K&& k, Args&&... args); ```
```c++ template<class... Args> std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); template<class... Args> std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); template<class K, class... Args> std::pair<iterator, bool> try_emplace(K&& k, Args&&... args); ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ template<class... Args> std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); template<class... Args> std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); template<class K, class... Args> std::pair<iterator, bool> try_emplace(K&& k, Args&&... args); ```
```c++
template<class... args="">
std::pair<iterator, bool=""> try_emplace(const key_type&amp; k, Args&amp;&amp;... args);
template<class... args="">
std::pair<iterator, bool=""> try_emplace(key_type&amp;&amp; k, Args&amp;&amp;... args);
template<class k,="" class...="" args="">
std::pair<iterator, bool=""> try_emplace(K&amp;&amp; k, Args&amp;&amp;... args);
```</iterator,></class></iterator,></class...></iterator,></class...>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
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 key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; This function is similiar to xref:#unordered_node_map_emplace[emplace], with the difference that no `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++
返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：此函数类似于 xref:#unordered_node_map_emplace[emplace]，区别在于如果存在具有等价键的元素，则不构造 `value_type`；否则，构造形式为：

```c++
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — English
:995
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:995
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
```c++
value_type(std::piecewise_construct,
std::forward_as_tuple(std::forward<key>(k)),
std::forward_as_tuple(std::forward<args>(args)...))
```</args></key>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — English
:1000
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — English
:1009
The `template<class K, class\... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
The `template<class K, class\... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1009
The `template<class K, class\... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
`template<class k,="" args="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1011
--
--
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1013
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — English
```c++ template<class... Args> iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); template<class... Args> iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); template<class K, class... Args> iterator try_emplace(const_iterator hint, K&& k, Args&&... args); ```
```c++ template<class... Args> iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); template<class... Args> iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); template<class K, class... Args> iterator try_emplace(const_iterator hint, K&& k, Args&&... args); ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ template<class... Args> iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); template<class... Args> iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); template<class K, class... Args> iterator try_emplace(const_iterator hint, K&& k, Args&&... args); ```
```c++ template<class... args=""> iterator try_emplace(const_iterator hint, const key_type&amp; k, Args&amp;&amp;... args); template<class... args=""> iterator try_emplace(const_iterator hint, key_type&amp;&amp; k, Args&amp;&amp;... args); template<class k,="" class...="" args=""> iterator try_emplace(const_iterator hint, K&amp;&amp; k, Args&amp;&amp;... args); ```</class></class...></class...>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; This function is similiar to xref:#unordered_node_map_emplace_hint[emplace_hint], with the difference that no `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++
返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：此函数类似于 xref:#unordered_node_map_emplace_hint[emplace_hint]，区别在于如果存在具有等价键的元素，则不构造 `value_type`；否则，构造形式为：

```c++
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — English
:1040
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — English
:1045
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — English
:1054
The `template<class K, class\... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
The `template<class K, class\... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1054
The `template<class K, class\... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
`template<class k,="" args="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1056
--
--
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1058
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
insert_or_assign
insert_or_assign
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ template<class M> std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); template<class M> std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); template<class K, class M> std::pair<iterator, bool> insert_or_assign(K&& k, M&& obj); ```
```c++
template<class m="">
std::pair<iterator, bool=""> insert_or_assign(const key_type&amp; k, M&amp;&amp; obj);
template<class m="">
std::pair<iterator, bool=""> insert_or_assign(key_type&amp;&amp; k, M&amp;&amp; obj);
template<class k,="" class="" m="">
std::pair<iterator, bool=""> insert_or_assign(K&amp;&amp; k, M&amp;&amp; obj);
```</iterator,></class></iterator,></class></iterator,></class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1072
If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.
如果存在键为 `k` 的元素，则通过赋值 `std::forward<m>(obj)` 来更新它。</m>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1074
If there is no such element, it is added to the container as: ```c++
如果不存在这样的元素，则将其添加到容器中，形式为：
```c++
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
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 key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, but only if the insert causes the load to be greater than the maximum load. + + The `template<class K, class M>` only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

`template<class k,="" class="" m="">` 仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1096
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ template<class M> iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); template<class M> iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); template<class K, class M> iterator insert_or_assign(const_iterator hint, K&& k, M&& obj); ```
```c++ template<class m=""> iterator insert_or_assign(const_iterator hint, const key_type&amp; k, M&amp;&amp; obj); template<class m=""> iterator insert_or_assign(const_iterator hint, key_type&amp;&amp; k, M&amp;&amp; obj); template<class k,="" class="" m=""> iterator insert_or_assign(const_iterator hint, K&amp;&amp; k, M&amp;&amp; obj); ```</class></class></class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1110
If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.
如果存在键为 `k` 的元素，则通过赋值 `std::forward<m>(obj)` 来更新它。</m>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1112
If there is no such element, it is added to the container as: ```c++
如果不存在这样的元素，则将其添加到容器中，形式为：
```c++
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, but only if the insert causes the load to be greater than the maximum load. + + The `template<class K, class M>` only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

`template<class k,="" class="" m="">` 仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1134
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; An opaque object implicitly convertible to the `iterator` or `const_iterator` immediately following `position` prior to the erasure. Throws:;; Nothing. Notes:;; The opaque object returned must only be discarded or immediately converted to `iterator` or `const_iterator`.
返回：一个不透明对象，可隐式转换为 `position` 在被擦除之前紧后位置的 `iterator` 或 `const_iterator`。
抛出：不抛出任何异常。
注意：返回的不透明对象只能被丢弃或立即转换为 `iterator` 或 `const_iterator`。
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1153
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ size_type erase(const key_type& k); template<class K> size_type erase(K&& k); ```
```c++ size_type erase(const key_type&amp; k); template<class k=""> size_type erase(K&amp;&amp; k); ```</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; The number of elements erased. Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
返回：被擦除的元素数量。
抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1168
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ iterator erase(const_iterator first, const_iterator last); ```
```c++ iterator erase(const_iterator first, const_iterator last); ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Erases the elements in the range from `first` to `last`.
Erases the elements in the range from `first` to `last`.
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; The iterator following the erased elements - i.e. `last`. Throws:;; Nothing in this implementation (neither the `hasher` nor the `key_equal` objects are called).
返回：被擦除元素之后的迭代器——即 `last`。
抛出：在此实现中不抛出任何异常（既不调用 `hasher` 也不调用 `key_equal` 对象）。
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1182
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1198
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ node_type extract(const_iterator position); ```
```c++ node_type extract(const_iterator position); ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; A `node_type` object holding the extracted element. Throws:;; Nothing.
返回：一个持有被提取元素的 `node_type` 对象。
抛出：不抛出任何异常。
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1211
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ node_type extract(const key_type& k); template<class K> node_type extract(K&& k); ```
```c++ node_type extract(const key_type&amp; k); template<class k=""> node_type extract(K&amp;&amp; k); ```</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; A `node_type` object holding the extracted element, or empty if no element was extracted. Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
返回：一个持有被提取元素的 `node_type` 对象；如果未提取到任何元素，则返回空。
抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1226
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
pull
pull
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ init_type pull(const_iterator position); ```
```c++ init_type pull(const_iterator position); ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1236
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ void clear() noexcept; ```
```c++ void clear() noexcept; ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1248
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ template<class H2, class P2> void merge(unordered_node_map<Key, T, H2, P2, Allocator>& source); template<class H2, class P2> void merge(unordered_node_map<Key, T, H2, P2, Allocator>&& source); ```
```c++ template<class h2,="" class="" p2=""> void merge(unordered_node_map<key, t,="" h2,="" p2,="" allocator="">&amp; source); template<class h2,="" class="" p2=""> void merge(unordered_node_map<key, t,="" h2,="" p2,="" allocator="">&amp;&amp; source); ```</key,></class></key,></class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Requires:;; `this\->get_allocator() == source.get_allocator()`. Notes:;; Invalidates iterators to the elements transferred. If the resulting size of `*this` is greater than its original maximum load, invalidates all iterators associated to `*this`.
要求：`this-&gt;get_allocator() == source.get_allocator()`。
注意：会使被转移元素的迭代器失效。如果 `*this` 的结果大小大于其原始最大负载，则会使与 `*this` 关联的所有迭代器失效。
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1266
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
get_allocator
get_allocator
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
``` allocator_type get_allocator() const noexcept; ```
``` allocator_type get_allocator() const noexcept; ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1278
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
``` hasher hash_function() const; ```
``` hasher hash_function() const; ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1288
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
key_eq
key_eq
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
``` key_equal key_eq() const; ```
``` key_equal key_eq() const; ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; The container's key equality predicate
返回：容器的键相等谓词。
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1298
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
find
find
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ iterator find(const key_type& k); const_iterator find(const key_type& k) const; template<class K> iterator find(const K& k);
```c++ iterator find(const key_type&amp; k); const_iterator find(const key_type&amp; k) const; template<class k=""> iterator find(const K&amp; k);</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```
```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; An iterator pointing to an element with key equivalent to `k`, or `end()` if no such element exists. Notes:;; The `template<class K>` overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
返回：指向键与 `k` 等价的元素的迭代器；如果不存在这样的元素，则返回 `end()`。
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1315
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
count
count
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; The number of elements with key equivalent to `k`. Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
返回：键与 `k` 等价的元素数量。
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1328
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; A boolean indicating whether or not there is an element with key equal to `key` in the container Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
返回：一个布尔值，指示容器中是否存在键等于 `key` 的元素。
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1341
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
equal_range
equal_range
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; A range containing all elements with key equivalent to `k`. If the container doesn't contain any such elements, returns `std::make_pair(b.end(), b.end())`. Notes:;; The `template<class K>` overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
返回：包含所有键与 `k` 等价的元素的范围。如果容器不包含任何此类元素，则返回 `std::make_pair(b.end(), b.end())`。
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1357
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
operator++[++++]++
operator++[++++]++
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ mapped_type& operator[](const key_type& k); mapped_type& operator[](key_type&& k); template<class K> mapped_type& operator[](K&& k); ```
```c++ mapped_type&amp; operator[](const key_type&amp; k); mapped_type&amp; operator[](key_type&amp;&amp; k); template<class k=""> mapped_type&amp; operator[](K&amp;&amp; k); ```</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Effects:;; If the container does not already contain an element with a key equivalent to `k`, inserts the value `std::pair<key_type const, mapped_type>(k, mapped_type())`. Returns:;; A reference to `x.second` where `x` is the element already in the container, or the newly inserted element with a key equivalent to `k`. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, but only if the insert causes the load to be greater than the maximum load. + + The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
效果：如果容器中不存在键与 `k` 等价的元素，则插入值 `std::pair<key_type const,="" mapped_type="">(k, mapped_type())`。
返回：对 `x.second` 的引用，其中 `x` 是容器中已存在的元素，或是新插入的键与 `k` 等价的元素。
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class></key_type>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1374
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
at
at
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; A reference to `x.second` where `x` is the (unique) element whose key is equivalent to `k`. Throws:;; An exception object of type `std::out_of_range` if no such element is present. Notes:;; The `template<class K>` overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
返回：对 `x.second` 的引用，其中 `x` 是键与 `k` 等价的（唯一）元素。
抛出：如果不存在这样的元素，则抛出 `std::out_of_range` 类型的异常对象。
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1389
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
bucket_count
bucket_count
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ size_type bucket_count() const noexcept; ```
```c++ size_type bucket_count() const noexcept; ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1401
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ float load_factor() const noexcept; ```
```c++ float load_factor() const noexcept; ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
Returns:;; `static_cast<float>(size())/static_cast<float>(bucket_count())`, or `0` if `bucket_count() == 0`.
返回：`static_cast<float>(size())/static_cast<float>(bucket_count())`，如果 `bucket_count() == 0` 则返回 `0`。</float></float>
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1413
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
max_load_factor
max_load_factor
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ float max_load_factor() const noexcept; ```
```c++ float max_load_factor() const noexcept; ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1424
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ void max_load_factor(float z); ```
```c++ void max_load_factor(float z); ```
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
:1434
---
---
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
max_load
max_load
Boost Unordered Translation (zh_Hans)/Doc / Modules / Root / Pages / Reference / Unordered Node Map (adoc) — Chinese (Simplified Han script)
```c++ size_type max_load() const noexcept; ```
```c++ size_type max_load() const noexcept; ```