Zen

Translation

Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
91/1150 · 115

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
:1528
---
---
:1530
erase_if
erase_if
```c++ template<class F> size_type erase_if(F f); ```
```c++ template<class f=""> size_type erase_if(F f); ```</class>
Successively invokes `f` with non-const references to each of the elements in the table, and erases those for which `f` returns `true`.
依次以非常量引用为参数，对表中的每个元素调用 `f`，并删除所有 `f` 返回 `true` 的元素。
Returns:;; The number of elements erased. Throws:;; Only throws an exception if it is thrown by `f`.
返回值：;; 删除的元素总数。
抛出异常：;; 仅当 `f` 抛出异常时才会抛出。
:1541
---
---
Parallel erase_if
并行条件擦除
```c++ template<class ExecutionPolicy, class F> void erase_if(ExecutionPolicy&& policy, F f); ```
```c++ template<class executionpolicy,="" class="" f=""> void erase_if(ExecutionPolicy&amp;&amp; policy, F f); ```</class>
Invokes `f` with non-const references to each of the elements in the table, and erases those for which `f` returns `true`. Execution is parallelized according to the semantics of the execution policy specified.
根据指定执行策略的语义并行执行操作：依次以**非常量引用**为参数对表中的每个元素调用 `f`，并删除所有 `f` 返回 `true` 的元素。
Throws:;; Depending on the exception handling mechanism of the execution policy used, may call `std::terminate` if an exception is thrown within `f`. Notes:;; Only available in compilers supporting C++17 parallel algorithms. + + This overload only participates in overload resolution if `std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is `true`. + + Unsequenced execution policies are not allowed.
抛出异常：;; 依据所使用执行策略的异常处理机制，若 `f` 内部抛出异常，可能会调用 `std::terminate`。注意：;; 仅在支持 C++17 并行算法的编译器中可用。该重载版本仅在`std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt;` 为 `true` 时参与重载决议。不允许使用无序执行策略。</std::remove_cvref_t<executionpolicy>
:1559
---
---
swap
交换
```c++ void swap(concurrent_node_map& other) noexcept(boost::allocator_traits<Allocator>::is_always_equal::value || boost::allocator_traits<Allocator>::propagate_on_container_swap::value); ```
```c++ void swap(concurrent_node_map&amp; other) noexcept(boost::allocator_traits<allocator>::is_always_equal::value || boost::allocator_traits<allocator>::propagate_on_container_swap::value); ```</allocator></allocator>
Swaps the contents of the table with the parameter.
将当前表与参数表的内容进行交换。
If `Allocator::propagate_on_container_swap` is declared and `Allocator::propagate_on_container_swap::value` is `true` then the tables' allocators are swapped. Otherwise, swapping with unequal allocators results in undefined behavior.
若声明了 `Allocator::propagate_on_container_swap` 且其值为 `true`，则交换两个表的分配器；否则，使用不相等的分配器进行交换会导致未定义行为。
Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
抛出异常：;; 除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。
并发特性：;; 阻塞当前容器 `*this` 与目标容器 `other`。
:1576
---
---
extract
extract
```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>
Extracts the element with key equivalent to `k`, if it exists.
若存在键与 `k` 等价的元素，则提取该元素。
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` 抛出异常时才会抛出。注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员类型别名时，`template<class k="">` 重载版本才参与重载决议。库假定 `Hash` 可同时接受 `K` 类型与 `Key` 类型作为参数，且 `Pred` 是透明的。这支持异构查找，从而避免实例化 `Key` 类型对象带来的性能开销。</class>
:1591
---
---
extract_if
条件提取
```c++ template<class F> node_type extract_if(const key_type& k, F f); template<class K, class F> node_type extract_if(K&& k, F f); ```
```c++ template<class f=""> node_type extract_if(const key_type&amp; k, F f); template<class k,="" class="" f=""> node_type extract_if(K&amp;&amp; k, F f); ```</class></class>
Extracts the element `x` with key equivalent to `k`, if it exists and `f(x)` is `true`.
若存在键与 `k` 等价的元素 `x`，且 `f(x)` 返回 `true`，则提取该元素。
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` or `f`. 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` 或 `f` 抛出异常时才会抛出。
注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员类型别名时，`template<class k="">` 重载版本才参与重载决议。库假定 `Hash` 可同时接受 `K` 类型与 `Key` 类型作为参数，且 `Pred` 是透明的。这支持异构查找，从而避免实例化 `Key` 类型对象带来的性能开销。</class>
:1606
---
---
clear
清空
```c++ void clear() noexcept; ```
```c++ void clear() noexcept; ```
Erases all elements in the table.
清空表中的所有元素。
Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * bucket_count()` Concurrency:;; Blocking on `*this`.
后置条件：;; `size() == 0`，且 `max_load() &gt;= max_load_factor() * bucket_count()`
并发特性：;; 阻塞当前容器 `*this`。
English Chinese (Simplified Han script) Actions
erase
擦除
```c++ size_type erase(const key_type& k); template<class K> size_type erase(const K& k); ```
```c++ size_type erase(const key_type&amp; k); template<class k=""> size_type erase(const K&amp; k); ```</class>
Erases the element with key equivalent to `k` if it exists.
若存在键与 `k` 等价的元素，则删除该元素。
Returns:;; The number of elements erased (0 or 1). 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.
返回值：;; 删除的元素数量（0 或 1）。
抛出异常：;; 仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。
注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员类型别名时，`template<class k="">` 重载版本才参与重载决议。库假定 `Hash` 可同时接受 `K` 类型与 `Key` 类型作为参数，且 `Pred` 是透明的。这支持异构查找，从而避免实例化 `Key` 类型对象带来的性能开销。</class>
erase_if by Key
erase_if by Key
```c++ template<class F> size_type erase_if(const key_type& k, F f); template<class K, class F> size_type erase_if(const K& k, F f); ```
```c++ template<class f=""> size_type erase_if(const key_type&amp; k, F f); template<class k,="" class="" f=""> size_type erase_if(const K&amp; k, F f); ```</class></class>
Erases the element `x` with key equivalent to `k` if it exists and `f(x)` is `true`.
若存在键与 `k` 等价的元素 `x`，且 `f(x)` 返回 `true`，则删除该元素。
Successively invokes `f` with non-const references to each of the elements in the table, and erases those for which `f` returns `true`.
依次以非常量引用为参数，对表中的每个元素调用 `f`，并删除所有 `f` 返回 `true` 的元素。
Returns:;; The number of elements erased. Throws:;; Only throws an exception if it is thrown by `f`.
返回值：;; 删除的元素总数。
抛出异常：;; 仅当 `f` 抛出异常时才会抛出。
Parallel erase_if
并行条件擦除
```c++ template<class ExecutionPolicy, class F> void erase_if(ExecutionPolicy&& policy, F f); ```
```c++ template<class executionpolicy,="" class="" f=""> void erase_if(ExecutionPolicy&amp;&amp; policy, F f); ```</class>
Invokes `f` with non-const references to each of the elements in the table, and erases those for which `f` returns `true`. Execution is parallelized according to the semantics of the execution policy specified.
根据指定执行策略的语义并行执行操作：依次以**非常量引用**为参数对表中的每个元素调用 `f`，并删除所有 `f` 返回 `true` 的元素。
```c++ void swap(concurrent_node_map& other) noexcept(boost::allocator_traits<Allocator>::is_always_equal::value || boost::allocator_traits<Allocator>::propagate_on_container_swap::value); ```
```c++ void swap(concurrent_node_map&amp; other) noexcept(boost::allocator_traits<allocator>::is_always_equal::value || boost::allocator_traits<allocator>::propagate_on_container_swap::value); ```</allocator></allocator>
Swaps the contents of the table with the parameter.
将当前表与参数表的内容进行交换。
If `Allocator::propagate_on_container_swap` is declared and `Allocator::propagate_on_container_swap::value` is `true` then the tables' allocators are swapped. Otherwise, swapping with unequal allocators results in undefined behavior.
若声明了 `Allocator::propagate_on_container_swap` 且其值为 `true`，则交换两个表的分配器；否则，使用不相等的分配器进行交换会导致未定义行为。
Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
抛出异常：;; 除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。
并发特性：;; 阻塞当前容器 `*this` 与目标容器 `other`。
extract
extract
```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>
Extracts the element with key equivalent to `k`, if it exists.
若存在键与 `k` 等价的元素，则提取该元素。
```c++ template<class H2, class P2> size_type merge(concurrent_node_map<Key, T, H2, P2, Allocator>& source); template<class H2, class P2> size_type merge(concurrent_node_map<Key, T, H2, P2, Allocator>&& source); ```
```c++ template<class h2,="" class="" p2=""> size_type merge(concurrent_node_map<key, t,="" h2,="" p2,="" allocator="">&amp; source); template<class h2,="" class="" p2=""> size_type merge(concurrent_node_map<key, t,="" h2,="" p2,="" allocator="">&amp;&amp; source); ```</key,></class></key,></class>
Move-inserts all the elements from `source` whose key is not already present in `*this`, and erases them from `source`.
将源容器 `source` 中所有**键不存在于当前容器 `*this`** 中的元素**移动插入**到当前容器，并从 `source` 中删除这些元素。
Returns:;; The number of elements inserted. Concurrency:;; Blocking on `*this` and `source`.
返回值：;; 插入的元素数量。
并发特性：;; 阻塞当前容器 `*this` 与源容器 `source`。
Observers
观察器
get_allocator
get++_++allocator
``` allocator_type get_allocator() const noexcept; ```
``` allocator_type get_allocator() const noexcept; ```
Returns:;; The table's allocator.
返回值：;; 表的分配器。
hash_function
哈希函数
``` hasher hash_function() const; ```
``` hasher hash_function() const; ```
Returns:;; The table's hash function.
返回值：;; 表的哈希函数。
``` key_equal key_eq() const; ```
``` key_equal key_eq() const; ```

Loading…

User avatar admin

Translation uploaded
Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
Throws:;; Nothing unless抛出异常：;; 除非 `key_equal` or或 `hasher` throw on swapping. Concurrency:;; Blocking on在交换时抛出异常，否则不抛出任何异常。
并发特性：;; 阻塞当前容器 `*this` and与目标容器 `other`.。
06/05/2026
User avatar admin

String added in the repository
Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
06/05/2026
Browse all string changes

Things to check

Mismatching line breaks

Number of new lines in translation does not match source.

Reset

Glossary

English Chinese (Simplified Han script)
No related strings found in the glossary.

String information

Flags
safe-html, strict-same
Unit identifier
52131
Source string location
:1573
String age
06/05/2026
Last updated
06/06/2026
Source string age
06/05/2026
Translation file AsciiDoc file
doc/modules/ROOT/pages/reference/concurrent_node_map_zh_Hans.adoc, string 379