Zen

Translation

Constructs an empty table using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
53/1590 · 159

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
:439
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[可默认构造] 要求。
:441
---
---
Copy Constructor
复制构造函数
```c++ concurrent_flat_set(concurrent_flat_set const& other); ```
```c++ concurrent_flat_set(concurrent_flat_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`。
:456
---
---
Move Constructor
移动构造函数
```c++ concurrent_flat_set(concurrent_flat_set&& other); ```
```c++ concurrent_flat_set(concurrent_flat_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_flat_set_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` and calls `other.reset_stats()`.
移动构造函数。`other` 的内部桶数组将直接转移至新容器。哈希函数、谓词及分配器均从 `other` 移动构造。若统计功能已通过 xref:concurrent_flat_set_boost_unordered_enable_stats[启用]，则从 `other` 转移内部统计信息并调用 `other.reset_stats()`。
:469
Concurrency:;; Blocking on `other`.
并发说明：;; 对 `other` 产生阻塞
:471
---
---
Iterator Range Constructor with Allocator
带分配器的迭代器范围构造函数
```c++ template<class InputIterator> concurrent_flat_set(InputIterator f, InputIterator l, const allocator_type& a); ```
```c++ template<class inputiterator=""> concurrent_flat_set(InputIterator f, InputIterator l, const allocator_type&amp; a); ```</class>
Constructs an empty table using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
构造一个以`a`为分配器、使用默认哈希函数与键相等谓词的空容器，并将`[f, l)`范围内的元素插入其中。
:482
Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
要求：`hasher`、`key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。
:484
---
---
Allocator Constructor
分配器构造函数
```c++ explicit concurrent_flat_set(Allocator const& a); ```
```c++ explicit concurrent_flat_set(Allocator const&amp; a); ```
Constructs an empty table, using allocator `a`.
构造一个使用分配器`a`的空容器。
:493
---
---
Copy Constructor with Allocator
带分配器的复制构造函数
```c++ concurrent_flat_set(concurrent_flat_set const& other, Allocator const& a); ```
```c++ concurrent_flat_set(concurrent_flat_set const&amp; other, Allocator const&amp; a); ```
Constructs a table, copying ``other``'s contained elements, hash function, and predicate, but using allocator `a`.
构造一个容器，复制 `other` 中的元素、哈希函数和谓词，但使用分配器 `a`。
:503
Concurrency:;; Blocking on `other`.
并发说明：;; 对 `other` 产生阻塞
:505
---
---
Move Constructor with Allocator
带分配器的移动构造函数
```c++ concurrent_flat_set(concurrent_flat_set&& other, Allocator const& a); ```
```c++ concurrent_flat_set(concurrent_flat_set&amp;&amp; other, Allocator const&amp; a); ```
If `a == other.get_allocator()`, the elements of `other` are transferred directly to the new table; otherwise, elements are moved-constructed from those of `other`. The hash function and predicate are moved-constructed from `other`, and the allocator is copy-constructed from `a`. If statistics are xref:concurrent_flat_set_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` iff `a == other.get_allocator()`, and always calls `other.reset_stats()`.
若`a == other.get_allocator()`，则`other`的元素将直接转移至新容器；否则，元素从`other`的元素移动构造而来。哈希函数与谓词从`other`移动构造，分配器从`a`拷贝构造。若统计功能已通过 xref:concurrent_flat_set_boost_unordered_enable_stats[enabled]，仅当`a == other.get_allocator()`时从`other`转移内部统计信息，且始终调用`other.reset_stats()`。
:520
Concurrency:;; Blocking on `other`.
并发说明：;; 对 `other` 产生阻塞
English Chinese (Simplified Han script) Actions
A deduction guide will not participate in overload resolution if any of the following are true:
如果以下任何一条件为真，则推导指引将不参与重载决议：
A `size_­type` parameter type in a deduction guide refers to the `size_­type` member type of the container type deduced by the deduction guide. Its default value coincides with the default value of the constructor selected.
推导指引中的 `size++_++type` 参数类型，指向由该推导指引所推导容器类型的 `size++_++type` 成员类型。其默认值与所选构造函数的默认值一致。
Returns `true` if `x.size() == y.size()` and for every element in `x`, there is an element in `y` with the same key, with an equal value (using `operator==` to compare the value types).
若 x.size() == y.size()，且对于 x 中的每个元素，y 中均存在一个具有相同键、值相等（使用 operator== 比较值类型）的元素，则返回 true。
operator!
operator!
```c++ template<class Key, class Hash, class Pred, class Alloc> bool operator!=(const concurrent_flat_set<Key, Hash, Pred, Alloc>& x, const concurrent_flat_set<Key, Hash, Pred, Alloc>& y); ```
```c++ template<class key,="" class="" hash,="" pred,="" alloc=""> bool operator!=(const concurrent_flat_set<key, hash,="" pred,="" alloc="">&amp; x, const concurrent_flat_set<key, hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>
Swap
交换
```cpp static constexpr size_type bulk_visit_size; ```
```cpp static constexpr size_type bulk_visit_size; ```
Chunk size internally used in xref:concurrent_flat_set_bulk_visit[bulk visit] operations.
xref:concurrent_flat_set_bulk_visit[批量访问]操作内部使用的块大小。
Constructors
构造函数
Default Constructor
默认构造函数
```c++ concurrent_flat_set(); ```
```c++ concurrent_flat_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()`作为分配器。
Bucket Count Constructor
桶数构造函数
```c++ explicit concurrent_flat_set(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); ```
```c++ explicit concurrent_flat_set(size_type n, const hasher&amp; hf = hasher(), const key_equal&amp; eql = key_equal(), const allocator_type&amp; 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`作为分配器。
Constructs an empty table using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
构造一个以`a`为分配器、使用默认哈希函数与键相等谓词的空容器，并将`[f, l)`范围内的元素插入其中。
Iterator Range Constructor
迭代器范围构造函数
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 const reference to `x`.
对范围 `[first, last)` 中的每个元素 `k`，若容器中存在键与 `k` 等价的元素 `x`，则以指向 `x` 的常量引用调用函数 `f`。
```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`。
注意：;; 若执行重哈希，将使指向元素的指针和引用失效。
Copy Insert
复制插入
```c++ bool insert(const value_type& obj); ```
```c++ bool insert(const value_type&amp; obj); ```
[c]visit
[c]visit
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.
返回值：;; 访问到的元素总数。
Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]. 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`。
注意：;; 若执行重哈希，将使指向元素的指针和引用失效。
``` key_equal key_eq() const; ```
``` key_equal key_eq() const; ```
Returns:;; The table's key equality predicate.
返回值：;; 表的键相等性断言。
Set Operations
集合操作

Loading…

User avatar admin

Translation uploaded
Constructs an empty table using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
Constructs an empty table using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.构造一个以`a`为分配器、使用默认哈希函数与键相等谓词的空容器，并将`[f, l)`范围内的元素插入其中。
06/05/2026
User avatar admin

String added in the repository
Constructs an empty table using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
Constructs an empty table using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
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
50225
Source string location
:479
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 82