Zen

Translation

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

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
:1334
---
---
:1336
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 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` 抛出异常时才会抛出异常。
:1347
---
---
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 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>
:1365
---
---
swap
交换
```c++ void swap(concurrent_node_set& other) noexcept(boost::allocator_traits<Allocator>::is_always_equal::value || boost::allocator_traits<Allocator>::propagate_on_container_swap::value); ```
```c++ void swap(concurrent_node_set&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` 已声明且 `Allocator::propagate_on_container_swap::value` 为 `true`，则交换两个表的分配器。否则，使用不相等的分配器进行交换会导致未定义行为。
Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
异常：;; 除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。
并发：;; 阻塞 `*this` 和 `other`。
:1382
---
---
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>
:1397
---
---
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>
:1412
---
---
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
If `nh` is empty, does nothing. Otherwise, inserts the associated element in the table if and only if there is no element in the table with a key equivalent to `nh.value()`. Otherwise, invokes `f` with a const reference to the equivalent element.
若 `nh` 为空，则不执行任何操作。否则，当且仅当哈希表中不存在与 `nh.value()` 键等价的元素时，将其关联元素插入表中；否则，以该等价元素的常量引用为参数调用函数 `f`。
Throws:;; If an exception is thrown by an operation other than a call to `hasher` or call to `f`, the function has no effect. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Behavior is undefined if `nh` is not empty and the allocators of `nh` and the container are not equal.
若 `nh` 为空，则不执行任何操作；否则，当且仅当容器中不存在与 `nh.value()` 等效的键时，插入其关联的元素；否则，使用指向等效元素的常量引用调用 `f` 。
emplace_and_[c]visit
emplace_and_[c]visit
Inserts an object, constructed with the arguments `args`, in the table if there is no element in the table with an equivalent key, and then invokes `f1` with a const reference to the newly created element. Otherwise, invokes `f2` with a const reference to the equivalent element.
若哈希表中不存在键等价的元素，则使用参数 `args` 构造对象并插入表中，随后以新建元素的常量引用为参数调用函数 `f1`；否则，以该等价元素的常量引用为参数调用函数 `f2`。
Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; The interface is exposition only, as C++ does not allow to declare parameters `f1` and `f2` after a variadic parameter pack.
要求：;; `value_type` 可由 `args` 构造。
返回值：;; 若成功插入元素则返回 `true`。
并发特性：;; 会阻塞当前对象的重哈希操作。
注意：;; 该接口仅为说明性用法，因为 C++ 不允许在可变参数包之后声明 `f1` 和 `f2` 参数。
Copy insert_and_[c]visit
复制 insert++_++and++_[++c++]++visit
```c++ template<class F1, class F2> bool insert_and_visit(const value_type& obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit(const value_type& obj, F1 f2, F2 f2); ```
```c++ template<class f1,="" class="" f2=""> bool insert_and_visit(const value_type&amp; obj, F1 f1, F2 f2); template<class f1,="" class="" f2=""> bool insert_and_cvisit(const value_type&amp; obj, F1 f2, F2 f2); ```</class></class>
Move insert_and_[c]visit
移动 insert++_++and++_[++c++]++visit
```c++ template<class F1, class F2> bool insert_and_visit(value_type&& obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit(value_type&& obj, F1 f1, F2 f2); ```
```c++ template<class f1,="" class="" f2=""> bool insert_and_visit(value_type&amp;&amp; obj, F1 f1, F2 f2); template<class f1,="" class="" f2=""> bool insert_and_cvisit(value_type&amp;&amp; obj, F1 f1, F2 f2); ```</class></class>
Insert Node and Visit
节点插入并访问
erase
擦除
Returns:;; The number of elements erased. Throws:;; Only throws an exception if it is thrown by `f`.
返回值：;; 删除的元素数量。
异常：;; 仅当 `f` 抛出异常时才会抛出异常。
Parallel erase_if
并行条件擦除
Iterator Range Constructor with Bucket Count and Hasher
带桶数和哈希函数的迭代器范围构造函数
Invokes `f` with 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:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
异常：;; 除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。
并发：;; 阻塞 `*this` 和 `other`。
```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`，则提取该元素。
```c++ template<class H2, class P2> size_type merge(concurrent_node_set<Key, H2, P2, Allocator>& source); template<class H2, class P2> size_type merge(concurrent_node_set<Key, H2, P2, Allocator>&& source); ```
```c++ template<class h2,="" class="" p2=""> size_type merge(concurrent_node_set<key, h2,="" p2,="" allocator="">&amp; source); template<class h2,="" class="" p2=""> size_type merge(concurrent_node_set<key, h2,="" p2,="" allocator="">&amp;&amp; source); ```</key,></class></key,></class>
Observers
观察器
get_allocator
get_allocator
Returns:;; The table's key equality predicate.
返回值：;; 表的键相等性断言。
Bucket Interface
桶接口
bucket_count
bucket_count
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>
Set max_load_factor
设置最大负载因子
```c++ void max_load_factor(float z); ```
```c++ void max_load_factor(float z); ```
Effects:;; Does nothing, as the user is not allowed to change this parameter. Kept for compatibility with `boost::unordered_set`.
效果：;; 不执行任何操作，因为不允许用户修改此参数。保留该函数是为了与 `boost::unordered_set` 保持兼容。
When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array.
效果：;; 当 `size() == 0` 时，调用 `rehash(0)` 会释放底层桶数组的内存。
A deduction guide will not participate in overload resolution if any of the following are true:
如果以下任何一条件为真，则推导指引将不参与重载决议：

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
53557
Source string location
:1379
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_set_zh_Hans.adoc, string 354