Zen

Translation

Successively invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const.
56/1260 · 126

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
:766
---
---
Visitation
访问操作
[c]visit
[c]visit
```c++ template<class F> size_t visit(const key_type& k, F f); template<class F> size_t visit(const key_type& k, F f) const; template<class F> size_t cvisit(const key_type& k, F f) const; template<class K, class F> size_t visit(const K& k, F f); template<class K, class F> size_t visit(const K& k, F f) const; template<class K, class F> size_t cvisit(const K& k, F f) const; ```
```c++ template<class f=""> size_t visit(const key_type&amp; k, F f); template<class f=""> size_t visit(const key_type&amp; k, F f) const; template<class f=""> size_t cvisit(const key_type&amp; k, F f) const; template<class k,="" class="" f=""> size_t visit(const K&amp; k, F f); template<class k,="" class="" f=""> size_t visit(const K&amp; k, F f) const; template<class k,="" class="" f=""> size_t cvisit(const K&amp; k, F f) const; ```</class></class></class></class></class></class>
If an element `x` exists with key equivalent to `k`, invokes `f` with a reference to `x`. Such reference is const iff `*this` is const.
若存在键与 k 等价的元素 x，则以 x 的引用调用函数 f。
当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。
Returns:;; The number of elements visited (0 or 1). Notes:;; The `template<class K, class F>` 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.
返回值：访问过的元素数量（0 或 1）。
注意：template<class k,="" class="" f=""> 形式的重载仅在 Hash::is_transparent 与 Pred::is_transparent 为合法成员别名时才参与重载决议。
库假定 Hash 可同时用于 K 类型与 Key 类型，且 Pred 是透明的。
这支持异构查找，避免了实例化 Key 类型对象带来的开销。</class>
:788
---
---
Bulk visit
批量访问
```c++ template<class FwdIterator, class F> size_t visit(FwdIterator first, FwdIterator last, F f); template<class FwdIterator, class F> size_t visit(FwdIterator first, FwdIterator last, F f) const; template<class FwdIterator, class F> size_t cvisit(FwdIterator first, FwdIterator last, F f) const; ```
```c++ template<class fwditerator,="" class="" f=""> size_t visit(FwdIterator first, FwdIterator last, F f); template<class fwditerator,="" class="" f=""> size_t visit(FwdIterator first, FwdIterator last, F f) const; template<class fwditerator,="" class="" f=""> size_t cvisit(FwdIterator first, FwdIterator last, F f) const; ```</class></class></class>
For each element `k` in the range [`first`, `last`), if there is an element `x` in the container with key equivalent to `k`, invokes `f` with a reference to `x`. Such reference is const iff `*this` is const.
对范围 [first, last) 中的每个键 k：
如果容器中存在键与 k 等价的元素 x，则以 x 的引用调用函数 f。
当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。
Although functionally equivalent to individually invoking xref:concurrent_flat_map_cvisit[`[c\]visit`] for each key, bulk visitation performs generally faster due to internal streamlining optimizations. It is advisable that `std::distance(first,last)` be at least xref:#concurrent_flat_map_constants[`bulk_visit_size`] to enjoy a performance gain: beyond this size, performance is not expected to increase further.
尽管功能上等价于对每个键单独调用 [c]visit，但批量访问因内部流线型优化，通常性能更高。
建议 std::distance(first,last) 至少达到 bulk_visit_size 阈值时再使用，以获得性能提升；超过该大小后，性能不会进一步提升。
Requires:;; `FwdIterator` is a https://en.cppreference.com/w/cpp/named_req/ForwardIterator[LegacyForwardIterator^] ({cpp}11 to {cpp}17), or satisfies https://en.cppreference.com/w/cpp/iterator/forward_iterator[std::forward_iterator^] ({cpp}20 and later). For `K` = `std::iterator_traits<FwdIterator>::value_type`, either `K` is `key_type` or else `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. In the latter case, 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. Returns:;; The number of elements visited.
要求：`FwdIterator` 需满足 https://en.cppreference.com/w/cpp/named_req/ForwardIterator[遗留向前迭代器^] 要求（{cpp}11 至 {cpp}17），或满足 https://en.cppreference.com/w/cpp/iterator/forward_iterator[`std::forward_iterator`^] 要求（{cpp}20 及更高版本）。对于 `K = std::iterator_traits<fwditerator>::value_type`，要么 `K` 是 `key_type`，要么 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef。在后一种情况下，库假定 `Hash` 可同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。该机制支持异构查找，从而避免实例化 `Key` 类型的开销。返回：被访问的元素数量。</fwditerator>
:824
---
---
[c]visit_all
[c]visit_all
```c++ template<class F> size_t visit_all(F f); template<class F> size_t visit_all(F f) const; template<class F> size_t cvisit_all(F f) const; ```
```c++ template<class f=""> size_t visit_all(F f); template<class f=""> size_t visit_all(F f) const; template<class f=""> size_t cvisit_all(F f) const; ```</class></class></class>
Successively invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const.
依次以表中每个元素的引用调用函数 f。
当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。
Returns:;; The number of elements visited.
返回值：访问到的元素数量。
:840
---
---
Parallel [c]visit_all
并行 [c]visit_all
```c++ template<class ExecutionPolicy, class F> void visit_all(ExecutionPolicy&& policy, F f); template<class ExecutionPolicy, class F> void visit_all(ExecutionPolicy&& policy, F f) const; template<class ExecutionPolicy, class F> void cvisit_all(ExecutionPolicy&& policy, F f) const; ```
```c++ template<class executionpolicy,="" class="" f=""> void visit_all(ExecutionPolicy&amp;&amp; policy, F f); template<class executionpolicy,="" class="" f=""> void visit_all(ExecutionPolicy&amp;&amp; policy, F f) const; template<class executionpolicy,="" class="" f=""> void cvisit_all(ExecutionPolicy&amp;&amp; policy, F f) const; ```</class></class></class>
Invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const. Execution is parallelized according to the semantics of the execution policy specified.
以表中每个元素的引用调用函数 f。
当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。
执行过程将根据指定的执行策略语义进行并行化。
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.
抛出异常：根据所使用执行策略的异常处理机制，如果 f 内部抛出异常，则可能会调用 std::terminate。
注意：仅在支持 C++17 并行算法的编译器中可用。
仅当 std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt; 为 true 时，这些重载版本才参与重载决议。
不允许使用无序执行策略。</std::remove_cvref_t<executionpolicy>
:861
---
---
[c]visit_while
[c]visit_while
```c++ template<class F> bool visit_while(F f); template<class F> bool visit_while(F f) const; template<class F> bool cvisit_while(F f) const; ```
```c++ template<class f=""> bool visit_while(F f); template<class f=""> bool visit_while(F f) const; template<class f=""> bool cvisit_while(F f) const; ```</class></class></class>
Successively invokes `f` with references to each of the elements in the table until `f` returns `false` or all the elements are visited. Such references to the elements are const iff `*this` is const.
依次以表中每个元素的引用调用函数 f，直到 f 返回 false 或遍历完所有元素。
当且仅当当前容器 *this 为常量（const）时，该元素引用为常量引用。
Returns:;; `false` iff `f` ever returns `false`.
返回值：当且仅当 f 曾返回 false 时，整体返回 false。
:878
---
---
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 references to each of the elements in the table until `f` returns `false` or all the elements are visited. Such references to the elements are const iff `*this` is const. Execution is parallelized according to the semantics of the execution policy specified.
以表中每个元素的引用调用函数 f，直到 f 返回 false 或遍历完所有元素。
当且仅当当前容器 *this 为常量（const）时，该元素引用为常量引用。
执行过程将根据指定的执行策略语义进行并行化。
English Chinese (Simplified Han script) Actions
emplace_or_[c]visit
emplace_or_[c]visit
```c++ concurrent_flat_map& operator=(std::initializer_list<value_type> il); ```
```c++ concurrent_flat_map&amp; operator=(std::initializer_list<value_type> il); ```</value_type>
Assign from values in initializer list. All previously existing elements are destroyed.
并发：阻塞于 *this 和 other。
从初始化列表赋值。销毁所有先前存在的元素。
Visitation
访问操作
[c]visit
[c]visit
```c++ template<class F> size_t visit(const key_type& k, F f); template<class F> size_t visit(const key_type& k, F f) const; template<class F> size_t cvisit(const key_type& k, F f) const; template<class K, class F> size_t visit(const K& k, F f); template<class K, class F> size_t visit(const K& k, F f) const; template<class K, class F> size_t cvisit(const K& k, F f) const; ```
```c++ template<class f=""> size_t visit(const key_type&amp; k, F f); template<class f=""> size_t visit(const key_type&amp; k, F f) const; template<class f=""> size_t cvisit(const key_type&amp; k, F f) const; template<class k,="" class="" f=""> size_t visit(const K&amp; k, F f); template<class k,="" class="" f=""> size_t visit(const K&amp; k, F f) const; template<class k,="" class="" f=""> size_t cvisit(const K&amp; k, F f) const; ```</class></class></class></class></class></class>
If an element `x` exists with key equivalent to `k`, invokes `f` with a reference to `x`. Such reference is const iff `*this` is const.
若存在键与 k 等价的元素 x，则以 x 的引用调用函数 f。
当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。
Returns:;; The number of elements visited (0 or 1). Notes:;; The `template<class K, class F>` 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.
返回值：访问过的元素数量（0 或 1）。
注意：template<class k,="" class="" f=""> 形式的重载仅在 Hash::is_transparent 与 Pred::is_transparent 为合法成员别名时才参与重载决议。
库假定 Hash 可同时用于 K 类型与 Key 类型，且 Pred 是透明的。
这支持异构查找，避免了实例化 Key 类型对象带来的开销。</class>
Bulk visit
批量访问
```c++ template<class FwdIterator, class F> size_t visit(FwdIterator first, FwdIterator last, F f); template<class FwdIterator, class F> size_t visit(FwdIterator first, FwdIterator last, F f) const; template<class FwdIterator, class F> size_t cvisit(FwdIterator first, FwdIterator last, F f) const; ```
```c++ template<class fwditerator,="" class="" f=""> size_t visit(FwdIterator first, FwdIterator last, F f); template<class fwditerator,="" class="" f=""> size_t visit(FwdIterator first, FwdIterator last, F f) const; template<class fwditerator,="" class="" f=""> size_t cvisit(FwdIterator first, FwdIterator last, F f) const; ```</class></class></class>
Requires:;; `FwdIterator` is a https://en.cppreference.com/w/cpp/named_req/ForwardIterator[LegacyForwardIterator^] ({cpp}11 to {cpp}17), or satisfies https://en.cppreference.com/w/cpp/iterator/forward_iterator[std::forward_iterator^] ({cpp}20 and later). For `K` = `std::iterator_traits<FwdIterator>::value_type`, either `K` is `key_type` or else `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. In the latter case, 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. Returns:;; The number of elements visited.
要求：`FwdIterator` 需满足 https://en.cppreference.com/w/cpp/named_req/ForwardIterator[遗留向前迭代器^] 要求（{cpp}11 至 {cpp}17），或满足 https://en.cppreference.com/w/cpp/iterator/forward_iterator[`std::forward_iterator`^] 要求（{cpp}20 及更高版本）。对于 `K = std::iterator_traits<fwditerator>::value_type`，要么 `K` 是 `key_type`，要么 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef。在后一种情况下，库假定 `Hash` 可同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。该机制支持异构查找，从而避免实例化 `Key` 类型的开销。返回：被访问的元素数量。</fwditerator>
```c++ template<class F> size_t visit_all(F f); template<class F> size_t visit_all(F f) const; template<class F> size_t cvisit_all(F f) const; ```
```c++ template<class f=""> size_t visit_all(F f); template<class f=""> size_t visit_all(F f) const; template<class f=""> size_t cvisit_all(F f) const; ```</class></class></class>
Successively invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const.
依次以表中每个元素的引用调用函数 f。
当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。
Returns:;; The number of elements visited.
返回值：访问到的元素数量。
Parallel [c]visit_all
并行 [c]visit_all
```c++ bool insert(const value_type& obj); bool insert(const init_type& obj); ```
```c++ bool insert(const value_type&amp; obj); bool insert(const init_type&amp; obj); ```
```c++ template<class ExecutionPolicy, class F> void visit_all(ExecutionPolicy&& policy, F f); template<class ExecutionPolicy, class F> void visit_all(ExecutionPolicy&& policy, F f) const; template<class ExecutionPolicy, class F> void cvisit_all(ExecutionPolicy&& policy, F f) const; ```
```c++ template<class executionpolicy,="" class="" f=""> void visit_all(ExecutionPolicy&amp;&amp; policy, F f); template<class executionpolicy,="" class="" f=""> void visit_all(ExecutionPolicy&amp;&amp; policy, F f) const; template<class executionpolicy,="" class="" f=""> void cvisit_all(ExecutionPolicy&amp;&amp; policy, F f) const; ```</class></class></class>
Invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const. Execution is parallelized according to the semantics of the execution policy specified.
以表中每个元素的引用调用函数 f。
当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。
执行过程将根据指定的执行策略语义进行并行化。
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.
抛出异常：根据所使用执行策略的异常处理机制，如果 f 内部抛出异常，则可能会调用 std::terminate。
注意：仅在支持 C++17 并行算法的编译器中可用。
仅当 std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt; 为 true 时，这些重载版本才参与重载决议。
不允许使用无序执行策略。</std::remove_cvref_t<executionpolicy>
[c]visit_while
[c]visit_while
Successively invokes `f` with references to each of the elements in the table until `f` returns `false` or all the elements are visited. Such references to the elements are const iff `*this` is const.
依次以表中每个元素的引用调用函数 f，直到 f 返回 false 或遍历完所有元素。
当且仅当当前容器 *this 为常量（const）时，该元素引用为常量引用。
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>
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>
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. + + A call of the form `insert(x)`, where `x` is equally convertible to both `const value_type&` and `const init_type&`, is not ambiguous and selects the `init_type` overload.
要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可复制插入^] 要求。返回：若执行了插入则返回 `true`。并发：在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用会失效。+ +形式为 `insert(x)` 的调用（其中 `x` 可同等转换为 `const value_type&amp;` 和 `const init_type&amp;`）不会产生歧义，并且会选择 `init_type` 重载。
Move Insert
移动插入
```c++ bool insert(value_type&& obj); bool insert(init_type&& obj); ```
```c++ bool insert(value_type&amp;&amp; obj); bool insert(init_type&amp;&amp; obj); ```
Deletes all preexisting elements of a `concurrent_flat_map` `x` and inserts from an archive (XML archive) `ar` restored copies of the elements of the original `concurrent_flat_map` `other` saved to the storage read by `ar`.
删除 `concurrent++_++flat++_++map` 容器 `x` 中所有已存在的元素，并从归档（XML 归档） `ar` 中插入原始 `concurrent++_++flat++_++map` 容器 `other` 的元素副本，这些副本是从 `ar` 所读取的存储中恢复的。

Loading…

User avatar admin

Translation uploaded
Successively invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const.
Successively invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const.依次以表中每个元素的引用调用函数 f。
当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。
06/05/2026
User avatar admin

String added in the repository
Successively invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const.
Successively invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const.
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
53871
Source string location
:834
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_map_zh_Hans.adoc, string 174