Zen

Translation

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.
59/1480 · 148

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
:411
---
---
A specialization of an internal class template:
内部类模板的特化：
with `NodeType` = `node_type`.
其中 `NodeType` = `node++_++type` 。
:432
---
---
Constants
常量
```cpp static constexpr size_type bulk_visit_size; ```
```cpp static constexpr size_type bulk_visit_size; ```
Chunk size internally used in xref:concurrent_node_set_bulk_visit[bulk visit] operations.
xref:concurrent_node_set_bulk_visit[批量遍历]操作内部使用的块大小。
Constructors
构造函数
Default Constructor
默认构造函数
```c++ concurrent_node_set(); ```
```c++ concurrent_node_set(); ```
Constructs an empty table using `hasher()` as the hash function, `key_equal()` as the key equality predicate and `allocator_type()` as the allocator.
构造一个空表，使用 `hasher()` 作为哈希函数，`key_equal()` 作为键相等性谓词，`allocator_type()` 作为分配器。
:453
Postconditions:;; `size() == 0` Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
后置条件：;; `size() == 0`
要求：;; 若使用默认参数，`hasher`、`key_equal` 和 `allocator_type` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^]。
:456
---
---
Bucket Count Constructor
桶数构造函数
```c++ explicit concurrent_node_set(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); ```
```c++ explicit concurrent_node_set(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); ```
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.
构造一个包含至少 `n` 个桶的空表，使用 `hf` 作为哈希函数，`eql` 作为键相等性谓词，`a` 作为分配器。
:470
Postconditions:;; `size() == 0` Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
后置条件：;; `size() == 0`
要求：;; 若使用默认参数，`hasher`、`key_equal` 和 `allocator_type` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^]。
:473
---
---
Iterator Range Constructor
迭代器范围构造函数
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)` 范围内的元素插入其中。
:489
Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
要求;; 若使用默认值，则 `hasher` 、 `key++_++equal` 和 `allocator++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。
:491
---
---
Copy Constructor
复制构造函数
```c++ concurrent_node_set(concurrent_node_set const& other); ```
```c++ concurrent_node_set(concurrent_node_set const& other); ```
The copy constructor. Copies the contained elements, hash function, predicate and allocator.
复制构造函数。复制容器内的元素、哈希函数、谓词以及分配器。
If `Allocator::select_on_container_copy_construction` exists and has the right signature, the allocator will be constructed from its result.
若 `Allocator::select_on_container_copy_construction` 存在且签名正确，则分配器将由其返回值构造。
Requires:;; `value_type` is copy constructible Concurrency:;; Blocking on `other`.
要求：;; `value_type` 是可复制构造的
并发特性：;; 阻塞 `other`
:506
---
---
Move Constructor
移动构造函数
```c++ concurrent_node_set(concurrent_node_set&& other); ```
```c++ concurrent_node_set(concurrent_node_set&& other); ```
The move constructor. The internal bucket array of `other` is transferred directly to the new table. The hash function, predicate and allocator are moved-constructed from `other`. If statistics are xref:concurrent_node_set_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` and calls `other.reset_stats()`.
移动构造函数。`other` 的内部桶数组会直接转移到新容器中。哈希函数、谓词和分配器均从 `other` 移动构造而来。若启用了统计功能，会从 `other` 转移内部统计信息，并调用 `other.reset_stats()`。
English Chinese (Simplified Han script) Actions
[c]visit
[c]visit
```c++ size_type bucket_count() const noexcept; ```
```c++ size_type bucket_count() const noexcept; ```
[#concurrent_node_set]
[#concurrent_node_set]
reset_stats
reset_stats
```c++ void reset_stats() noexcept; ```
```c++ void reset_stats() noexcept; ```
Saves all the elements of a `concurrent_node_set` `x` to an archive (XML archive) `ar`.
将 `concurrent++_++node++_++set` `x` 的所有元素保存至归档（XML 归档） `ar` 。
Swap
交换
Synopsis
概要
`Key` must be https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^] into the container
`Key` 必须满足可移动插入要求，即能够被
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类型的值。
`std::allocator_traits<Allocator>::pointer` and `std::allocator_traits<Allocator>::const_pointer` must be convertible to/from `value_type*` and `const value_type*`, respectively.
`std::allocator_traits<allocator>::pointer` 与 `std::allocator_traits<allocator>::const_pointer` 必须分别可与 `value_type*` 和 `const value_type*` 相互转换。</allocator></allocator>
Read access to the element.
对元素的读取访问。
Configuration Macros
配置宏
A class for holding extracted table elements, modelling https://en.cppreference.com/w/cpp/container/node_handle[NodeHandle].
用于保存提取的表元素的类，建模为 https://en.cppreference.com/w/cpp/container/node_handle[NodeHandle] 。
Constants
常量
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.
构造一个包含至少 `n` 个桶的空表，使用 `hf` 作为哈希函数，`eql` 作为键相等性谓词，`a` 作为分配器。
The copy constructor. Copies the contained elements, hash function, predicate and allocator.
复制构造函数。复制容器内的元素、哈希函数、谓词以及分配器。
Requires:;; `value_type` is copy constructible Concurrency:;; Blocking on `other`.
要求：;; `value_type` 是可复制构造的
并发特性：;; 阻塞 `other`
Allocator Constructor
分配器构造函数
Constructs an empty table, using allocator `a`.
构造一个空容器，使用分配器 `a`。
Complexity:;; O(`bucket_count()`)
复杂度：;; O(`bucket_count()`)
Destructor
析构函数
```c++ concurrent_node_set& operator=(std::initializer_list<value_type> il); ```
```c++ concurrent_node_set&amp; operator=(std::initializer_list<value_type> il); ```</value_type>
Visitation
访问操作
If an element `x` exists with key equivalent to `k`, invokes `f` with a const reference to `x`.
若存在键与 `k` 等价的元素 `x`，则使用指向 `x` 的常量引用调用 `f`。
Returns:;; The number of elements visited.
返回值：;; 被访问的元素数量。
```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>
size
大小
```c++ size_type size() const noexcept; ```
```c++ size_type size() const noexcept; ```
```c++ bool insert(value_type&& obj); ```
```c++ bool insert(value_type&amp;&amp; obj); ```

Loading…

User avatar admin

Translation uploaded
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.
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.构造一个包含至少 `n` 个桶的空表，使用 `hf` 作为哈希函数，`eql` 作为键相等性谓词，`a` 作为分配器。
06/05/2026
User avatar admin

String added in the repository
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.
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.
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
53271
Source string location
:466
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 68