Zen

Translation

Notes:;; In the presence of concurrent insertion operations, the value returned may not accurately reflect the true size of the table right after execution.
43/1560 · 156

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
Returns:;; `false` iff `f` ever returns `false`.
返回值：;; 当且仅当 `f` 返回过 `false` 时，返回 `false`。
:820
---
---
Parallel [c]visit_while
并行 ++[++c++]++visit++_++while
```c++ template<class ExecutionPolicy, class F> bool visit_while(ExecutionPolicy&& policy, F f); template<class ExecutionPolicy, class F> bool visit_while(ExecutionPolicy&& policy, F f) const; template<class ExecutionPolicy, class F> bool cvisit_while(ExecutionPolicy&& policy, F f) const; ```
```c++ template<class executionpolicy,="" class="" f=""> bool visit_while(ExecutionPolicy&amp;&amp; policy, F f); template<class executionpolicy,="" class="" f=""> bool visit_while(ExecutionPolicy&amp;&amp; policy, F f) const; template<class executionpolicy,="" class="" f=""> bool cvisit_while(ExecutionPolicy&amp;&amp; policy, F f) const; ```</class></class></class>
Invokes `f` with const references to each of the elements in the table until `f` returns `false` or all the elements are visited. Execution is parallelized according to the semantics of the execution policy specified.
以指向哈希表中每个元素的常量引用调用函数 `f`，直到 `f` 返回 `false` 或遍历完所有元素。执行过程会根据指定执行策略的语义进行并行化。
Returns:;; `false` iff `f` ever returns `false`. 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. + + These overloads only participate in overload resolution if `std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is `true`. + + Unsequenced execution policies are not allowed. + + Parallelization implies that execution does not necessary finish as soon as `f` returns `false`, and as a result `f` may be invoked with further elements for which the return value is also `false`.
返回值：;; 当且仅当 `f` 返回过 `false` 时，返回 `false`。
抛出异常：;; 根据所使用执行策略的异常处理机制，若 `f` 内部抛出异常，则可能调用 `std::terminate`。
注意：;; 仅在支持 C++17 并行算法的编译器中可用。
仅当 `std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt;` 为 `true` 时，这些重载版本才会参与重载决议。
不允许使用无序执行策略。
并行化意味着执行流程不会在 `f` 返回 `false` 时立即终止，因此 `f` 可能还会被后续元素调用并同样返回 `false`。</std::remove_cvref_t<executionpolicy>
:846
---
---
Size and Capacity
大小与容量
empty
空
```c++ [[nodiscard]] bool empty() const noexcept; ```
```c++ [[nodiscard]] bool empty() const noexcept; ```
Returns:;; `size() == 0`
返回值：;; `size() == 0`
:859
---
---
size
大小
```c++ size_type size() const noexcept; ```
```c++ size_type size() const noexcept; ```
Returns:;; The number of elements in the table.
返回值：;; 哈希表中的元素总数。
Notes:;; In the presence of concurrent insertion operations, the value returned may not accurately reflect the true size of the table right after execution.
注意：;; 在存在并发插入操作时，返回的值可能无法准确反映函数执行后哈希表的真实大小。
:874
---
---
max_size
max_size
```c++ size_type max_size() const noexcept; ```
```c++ size_type max_size() const noexcept; ```
Returns:;; `size()` of the largest possible table.
返回值：;; 哈希表能容纳的最大元素数量（最大容量）。
:885
---
---
Modifiers
修改器
emplace
原地构造
```c++ template<class... Args> bool emplace(Args&&... args); ```
```c++ template<class... args=""> bool emplace(Args&amp;&amp;... args); ```</class...>
Inserts an object, constructed with the arguments `args`, in the table if and only if there is no element in the table with an equivalent key.
当且仅当哈希表中不存在等价键的元素时，才会使用参数 `args` 构造对象并插入到哈希表中。
Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued.
前置要求：;; `value_type` 可由参数 `args` 构造。
返回值：;; 成功插入元素时返回 `true`。
并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。
注意：;; 若执行重哈希，将使指向元素的指针和引用失效。
:902
---
---
Copy Insert
复制插入
```c++ bool insert(const value_type& obj); ```
```c++ bool insert(const value_type&amp; obj); ```
:909
Inserts `obj` in the table if and only if there is no element in the table with an equivalent key.
当且仅当哈希表中不存在等价键的元素时，才将 `obj` 插入到哈希表中。
:912
Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^]. Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued.
前置要求：;; `value_type` 满足可复制插入要求。
返回值：;; 成功插入元素时返回 `true`。
并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。
注意：;; 若执行重哈希，将使指向元素的指针和引用失效。
English Chinese (Simplified Han script) Actions
rehash
重哈希
```c++ void rehash(size_type n); ```
```c++ void rehash(size_type n); ```
Throws:;; The function has no effect if an exception is thrown, unless it is thrown by the table's hash function or comparison function. Concurrency:;; Blocking on `*this`. ---
抛出：;; 若抛出异常，函数无任何效果（哈希函数或比较函数抛出的异常除外）。
并发：;; 阻塞`*this`。
---
```c++ void reserve(size_type n); ```
```c++ void reserve(size_type n); ```
Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`.
等价于 `a.rehash(ceil(n / a.max_load_factor()))`。
Statistics
统计信息
get_stats
get_stats
```c++ stats get_stats() const; ```
```c++ stats get_stats() const; ```
Returns:;; A statistical description of the insertion and lookup operations performed by the table so far. Notes:;; Only available if xref:reference/stats.adoc#stats[statistics calculation] is xref:concurrent_flat_set_boost_unordered_enable_stats[enabled].
返回值：;; 该哈希表迄今为止执行的插入与查找操作的统计信息。
备注：;; 仅当 xref:reference/stats.adoc#stats[统计计算] 被 xref:concurrent_flat_set_boost_unordered_enable_stats[启用] 时，本接口方可使用。
```c++ template<class K, class H, class P, class A, class Predicate> typename concurrent_flat_set<K, H, P, A>::size_type erase_if(concurrent_flat_set<K, H, P, A>& c, Predicate pred); ```
```c++ template<class k,="" class="" h,="" p,="" a,="" predicate=""> typename concurrent_flat_set<k, h,="" p,="" a="">::size_type erase_if(concurrent_flat_set<k, h,="" p,="" a="">&amp; c, Predicate pred); ```</k,></k,></class>
Serialization
序列化
Saving an concurrent_flat_set to an archive
将 concurrent++_++flat++_++set 保存到归档
Requires:;; `value_type` is serializable (XML serializable), and it supports Boost.Serialization `save_construct_data`/`load_construct_data` protocol (automatically suported by https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^] types). Concurrency:;; Blocking on `x`.
要求;; `value++_++type` 必须可序列化（支持 XML 序列化），且需要支持 Boost.Serialization 的 `save++_++construct++_++data` / `load++_++construct++_++data` 协议（该协议自动支持满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求的类型）。 并发性;; 阻塞于 `x` 。
`std::allocator_traits<Alloc>::deallocate`
`std::allocator_traits<alloc>::deallocate`</alloc>
Returns:;; The number of elements in the table.
返回值：;; 哈希表中的元素总数。
Notes:;; In the presence of concurrent insertion operations, the value returned may not accurately reflect the true size of the table right after execution.
注意：;; 在存在并发插入操作时，返回的值可能无法准确反映函数执行后哈希表的真实大小。
max_size
max_size
```c++ concurrent_flat_set(std::initializer_list<value_type> il, const allocator_type& a); ```
```c++ concurrent_flat_set(std::initializer_list<value_type> il, const allocator_type&amp; a); ```</value_type>
The internal data structure of `boost::concurrent_flat_set` is similar to that of `boost::unordered_flat_set`. As a result of its using open-addressing techniques, `value_type` must be move-constructible and pointer stability is not kept under rehashing.
`boost::concurrent++_++flat++_++set` 的内部数据结构类似于 `boost::unordered++_++flat++_++set` 。由于其采用开放寻址技术， `value++_++type` 必须满足可移动构造要求，且在重哈希过程中无法保持指针稳定性。
*Template Parameters*
*模板参数*
and https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from the container.
https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入] 到容器中的要求，且需满足从容器中 https://en.cppreference.com/w/cpp/named_req/Erasable[可擦除] 的要求。
A unary function object type that acts a hash function for a `Key`. It takes a single argument of type `Key` and returns a value of type `std::size_t`.
一种为`Key`提供哈希功能的一元函数对象类型。它接受单个`Key`类型参数，并返回`std::size_t`类型的值。
A binary function object that induces an equivalence relation on values of type `Key`. It takes two arguments of type `Key` and returns a value of type `bool`.
一种二元函数对象，用于在Key类型的值上构建等价关系。它接受两个Key类型的参数，并返回一个bool类型的值。
An allocator whose value type is the same as the table's value type.
值类型与该表的值类型相同的分配器。
The size of the bucket array can be automatically increased by a call to `insert`/`emplace`, or as a result of calling `rehash`/`reserve`. The _load factor_ of the table (number of elements divided by number of buckets) is never greater than `max_load_factor()`, except possibly for small sizes where the implementation may decide to allow for higher loads.
调用 `insert`/`emplace` 或执行 `rehash`/`reserve` 操作时，桶数组的大小会自动扩容。容器的负载因子（元素数量除以桶数量）永远不会超过 `max_load_factor()`，仅在尺寸较小时，实现可能允许更高的负载因子。
If `link:../../../../../container_hash/doc/html/hash.html#ref_hash_is_avalanchinghash[hash_is_avalanching]<Hash>::value` is `true`, the hash function is used as-is; otherwise, a bit-mixing post-processing stage is added to increase the quality of hashing at the expense of extra computational cost.
若 `link:../../../../../container_hash/doc/html/hash.html#ref_hash_is_avalanchinghash[hash_is_avalanching]<hash>::value` 为 `true`，则哈希函数直接使用；否则会添加一个位混合后处理阶段，以额外的计算开销为代价提升哈希质量。</hash>
Concurrency Requirements and Guarantees
并发要求与保证
Constructs an empty table with at least `n` buckets, using `hf` as the hash function, `eql` as the key equality predicate and `a` as the allocator, and inserts the elements from `[f, l)` into it.
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等性谓词、 `a` 作为分配器，并将 `++[++f, l)` 范围内的元素插入其中。
Concurrent invocations of `operator()` on the same const instance of `Hash` or `Pred` are required to not introduce data races. For `Alloc` being either `Allocator` or any allocator type rebound from `Allocator`, concurrent invocations of the following operations on the same instance `al` of `Alloc` are required to not introduce data races:
要求对同一 `Hash` 或 `Pred` 常量实例并发调用 `operator()` 时不得引入数据竞争。对于 `Alloc` （即 `Allocator` 或其重绑定后的任意分配器类型），在同一实例 `al` 上并发调用以下操作时不得引入数据竞争：
Copy construction from `al` of an allocator rebound from `Alloc`
通过从`Alloc`重新绑定的分配器以`al`进行拷贝构造

Loading…

User avatar admin

Translation uploaded
Notes:;; In the presence of concurrent insertion operations, the value returned may not accurately reflect the true size of the table right after execution.
Notes:;; In the presence of concurrent insertion operations, the value returned may not accurately reflect the true size of the table right after execution.注意：;; 在存在并发插入操作时，返回的值可能无法准确反映函数执行后哈希表的真实大小。
06/05/2026
User avatar admin

String added in the repository
Notes:;; In the presence of concurrent insertion operations, the value returned may not accurately reflect the true size of the table right after execution.
Notes:;; In the presence of concurrent insertion operations, the value returned may not accurately reflect the true size of the table right after execution.
06/05/2026
Browse all string changes

Glossary

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

String information

Flags
safe-html, strict-same
Unit identifier
50343
Source string location
:871
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_flat_set_zh_Hans.adoc, string 200