en	﻿[#concurrent_node_set]
zh-hans	[#concurrent_node_set]

en	Class Template concurrent_node_set
zh-hans	类模板 concurrent++_++node++_++set

en	:idprefix: concurrent_node_set_

en	`boost::concurrent_node_set` — A node-based hash table that stores unique values and allows for concurrent element insertion, erasure, lookup and access without external synchronization mechanisms.
zh-hans	`boost::concurrent++_++node++_++set` —— 一种基于节点的哈希表，用于存储唯一值，并允许在无外部同步机制的情况下并发执行元素插入、擦除、查找和访问操作。

en	Even though it acts as a container, `boost::concurrent_node_set` does not model the standard C++ https://en.cppreference.com/w/cpp/named_req/Container[Container^] concept. In particular, iterators and associated operations (`begin`, `end`, etc.) are not provided. Element access is done through user-provided _visitation functions_ that are passed to `concurrent_node_set` operations where they are executed internally in a controlled fashion. Such visitation-based API allows for low-contention concurrent usage scenarios.
zh-hans	尽管 `boost::concurrent++_++node++_++set` 的行为类似于容器，但它并不符合标准 C{plus}{plus} https://en.cppreference.com/w/cpp/named_req/Container[容器] 概念。具体而言，它不提供迭代器及相关操作（如 `begin` 、 `end` 等）。元素的访问通过用户提供的 _访问函数_ 实现，这些函数被传递至 `concurrent++_++node++_++set` 的内部操作，并以受控方式执行。这种基于访问的 API 设计支持低竞争度的并发使用场景。

en	The internal data structure of `boost::concurrent_node_set` is similar to that of `boost::unordered_node_set`. Unlike `boost::concurrent_flat_set`, pointer stability and node handling functionalities are provided, at the expense of potentially lower performance.
zh-hans	`boost::concurrent++_++node++_++set` 的内部数据结构与 `boost::unordered++_++node++_++set` 类似。与 `boost::concurrent++_++flat++_++set` 不同，它提供了指针稳定性和节点处理功能，但可能以性能降低为代价。

en	Synopsis
zh-hans	概要

en	---

en	Description
zh-hans	描述

en	*Template Parameters*
zh-hans	*模板参数*

en	_Key_
zh-hans	_键_

en	`Key` must be https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^] into the container
zh-hans	`Key` 必须满足可移动插入要求，即能够被

en	and https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from the container.
zh-hans	https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入] 到容器中的要求，且需满足从容器中 https://en.cppreference.com/w/cpp/named_req/Erasable[可擦除] 的要求。

en	_Hash_

en	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`.
zh-hans	一元函数对象类型，用作 `Key` 的哈希函数。它接受一个类型为 `Key`

en	_Pred_

en	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`.
zh-hans	一种二元函数对象，用于在Key类型的值上构建等价关系。它接受两个Key类型的参数，并返回一个bool类型的值。

en	_Allocator_

en	An allocator whose value type is the same as the table's value type.
zh-hans	值类型与该表的值类型相同的分配器。

en	`std::allocator_traits<Allocator>::pointer` and `std::allocator_traits<Allocator>::const_pointer` must be convertible to/from `value_type*` and `const value_type*`, respectively.
zh-hans	`std::allocator_traits<allocator>::pointer` 与 `std::allocator_traits<allocator>::const_pointer` 必须分别可与 `value_type*` 和 `const value_type*` 相互转换。</allocator></allocator>

en	The element nodes of the table are held into an internal _bucket array_. An node is inserted into a bucket determined by the hash code of its element, but if the bucket is already occupied (a _collision_), an available one in the vicinity of the original position is used.
zh-hans	该表的元素节点存储于内部**桶数组**中。节点会根据其元素的哈希值插入到对应的桶内；若该桶已被占用（即发生**哈希冲突**），则使用原位置附近的可用桶进行存储。

en	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.
zh-hans	通过调用 `insert`/`emplace`，或执行 `rehash`/`reserve` 操作，可自动扩容桶数组的大小。容器的**负载因子**（元素数量除以桶数量）永远不会大于 `max_load_factor()`，仅在容器尺寸极小时，实现可能允许负载因子略高于该值。

en	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.
zh-hans	若 `link:../../../../../container_hash/doc/html/hash.html#ref_hash_is_avalanchinghash[hash_is_avalanching]<hash>::value` 为 `true`，则直接使用原哈希函数；否则会添加一个位混合后置处理阶段，以额外计算开销为代价提升哈希质量。</hash>

en	---

en	Concurrency Requirements and Guarantees
zh-hans	并发要求与保证

en	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:
zh-hans	要求对同一 `Hash` 或 `Pred` 常量实例并发调用 `operator()` 时不得引入数据竞争。对于 `Alloc` （即 `Allocator` 或其重绑定后的任意分配器类型），在同一实例 `al` 上并发调用以下操作时不得引入数据竞争：

en	Copy construction from `al` of an allocator rebound from `Alloc`
zh-hans	从 `al` 复制构造重新绑定的分配器

en	`std::allocator_traits<Alloc>::allocate`
zh-hans	`std::allocator++_++traits++&lt;++Alloc++&gt;++::allocate`

en	`std::allocator_traits<Alloc>::deallocate`
zh-hans	`std::allocator++_++traits++&lt;++Alloc++&gt;++::deallocate`

en	`std::allocator_traits<Alloc>::construct`
zh-hans	`std::allocator++_++traits++&lt;++Alloc++&gt;++::construct`

en	`std::allocator_traits<Alloc>::destroy`
zh-hans	`std::allocator++_++traits++&lt;++Alloc++&gt;++::destroy`

en	In general, these requirements on `Hash`, `Pred` and `Allocator` are met if these types are not stateful or if the operations only involve constant access to internal data members.
zh-hans	通常而言，若 `Hash` 、 `Pred` 和 `Allocator` 这些类型不包含状态，或其操作仅涉及对内部数据成员的常量访问，即可满足上述要求。

en	With the exception of destruction, concurrent invocations of any operation on the same instance of a `concurrent_node_set` do not introduce data races — that is, they are thread-safe.
zh-hans	除析构操作外，对同一 `concurrent++_++node++_++set` 实例并发调用任何操作均不会引入数据竞争——即这些操作是线程安全的。

en	If an operation *op* is explicitly designated as _blocking on_ `x`, where `x` is an instance of a `boost::concurrent_node_set`, prior blocking operations on `x` synchronize with *op*. So, blocking operations on the same `concurrent_node_set` execute sequentially in a multithreaded scenario.
zh-hans	若某个操作 *op* 被显式指定为__阻塞于__ `x` （其中 `x` 为 `boost::concurrent++_++node++_++set` 实例），则先前对 `x` 的阻塞操作将与 *op* 同步。因此，在多线程场景中，对同一 `concurrent++_++node++_++set` 的阻塞操作将按顺序执行。

en	An operation is said to be _blocking on rehashing of_ ``__x__`` if it blocks on `x` only when an internal rehashing is issued.
zh-hans	若某个操作仅在触发内部重哈希时才会阻塞于 _`x`_，则称该操作__阻塞于 _`x`_ 的重哈希过程__。

en	When executed internally by a `boost::concurrent_node_set`, the following operations by a user-provided visitation function on the element passed do not introduce data races:
zh-hans	当由 `boost::concurrent++_++node++_++set` 内部执行时，用户提供的访问函数对传递的元素执行以下操作不会引入数据竞争：

en	Read access to the element.
zh-hans	对元素的读取访问。

en	Non-mutable modification of the element.
zh-hans	对元素的非可变修改。

en	Mutable modification of the element:
zh-hans	对元素的可变修改：

en	** Within a container function accepting two visitation functions, always for the first function. ** Within a non-const container function whose name does not contain `cvisit`, for the last (or only) visitation function.
zh-hans	** 在容器接受两个访问函数的操作中，此条件始终适用于第一个访问函数。 ** 在名称不包含 `cvisit` 的非常量容器函数中，此条件适用于最后一个（或唯一一个）访问函数。

en	Any `boost::concurrent_node_set operation` that inserts or modifies an element `e` synchronizes with the internal invocation of a visitation function on `e`.
zh-hans	任何插入或修改元素 `e` 的 `boost::concurrent++_++node++_++set` 操作均与在 `e` 上内部调用的访问函数同步。

en	Visitation functions executed by a `boost::concurrent_node_set` `x` are not allowed to invoke any operation on `x`; invoking operations on a different `boost::concurrent_node_set` instance `y` is allowed only if concurrent outstanding operations on `y` do not access `x` directly or indirectly.
zh-hans	由 `boost::concurrent++_++node++_++set` `x` 执行的访问函数不得调用 `x` 上的任何操作；仅当对另一 `boost::concurrent++_++node++_++set` 实例 `y` 的并发未完成操作不直接或间接访问 `x` 时，才允许调用 `y` 上的操作。

en	---

en	Configuration Macros
zh-hans	配置宏

en	`BOOST_UNORDERED_DISABLE_REENTRANCY_CHECK`
zh-hans	`BOOST++_++UNORDERED++_++DISABLE++_++REENTRANCY++_++CHECK`

en	In debug builds (more precisely, when link:../../../../../assert/doc/html/assert.html#boost_assert_is_void[`BOOST_ASSERT_IS_VOID`^] is not defined), __container reentrancies__ (illegaly invoking an operation on `m` from within a function visiting elements of `m`) are detected and signalled through `BOOST_ASSERT_MSG`. When run-time speed is a concern, the feature can be disabled by globally defining this macro.
zh-hans	在调试版本中（更准确地说，当未定义 link:../../../../../assert/doc/html/assert.html#boost_assert_is_void[`BOOST++_++ASSERT++_++IS++_++VOID`] 时），系统会检测__容器重入__行为（即在访问 `m` 元素的函数内部非法调用 `m` 上的操作），并通过 `BOOST++_++ASSERT++_++MSG` 发出信号。若需关注运行时速度，可通过全局定义此宏来禁用该功能。

en	---

en	`BOOST_UNORDERED_ENABLE_STATS`
zh-hans	`BOOST++_++UNORDERED++_++ENABLE++_++STATS`

en	Globally define this macro to enable xref:reference/stats.adoc#stats[statistics calculation] for the table. Note that this option decreases the overall performance of many operations.
zh-hans	全局定义此宏以启用容器的 xref:reference/stats.adoc#stats[统计计算] 功能。请注意，此选项会降低多数操作的总体性能。

en	---

en	Typedefs
zh-hans	类型定义

en	A class for holding extracted table elements, modelling https://en.cppreference.com/w/cpp/container/node_handle[NodeHandle].
zh-hans	用于保存提取的表元素的类，建模为 https://en.cppreference.com/w/cpp/container/node_handle[NodeHandle] 。

en	---

en	A specialization of an internal class template:
zh-hans	内部类模板的特化：

en	with `NodeType` = `node_type`.
zh-hans	其中 `NodeType` = `node++_++type` 。

en	---

en	Constants
zh-hans	常量

en	```cpp static constexpr size_type bulk_visit_size; ```

en	Chunk size internally used in xref:concurrent_node_set_bulk_visit[bulk visit] operations.
zh-hans	xref:concurrent_node_set_bulk_visit[批量遍历]操作内部使用的块大小。

en	Constructors
zh-hans	构造函数

en	Default Constructor
zh-hans	默认构造函数

en	```c++ concurrent_node_set(); ```

en	Constructs an empty table using `hasher()` as the hash function, `key_equal()` as the key equality predicate and `allocator_type()` as the allocator.
zh-hans	构造一个空表，使用 `hasher()` 作为哈希函数，`key_equal()` 作为键相等性谓词，`allocator_type()` 作为分配器。

en	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^].
zh-hans	后置条件：;; `size() == 0` 要求：;; 若使用默认参数，`hasher`、`key_equal` 和 `allocator_type` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^]。

en	---

en	Bucket Count Constructor
zh-hans	桶数构造函数

en	```c++ explicit concurrent_node_set(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); ```
zh-hans	```c++ explicit concurrent_node_set(size_type n, const hasher&amp; hf = hasher(), const key_equal&amp; eql = key_equal(), const allocator_type&amp; a = allocator_type()); ```

en	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.
zh-hans	构造一个包含至少 `n` 个桶的空表，使用 `hf` 作为哈希函数，`eql` 作为键相等性谓词，`a` 作为分配器。

en	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^].
zh-hans	后置条件：;; `size() == 0` 要求：;; 若使用默认参数，`hasher`、`key_equal` 和 `allocator_type` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^]。

en	---

en	Iterator Range Constructor
zh-hans	迭代器范围构造函数

en	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.
zh-hans	构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等性谓词、 `a` 作为分配器，并将 `++[++f, l)` 范围内的元素插入其中。

en	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^].
zh-hans	要求;; 若使用默认值，则 `hasher` 、 `key++_++equal` 和 `allocator++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。

en	---

en	Copy Constructor
zh-hans	复制构造函数

en	```c++ concurrent_node_set(concurrent_node_set const& other); ```
zh-hans	```c++ concurrent_node_set(concurrent_node_set const&amp; other); ```

en	The copy constructor. Copies the contained elements, hash function, predicate and allocator.
zh-hans	复制构造函数。复制容器内的元素、哈希函数、谓词以及分配器。

en	If `Allocator::select_on_container_copy_construction` exists and has the right signature, the allocator will be constructed from its result.
zh-hans	若 `Allocator::select_on_container_copy_construction` 存在且签名正确，则分配器将由其返回值构造。

en	Requires:;; `value_type` is copy constructible Concurrency:;; Blocking on `other`.
zh-hans	要求：;; `value_type` 是可复制构造的 并发特性：;; 阻塞 `other`

en	---

en	Move Constructor
zh-hans	移动构造函数

en	```c++ concurrent_node_set(concurrent_node_set&& other); ```
zh-hans	```c++ concurrent_node_set(concurrent_node_set&amp;&amp; other); ```

en	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()`.
zh-hans	移动构造函数。`other` 的内部桶数组会直接转移到新容器中。哈希函数、谓词和分配器均从 `other` 移动构造而来。若启用了统计功能，会从 `other` 转移内部统计信息，并调用 `other.reset_stats()`。

en	Concurrency:;; Blocking on `other`.
zh-hans	并发特性：;; 阻塞 `other`

en	---

en	Iterator Range Constructor with Allocator
zh-hans	带分配器的迭代器范围构造函数

en	```c++ template<class InputIterator> concurrent_node_set(InputIterator f, InputIterator l, const allocator_type& a); ```
zh-hans	```c++ template<class inputiterator=""> concurrent_node_set(InputIterator f, InputIterator l, const allocator_type&amp; a); ```</class>

en	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.
zh-hans	构造一个以 `a` 作为分配器的空容器，使用默认的哈希函数与键相等性谓词，并将 `[f, l)` 范围内的元素插入其中。

en	Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh-hans	要求：;; `hasher`、`key_equal` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^]。

en	---

en	Allocator Constructor
zh-hans	分配器构造函数

en	```c++ explicit concurrent_node_set(Allocator const& a); ```
zh-hans	```c++ explicit concurrent_node_set(Allocator const&amp; a); ```

en	Constructs an empty table, using allocator `a`.
zh-hans	构造一个空容器，使用分配器 `a`。

en	---

en	Copy Constructor with Allocator
zh-hans	带分配器的复制构造函数

en	```c++ concurrent_node_set(concurrent_node_set const& other, Allocator const& a); ```
zh-hans	```c++ concurrent_node_set(concurrent_node_set const&amp; other, Allocator const&amp; a); ```

en	Constructs a table, copying ``other``'s contained elements, hash function, and predicate, but using allocator `a`.
zh-hans	构造一个容器，复制 `other` 中的元素、哈希函数和谓词，但使用分配器 `a`。

en	Concurrency:;; Blocking on `other`.
zh-hans	并发特性：;; 阻塞 `other`

en	---

en	Move Constructor with Allocator
zh-hans	带分配器的移动构造函数

en	```c++ concurrent_node_set(concurrent_node_set&& other, Allocator const& a); ```
zh-hans	```c++ concurrent_node_set(concurrent_node_set&amp;&amp; other, Allocator const&amp; a); ```

en	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_node_set_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` iff `a == other.get_allocator()`, and always calls `other.reset_stats()`.
zh-hans	若 `a == other.get_allocator()`，则 `other` 的元素会直接转移到新容器；否则元素从 `other` 移动构造而来。 哈希函数与谓词从 `other` 移动构造，分配器从 `a` 复制构造。 若启用了统计功能：仅当 `a == other.get_allocator()` 时，从 `other` 转移内部统计信息；**始终调用** `other.reset_stats()`。

en	Concurrency:;; Blocking on `other`.
zh-hans	并发特性：;; 阻塞 `other`

en	---

en	Move Constructor from unordered_node_set
zh-hans	从 unordered++_++node++_++set 的移动构造函数

en	```c++ concurrent_node_set(unordered_node_set<Key, Hash, Pred, Allocator>&& other); ```
zh-hans	```c++ concurrent_node_set(unordered_node_set<key, hash,="" pred,="" allocator="">&amp;&amp; other); ```</key,>

en	Move construction from a xref:#unordered_node_set[`unordered_node_set`]. The internal bucket array of `other` is transferred directly to the new container. 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()`.
zh-hans	从xref:#unordered_node_set[`unordered_node_set`]执行移动构造。`other`的内部桶数组直接转移至新容器。哈希函数、谓词及分配器均从`other`移动构造。若启用xref:concurrent_node_set_boost_unordered_enable_stats[统计功能]，则从`other`转移内部统计信息，并调用`other.reset_stats()`。

en	Complexity:;; O(`bucket_count()`)
zh-hans	复杂度：;; O(`bucket_count()`)

en	---

en	Initializer List Constructor
zh-hans	初始化列表构造函数

en	Constructs an empty table with at least `n` buckets, using `hf` as the hash function, `eql` as the key equality predicate and `a`, and inserts the elements from `il` into it.
zh-hans	构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等性谓词、 `a` 作为分配器，并 `il` 中的元素插入其中。

en	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^].
zh-hans	要求;; 若使用默认值，则 `hasher` 、 `key++_++equal` 和 `allocator++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。

en	---

en	Bucket Count Constructor with Allocator
zh-hans	带分配器的桶数构造函数

en	```c++ concurrent_node_set(size_type n, allocator_type const& a); ```
zh-hans	```c++ concurrent_node_set(size_type n, allocator_type const&amp; a); ```

en	Constructs an empty table with at least `n` buckets, using `hf` as the hash function, the default hash function and key equality predicate and `a` as the allocator.
zh-hans	构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、默认的键相等谓词，并以 `a` 作为分配器。

en	Postconditions:;; `size() == 0` Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh-hans	后置条件：;; `size() == 0` 要求：;; `hasher` 和 `key_equal` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^]。

en	---

en	Bucket Count Constructor with Hasher and Allocator
zh-hans	带哈希函数和分配器的桶数构造函数

en	```c++ concurrent_node_set(size_type n, hasher const& hf, allocator_type const& a); ```
zh-hans	```c++ concurrent_node_set(size_type n, hasher const&amp; hf, allocator_type const&amp; a); ```

en	Constructs an empty table with at least `n` buckets, using `hf` as the hash function, the default key equality predicate and `a` as the allocator.
zh-hans	构造一个至少拥有 `n` 个桶的空容器，使用 `hf` 作为哈希函数、默认的键相等性谓词，并以 `a` 作为分配器。

en	Postconditions:;; `size() == 0` Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh-hans	后置条件：;; `size() == 0` 要求：;; `key_equal` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^]。

en	---

en	Iterator Range Constructor with Bucket Count and Allocator
zh-hans	带桶数和分配器的迭代器范围构造函数

en	Constructs an empty table with at least `n` buckets, using `a` as the allocator and default hash function and key equality predicate, and inserts the elements from `[f, l)` into it.
zh-hans	构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器以及默认的哈希函数和键相等性谓词，并将 `++[++f, l)` 范围内的元素插入其中。

en	Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh-hans	要求;; `hasher` 和 `key++_++equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。

en	---

en	Iterator Range Constructor with Bucket Count and Hasher
zh-hans	带桶数和哈希函数的迭代器范围构造函数

en	Constructs an empty table with at least `n` buckets, using `hf` as the hash function, `a` as the allocator, with the default key equality predicate, and inserts the elements from `[f, l)` into it.
zh-hans	构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `a` 作为分配器以及默认的键相等性谓词，并将 `++[++f, l)` 范围内的元素插入其中。

en	Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh-hans	要求;; `key++_++equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。

en	---

en	initializer_list Constructor with Allocator
zh-hans	带分配器的初始化列表构造函数

en	```c++ concurrent_node_set(std::initializer_list<value_type> il, const allocator_type& a); ```
zh-hans	```c++ concurrent_node_set(std::initializer_list<value_type> il, const allocator_type&amp; a); ```</value_type>

en	Constructs an empty table using `a` and default hash function and key equality predicate, and inserts the elements from `il` into it.
zh-hans	构造一个使用分配器`a`、默认哈希函数和键相等性谓词的空容器，并将`il`中的元素插入其中。

en	Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh-hans	要求：;; `hasher` 和 `key_equal` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^]。

en	---

en	initializer_list Constructor with Bucket Count and Allocator
zh-hans	带桶数和分配器的初始化列表构造函数

en	```c++ concurrent_node_set(std::initializer_list<value_type> il, size_type n, const allocator_type& a); ```
zh-hans	```c++ concurrent_node_set(std::initializer_list<value_type> il, size_type n, const allocator_type&amp; a); ```</value_type>

en	Constructs an empty table with at least `n` buckets, using `a` and default hash function and key equality predicate, and inserts the elements from `il` into it.
zh-hans	构造一个至少包含 `n` 个桶的空容器，使用分配器 `a`、默认哈希函数和键相等性谓词，并将 `il` 中的元素插入其中。

en	Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh-hans	要求：;; `hasher` 和 `key_equal` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^]。

en	---

en	initializer_list Constructor with Bucket Count and Hasher and Allocator
zh-hans	带桶数、哈希函数和分配器的初始化列表构造函数

en	```c++ concurrent_node_set(std::initializer_list<value_type> il, size_type n, const hasher& hf, const allocator_type& a); ```
zh-hans	```c++ concurrent_node_set(std::initializer_list<value_type> il, size_type n, const hasher&amp; hf, const allocator_type&amp; a); ```</value_type>

en	Constructs an empty table with at least `n` buckets, using `hf` as the hash function, `a` as the allocator and default key equality predicate,and inserts the elements from `il` into it.
zh-hans	构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、`a` 作为分配器以及默认的键相等性谓词，并将 `il` 中的元素插入其中。

en	Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh-hans	要求：;; `key_equal` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^]。

en	---

en	Destructor
zh-hans	析构函数

en	```c++ ~concurrent_node_set(); ```

en	Note:;; The destructor is applied to every element, and all memory is deallocated
zh-hans	注意：;; 析构函数会作用于所有元素，且所有内存都会被释放

en	---

en	Assignment
zh-hans	赋值操作

en	Copy Assignment
zh-hans	复制赋值

en	```c++ concurrent_node_set& operator=(concurrent_node_set const& other); ```
zh-hans	```c++ concurrent_node_set&amp; operator=(concurrent_node_set const&amp; other); ```

en	The assignment operator. Destroys previously existing elements, copy-assigns the hash function and predicate from `other`, copy-assigns the allocator from `other` if `Alloc::propagate_on_container_copy_assignment` exists and `Alloc::propagate_on_container_copy_assignment::value` is `true`, and finally inserts copies of the elements of `other`.
zh-hans	赋值运算符。销毁先前存在的元素，从`other`复制赋值哈希函数和谓词；若`Alloc::propagate_on_container_copy_assignment`存在且`Alloc::propagate_on_container_copy_assignment::value`为`true`，则从`other`复制赋值分配器；最后插入`other`元素的副本。

en	Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^] Concurrency:;; Blocking on `*this` and `other`.
zh-hans	要求：;; `value_type` 必须满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^] 并发：;; 阻塞于 `*this` 和 `other`。

en	---

en	Move Assignment
zh-hans	移动赋值

en	```c++ concurrent_node_set& operator=(concurrent_node_set&& other) noexcept(boost::allocator_traits<Allocator>::is_always_equal::value || boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value); ``` The move assignment operator. Destroys previously existing elements, swaps the hash function and predicate from `other`, and move-assigns the allocator from `other` if `Alloc::propagate_on_container_move_assignment` exists and `Alloc::propagate_on_container_move_assignment::value` is `true`. If at this point the allocator is equal to `other.get_allocator()`, the internal bucket array of `other` is transferred directly to `*this`; otherwise, inserts move-constructed copies of the elements of `other`. If statistics are xref:concurrent_node_set_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` iff the final allocator is equal to `other.get_allocator()`, and always calls `other.reset_stats()`.
zh-hans	```c++ concurrent_node_set&amp; operator=(concurrent_node_set&amp;&amp; other) noexcept(boost::allocator_traits<allocator>::is_always_equal::value || boost::allocator_traits<allocator>::propagate_on_container_move_assignment::value); ``` 移动赋值运算符。销毁先前存在的元素，交换other的哈希函数与谓词；若Alloc::propagate_on_container_move_assignment存在且Alloc::propagate_on_container_move_assignment::value为true，则移动赋值other的分配器。若此时分配器与other.get_allocator()相等，直接将other的内部桶数组转移至*this；否则插入other元素的移动构造副本。若启用 xref:concurrent_node_set_boost_unordered_enable_stats [统计功能]，当且仅当最终分配器与other.get_allocator()相等时，从other转移内部统计信息，且始终调用other.reset_stats()。</allocator></allocator>

en	Concurrency:;; Blocking on `*this` and `other`.
zh-hans	并发：;; 阻塞于 `*this` 和 `other`。

en	---

en	Initializer List Assignment
zh-hans	初始化列表赋值

en	```c++ concurrent_node_set& operator=(std::initializer_list<value_type> il); ```
zh-hans	```c++ concurrent_node_set&amp; operator=(std::initializer_list<value_type> il); ```</value_type>

en	Assign from values in initializer list. All previously existing elements are destroyed.
zh-hans	通过初始化列表中的值赋值。所有先前存在的元素都会被销毁。

en	Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^] Concurrency:;; Blocking on `*this`.
zh-hans	要求：;; `value_type` 必须满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^] 并发：;; 阻塞于 `*this`。

en	---

en	Visitation
zh-hans	访问操作

en	[c]visit

en	```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; ```
zh-hans	```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>

en	If an element `x` exists with key equivalent to `k`, invokes `f` with a const reference to `x`.
zh-hans	若存在键与 `k` 等价的元素 `x`，则使用指向 `x` 的常量引用调用 `f`。

en	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.
zh-hans	返回值：;; 访问过的元素数量（0 或 1）。 注意：;; 仅当 `Hash::is_transparent` 与 `Pred::is_transparent` 为合法成员别名时，`template<class k,="" class="" f="">` 重载版本才会参与重载决议。库假定 `Hash` 可同时用于 `K` 与 `Key` 类型，且 `Pred` 是透明的。这支持异构查找，避免了实例化 `Key` 类型对象的开销。</class>

en	---

en	Bulk visit
zh-hans	批量访问

en	```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; ```
zh-hans	```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>

en	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`.
zh-hans	对范围 ++[++`first`, `last`) 内的每个元素 `k` ，若容器中存在键等价于 `k` 的元素 `x` ，则使用指向 `x` 的常量引用调用 `f` 。

en	Although functionally equivalent to individually invoking xref:concurrent_node_set_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_node_set_constants[`bulk_visit_size`] to enjoy a performance gain: beyond this size, performance is not expected to increase further.
zh-hans	尽管功能上等同于对每个键单独调用 `[c]visit`，但批量访问因内部优化通常性能更高。建议 `std::distance(first,last)` 至少达到 `bulk_visit_size` 以获得性能提升；超过该大小后，性能预计不会进一步提升。

en	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.
zh-hans	要求：;; `FwdIterator` 是传统前向迭代器（C++11 至 C++17），或满足 `std::forward_iterator` 概念（C++20 及更高版本）。对于 `K = std::iterator_traits<fwditerator>::value_type`，要么 `K` 是 `key_type`，要么 `Hash::is_transparent` 和 `Pred::is_transparent` 是合法的成员别名。在后一种情况下，库假定 `Hash` 可同时接收 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这支持异构查找，避免了实例化 `Key` 类型对象的开销。返回值：;; 被访问的元素数量。</fwditerator>

en	---

en	[c]visit_all

en	```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; ```
zh-hans	```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>

en	Successively invokes `f` with const references to each of the elements in the table.
zh-hans	依次以表中每个元素的常量引用调用 `f`。

en	Returns:;; The number of elements visited.
zh-hans	返回值：;; 被访问的元素数量。

en	---

en	Parallel [c]visit_all
zh-hans	并行 ++[++c++]++visit++_++all

en	```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; ```
zh-hans	```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>

en	Invokes `f` with const references to each of the elements in the table. Execution is parallelized according to the semantics of the execution policy specified.
zh-hans	以表中每个元素的常量引用调用 `f`。执行过程会根据指定执行策略的语义进行并行化。

en	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.
zh-hans	抛出异常：;; 根据所使用执行策略的异常处理机制，若 `f` 内部抛出异常，则可能调用 `std::terminate`。 注意：;; 仅在支持 C++17 并行算法的编译器中可用。 仅当`std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt;` 为 `true` 时，这些重载版本才参与重载决议。 不允许使用无顺序执行策略。</std::remove_cvref_t<executionpolicy>

en	---

en	[c]visit_while

en	```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; ```
zh-hans	```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>

en	Successively invokes `f` with const references to each of the elements in the table until `f` returns `false` or all the elements are visited.
zh-hans	依次以表中每个元素的常量引用调用 `f`，直到 `f` 返回 `false` 或遍历完所有元素。

en	Returns:;; `false` iff `f` ever returns `false`.
zh-hans	返回值：;; 当且仅当 `f` 返回过 `false` 时，返回 `false`。

en	---

en	Parallel [c]visit_while
zh-hans	并行 ++[++c++]++visit++_++while

en	```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; ```
zh-hans	```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>

en	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.
zh-hans	以表中每个元素的常量引用调用 `f`，直到 `f` 返回 `false` 或遍历完所有元素。执行过程会根据指定执行策略的语义进行并行化。

en	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`.
zh-hans	返回值：;; 当且仅当 `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>

en	---

en	Size and Capacity
zh-hans	大小与容量

en	empty
zh-hans	空

en	```c++ [[nodiscard]] bool empty() const noexcept; ```

en	Returns:;; `size() == 0`
zh-hans	返回值：;; `size() == 0`

en	---

en	size
zh-hans	大小

en	```c++ size_type size() const noexcept; ```

en	Returns:;; The number of elements in the table.
zh-hans	返回值：;; 哈希表中的元素数量。

en	Notes:;; In the presence of concurrent insertion operations, the value returned may not accurately reflect the true size of the table right after execution.
zh-hans	注意：;; 当存在并发插入操作时，返回的值可能无法精确反映函数执行后哈希表的真实大小。

en	---

en	max_size

en	```c++ size_type max_size() const noexcept; ```

en	Returns:;; `size()` of the largest possible table.
zh-hans	返回值：;; 哈希表支持的最大元素数量。

en	---

en	Modifiers
zh-hans	修改器

en	emplace
zh-hans	原地构造

en	```c++ template<class... Args> bool emplace(Args&&... args); ```
zh-hans	```c++ template<class... args=""> bool emplace(Args&amp;&amp;... args); ```</class...>

en	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.
zh-hans	当且仅当哈希表中不存在键等价的元素时，才使用参数 `args` 构造对象并插入到哈希表中。

en	Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`.
zh-hans	要求：;; `value_type` 可由 `args` 构造。 返回值：;; 若成功插入元素则返回 `true`。 并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。

en	---

en	Copy Insert
zh-hans	复制插入

en	```c++ bool insert(const value_type& obj); ```
zh-hans	```c++ bool insert(const value_type&amp; obj); ```

en	Inserts `obj` in the table if and only if there is no element in the table with an equivalent key.
zh-hans	当且仅当哈希表中不存在键等价的元素时，才将 `obj` 插入到哈希表中。

en	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`.
zh-hans	要求：;; `value_type` 支持拷贝插入。 返回值：;; 若成功插入元素则返回 `true`。 并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。

en	---

en	Move Insert
zh-hans	移动插入

en	```c++ bool insert(value_type&& obj); ```
zh-hans	```c++ bool insert(value_type&amp;&amp; obj); ```

en	Inserts `obj` in the table if and only if there is no element in the table with an equivalent key.
zh-hans	当且仅当哈希表中不存在键等价的元素时，才将 `obj` 插入到哈希表中。

en	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`.
zh-hans	要求：;; `value_type` 支持移动插入。 返回值：;; 若成功插入元素则返回 `true`。 并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。

en	---

en	Transparent Insert
zh-hans	透明插入

en	```c++ template<class K> bool insert(K&& k); ```
zh-hans	```c++ template<class k=""> bool insert(K&amp;&amp; k); ```</class>

en	Inserts an element constructed from `std::forward<K>(k)` in the container if and only if there is no element in the container with an equivalent key.
zh-hans	当且仅当容器中不存在键等价的元素时，才使用 `std::forward<k>(k)` 构造元素并插入到容器中。</k>

en	Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; This 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.
zh-hans	要求：;; `value_type` 可通过 `k` 原位构造。 返回值：;; 若成功插入元素则返回 `true`。 并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。 注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员别名时，该重载版本参与重载决议。库假定 `Hash` 可同时接收 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这支持异构查找，避免了实例化 `Key` 类型对象的开销。

en	---

en	Insert Iterator Range
zh-hans	迭代器范围插入

en	```c++ template<class InputIterator> size_type insert(InputIterator first, InputIterator last); ```
zh-hans	```c++ template<class inputiterator=""> size_type insert(InputIterator first, InputIterator last); ```</class>

en	Equivalent to [listing,subs="+macros,+quotes"]
zh-hans	等价于 [listing,subs="+macros,+quotes"]

en	Returns:;; The number of elements inserted.
zh-hans	返回值：;; 成功插入的元素数量。

en	---

en	Insert Initializer List
zh-hans	初始化列表插入

en	```c++ size_type insert(std::initializer_list<value_type> il); ```
zh-hans	```c++ size_type insert(std::initializer_list<value_type> il); ```</value_type>

en	Equivalent to [listing,subs="+macros,+quotes"]
zh-hans	等价于 [listing,subs="+macros,+quotes"]

en	Returns:;; The number of elements inserted.
zh-hans	返回值：;; 成功插入的元素个数。

en	---

en	Insert Node
zh-hans	节点插入

en	```c++ insert_return_type insert(node_type&& nh); ```
zh-hans	```c++ insert_return_type insert(node_type&amp;&amp; nh); ```

en	If `nh` is not empty, 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()`. `nh` is empty when the function returns.
zh-hans	若 `nh` 非空，则当且仅当哈希表中不存在与 `nh.value()` 键等价的元素时，将其关联元素插入哈希表。函数返回时 `nh` 变为空。

en	Returns:;; An `insert_return_type` object constructed from `inserted` and `node`: +
zh-hans	返回值：;; 由 `inserted` 和 `node` 构造的 `insert_return_type` 对象。

en	If `nh` is empty, `inserted` is `false` and `node` is empty.
zh-hans	若 `nh` 为空，则 `inserted` 为 `false` 且 `node` 为空。

en	Otherwise if the insertion took place, `inserted` is true and `node` is empty.
zh-hans	若插入操作成功，则 `inserted` 为 true， 且 `node` 为空。

en	If the insertion failed, `inserted` is false and `node` has the previous value of `nh`.
zh-hans	若插入操作失败，则 `inserted` 为 false ，且 `node` 保留 `nh` 的原值。

en	Throws:;; If an exception is thrown by an operation other than a call to `hasher` 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.
zh-hans	若 `nh` 非空，则当且仅当容器中不存在与 `nh.value()` 等效的键时，插入其关联的元素。函数返回时 `nh` 为空。

en	---

en	emplace_or_[c]visit

en	```c++ template<class... Args, class F> bool emplace_or_visit(Args&&... args, F&& f); template<class... Args, class F> bool emplace_or_cvisit(Args&&... args, F&& f); ```
zh-hans	```c++ template<class... args,="" class="" f=""> bool emplace_or_visit(Args&amp;&amp;... args, F&amp;&amp; f); template<class... args,="" class="" f=""> bool emplace_or_cvisit(Args&amp;&amp;... args, F&amp;&amp; f); ```</class...></class...>

en	Inserts an object, constructed with the arguments `args`, in the table if there is no element in the table with an equivalent key. Otherwise, invokes `f` with a const reference to the equivalent element.
zh-hans	若哈希表中不存在键等价的元素，则使用参数 `args` 构造对象并插入表中；否则，以该等价元素的常量引用为参数调用函数 `f`。

en	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 a parameter `f` after a variadic parameter pack.
zh-hans	要求：;; `value_type` 可由 `args` 构造。 返回值：;; 若成功插入元素则返回 `true`。 并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。 注意：;; 该接口仅为说明性用法，因为 C++ 不允许在可变参数包之后声明参数 `f`。

en	---

en	Copy insert_or_[c]visit
zh-hans	复制 insert++_++or++_[++c++]++visit

en	```c++ template<class F> bool insert_or_visit(const value_type& obj, F f); template<class F> bool insert_or_cvisit(const value_type& obj, F f); ```
zh-hans	```c++ template<class f=""> bool insert_or_visit(const value_type&amp; obj, F f); template<class f=""> bool insert_or_cvisit(const value_type&amp; obj, F f); ```</class></class>

en	Inserts `obj` in the table if and only if there is no element in the table with an equivalent key. Otherwise, invokes `f` with a const reference to the equivalent element.
zh-hans	当且仅当哈希表中不存在键等价的元素时，将 `obj` 插入表中；否则，以该等价元素的常量引用为参数调用函数 `f`。

en	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`.
zh-hans	要求：;; `value_type` 支持拷贝插入。 返回值：;; 若成功插入元素则返回 `true`。 并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。

en	---

en	Move insert_or_[c]visit
zh-hans	移动 insert++_++or++_[++c++]++visit

en	```c++ template<class F> bool insert_or_visit(value_type&& obj, F f); template<class F> bool insert_or_cvisit(value_type&& obj, F f); ```
zh-hans	```c++ template<class f=""> bool insert_or_visit(value_type&amp;&amp; obj, F f); template<class f=""> bool insert_or_cvisit(value_type&amp;&amp; obj, F f); ```</class></class>

en	Inserts `obj` in the table if and only if there is no element in the table with an equivalent key. Otherwise, invokes `f` with a const reference to the equivalent element.
zh-hans	当且仅当哈希表中不存在键等价的元素时，将 `obj` 插入表中；否则，以该等价元素的常量引用为参数调用函数 `f`。

en	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`.
zh-hans	要求：;; `value_type` 支持移动插入。 返回值：;; 若成功插入元素则返回 `true`。 并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。

en	---

en	Transparent insert_or_[c]visit
zh-hans	透明 insert++_++or++_[++c++]++visit

en	```c++ template<class K, class F> bool insert_or_visit(K&& k, F f); template<class K, class F> bool insert_or_cvisit(K&& k, F f); ```
zh-hans	```c++ template<class k,="" class="" f=""> bool insert_or_visit(K&amp;&amp; k, F f); template<class k,="" class="" f=""> bool insert_or_cvisit(K&amp;&amp; k, F f); ```</class></class>

en	Inserts an element constructed from `std::forward<K>(k)` in the container if and only if there is no element in the container with an equivalent key. Otherwise, invokes `f` with a const reference to the equivalent element.
zh-hans	当且仅当容器中不存在键等价的元素时，使用 `std::forward<k>(k)` 构造元素并插入容器；否则，以该等价元素的常量引用为参数调用函数 `f`。</k>

en	Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; These 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.
zh-hans	要求：;; `value_type` 可从 `k` 原位构造。 返回值：;; 若成功插入元素则返回 `true`。 并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。 注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员别名时，该重载版本参与重载决议。库假定 `Hash` 可同时接收 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这支持异构查找，避免了实例化 `Key` 类型对象的开销。

en	---

en	Insert Iterator Range or Visit
zh-hans	迭代器范围插入或访问

en	```c++ template<class InputIterator,class F> size_type insert_or_visit(InputIterator first, InputIterator last, F f); template<class InputIterator,class F> size_type insert_or_cvisit(InputIterator first, InputIterator last, F f); ```
zh-hans	```c++ template<class inputiterator,class="" f=""> size_type insert_or_visit(InputIterator first, InputIterator last, F f); template<class inputiterator,class="" f=""> size_type insert_or_cvisit(InputIterator first, InputIterator last, F f); ```</class></class>

en	Equivalent to [listing,subs="+macros,+quotes"]
zh-hans	等价于 [listing,subs="+macros,+quotes"]

en	Returns:;; The number of elements inserted.
zh-hans	返回值：;; 成功插入的元素个数。

en	---

en	Insert Initializer List or Visit
zh-hans	初始化列表插入或访问

en	```c++ template<class F> size_type insert_or_visit(std::initializer_list<value_type> il, F f); template<class F> size_type insert_or_cvisit(std::initializer_list<value_type> il, F f); ```
zh-hans	```c++ template<class f=""> size_type insert_or_visit(std::initializer_list<value_type> il, F f); template<class f=""> size_type insert_or_cvisit(std::initializer_list<value_type> il, F f); ```</value_type></class></value_type></class>

en	Equivalent to [listing,subs="+macros,+quotes"]
zh-hans	等价于 [listing,subs="+macros,+quotes"]

en	Returns:;; The number of elements inserted.
zh-hans	返回值：;; 成功插入的元素个数。

en	---

en	Insert Node or Visit
zh-hans	节点插入或访问

en	```c++ template<class F> insert_return_type insert_or_visit(node_type&& nh, F f); template<class F> insert_return_type insert_or_cvisit(node_type&& nh, F f); ```
zh-hans	```c++ template<class f=""> insert_return_type insert_or_visit(node_type&amp;&amp; nh, F f); template<class f=""> insert_return_type insert_or_cvisit(node_type&amp;&amp; nh, F f); ```</class></class>

en	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.
zh-hans	若 `nh` 为空，则不执行任何操作。否则，当且仅当哈希表中不存在与 `nh.value()` 键等价的元素时，将其关联元素插入表中；否则，以该等价元素的常量引用为参数调用函数 `f`。

en	Returns:;; An `insert_return_type` object constructed from `inserted` and `node`: +
zh-hans	返回值：;; 由 `inserted` 和 `node` 构造的 `insert_return_type` 对象。

en	If `nh` is empty, `inserted` is `false` and `node` is empty.
zh-hans	若 `nh` 为空，则 `inserted` 为 `false` 且 `node` 为空。

en	Otherwise if the insertion took place, `inserted` is true and `node` is empty.
zh-hans	若插入操作成功，则 `inserted` 为 true， 且 `node` 为空。

en	If the insertion failed, `inserted` is false and `node` has the previous value of `nh`.
zh-hans	若插入操作失败，则 `inserted` 为 false ，且 `node` 保留 `nh` 的原值。

en	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.
zh-hans	若 `nh` 为空，则不执行任何操作；否则，当且仅当容器中不存在与 `nh.value()` 等效的键时，插入其关联的元素；否则，使用指向等效元素的常量引用调用 `f` 。

en	---

en	emplace_and_[c]visit

en	```c++ template<class... Args, class F1, class F2> bool emplace_or_visit(Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool emplace_or_cvisit(Args&&... args, F1&& f1, F2&& f2); ```
zh-hans	```c++ template<class... args,="" class="" f1,="" f2=""> bool emplace_or_visit(Args&amp;&amp;... args, F1&amp;&amp; f1, F2&amp;&amp; f2); template<class... args,="" class="" f1,="" f2=""> bool emplace_or_cvisit(Args&amp;&amp;... args, F1&amp;&amp; f1, F2&amp;&amp; f2); ```</class...></class...>

en	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.
zh-hans	若哈希表中不存在键等价的元素，则使用参数 `args` 构造对象并插入表中，随后以新建元素的常量引用为参数调用函数 `f1`；否则，以该等价元素的常量引用为参数调用函数 `f2`。

en	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.
zh-hans	要求：;; `value_type` 可由 `args` 构造。 返回值：;; 若成功插入元素则返回 `true`。 并发特性：;; 会阻塞当前对象的重哈希操作。 注意：;; 该接口仅为说明性用法，因为 C++ 不允许在可变参数包之后声明 `f1` 和 `f2` 参数。

en	---

en	Copy insert_and_[c]visit
zh-hans	复制 insert++_++and++_[++c++]++visit

en	```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); ```
zh-hans	```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>

en	Inserts `obj` in the table if and only 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 `f` with a const reference to the equivalent element.
zh-hans	当且仅当哈希表中不存在键等价的元素时，将 `obj` 插入表中，随后以新建元素的常量引用为参数调用函数 `f1`；否则，以该等价元素的常量引用为参数调用函数 `f`。

en	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`.
zh-hans	要求：`value_type` 支持拷贝插入。 返回值：若成功插入元素则返回 `true`。 并发特性：会阻塞当前对象的重哈希操作。

en	---

en	Move insert_and_[c]visit
zh-hans	移动 insert++_++and++_[++c++]++visit

en	```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); ```
zh-hans	```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>

en	Inserts `obj` in the table if and only 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.
zh-hans	当且仅当哈希表中不存在键等价的元素时，将 `obj` 插入表中，随后以新建元素的常量引用为参数调用函数 `f1`；否则，以该等价元素的常量引用为参数调用函数 `f2`。 要求：`value_type` 支持拷贝插入。 返回值：若成功插入元素则返回 `true`。 并发特性：会阻塞当前对象的重哈希操作。

en	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`.
zh-hans	要求：;; `value_type` 满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]。 返回值：;; 插入成功则返回 `true`。 并发特性：;; 会阻塞 `*this` 的重哈希操作。

en	---

en	Transparent insert_and_[c]visit
zh-hans	透明 insert++_++and++_[++c++]++visit（透明插入并 ++[++c++]++ 访问）

en	```c++ template<class K, class F1, class F2> bool insert_and_visit(K&& k, F1 f1, F2 f2); template<class K, class F1, class F2> bool insert_and_cvisit(K&& k, F1 f1, F2 f2); ```
zh-hans	```c++ template<class k,="" class="" f1,="" f2=""> bool insert_and_visit(K&amp;&amp; k, F1 f1, F2 f2); template<class k,="" class="" f1,="" f2=""> bool insert_and_cvisit(K&amp;&amp; k, F1 f1, F2 f2); ```</class></class>

en	Inserts an element constructed from `std::forward<K>(k)` in the container if and only if there is no element in the container 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.
zh-hans	当且仅当容器中不存在键等价的元素时，通过`std::forward<k>(k)`构造元素并插入容器，随后使用新建元素的常量引用调用`f1`。若存在等价键元素，则使用该元素的常量引用调用`f2`。</k>

en	Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; These 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.
zh-hans	要求：;; `value_type` 可基于 `k` 满足 https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^]。 返回值：;; 插入成功则返回 `true`。 并发特性：;; 会阻塞 `*this` 的重哈希操作。 注意：;; 仅当 `Hash::is_transparent` 与 `Pred::is_transparent` 为合法成员类型别名时，此类重载函数才参与重载决议。本库假定 `Hash` 可接收 `K` 与 `Key` 两种类型进行调用，且 `Pred` 具备透明特性。该特性支持异构查找，省去了实例化 `Key` 类型对象的开销。

en	---

en	Insert Iterator Range and Visit
zh-hans	迭代器范围插入并访问

en	```c++ template<class InputIterator,class F1, class F2> size_type insert_and_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); template<class InputIterator,class F1, class f2> size_type insert_and_cvisit(InputIterator first, InputIterator last, F1 f1, F2 f2); ```
zh-hans	```c++ template<class inputiterator,class="" f1,="" class="" f2=""> size_type insert_and_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); template<class inputiterator,class="" f1,="" class="" f2=""> size_type insert_and_cvisit(InputIterator first, InputIterator last, F1 f1, F2 f2); ```</class></class>

en	Equivalent to [listing,subs="+macros,+quotes"]
zh-hans	等价于 [listing,subs="+macros,+quotes"]

en	Returns:;; The number of elements inserted.
zh-hans	返回值：;; 成功插入的元素数量。

en	---

en	Insert Initializer List and Visit
zh-hans	初始化列表插入并访问

en	```c++ template<class F1, class F2> size_type insert_and_visit(std::initializer_list<value_type> il, F1 f1, F2 f2); template<class F1, class F2> size_type insert_and_cvisit(std::initializer_list<value_type> il, F1 f1, F2 f2); ```
zh-hans	```c++ template<class f1,="" class="" f2=""> size_type insert_and_visit(std::initializer_list<value_type> il, F1 f1, F2 f2); template<class f1,="" class="" f2=""> size_type insert_and_cvisit(std::initializer_list<value_type> il, F1 f1, F2 f2); ```</value_type></class></value_type></class>

en	Equivalent to [listing,subs="+macros,+quotes"]
zh-hans	等价于 [listing,subs="+macros,+quotes"]

en	Returns:;; The number of elements inserted.
zh-hans	返回值：;; 已插入的元素数量。

en	---

en	Insert Node and Visit
zh-hans	节点插入并访问

en	```c++ template<class F1, class F2> insert_return_type insert_and_visit(node_type&& nh, F1 f1, F2 f2); template<class F1, class F2> insert_return_type insert_and_cvisit(node_type&& nh, F1 f1, F2 f2); ```
zh-hans	```c++ template<class f1,="" class="" f2=""> insert_return_type insert_and_visit(node_type&amp;&amp; nh, F1 f1, F2 f2); template<class f1,="" class="" f2=""> insert_return_type insert_and_cvisit(node_type&amp;&amp; nh, F1 f1, F2 f2); ```</class></class>

en	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()`, and then invokes `f1` with a const reference to the newly inserted element. Otherwise, invokes `f2` with a const reference to the equivalent element.
zh-hans	若 `nh` 为空，则不执行任何操作。否则，当且仅当表中不存在与 `nh.value()` 键等价的元素时，将关联元素插入表中，随后以新插入元素的常量引用调用 `f1`；否则，以等价元素的常量引用调用 `f2`。

en	Returns:;; An `insert_return_type` object constructed from `inserted` and `node`: +
zh-hans	返回值：;; 由 `inserted` 和 `node` 构造的 `insert_return_type` 对象：+

en	If `nh` is empty, `inserted` is `false` and `node` is empty.
zh-hans	若 `nh` 为空，则 `inserted` 为 `false` 且 `node` 为空。

en	Otherwise if the insertion took place, `inserted` is true and `node` is empty.
zh-hans	若插入操作成功，则 `inserted` 为 true， 且 `node` 为空。

en	If the insertion failed, `inserted` is false and `node` has the previous value of `nh`.
zh-hans	若插入操作失败，则 `inserted` 为 false ，且 `node` 保留 `nh` 的原值。

en	Throws:;; If an exception is thrown by an operation other than a call to `hasher` or call to `f1` or `f2`, 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.
zh-hans	若 `nh` 为空，则不执行任何操作；否则，当且仅当容器中不存在与 `nh.value()` 等效的键时，插入其关联的元素，并使用指向新插入元素的常量引用调用 `f1` ；否则，使用指向等效元素的常量引用调用 `f2` 。

en	---

en	erase
zh-hans	擦除

en	```c++ size_type erase(const key_type& k); template<class K> size_type erase(const K& k); ```
zh-hans	```c++ size_type erase(const key_type&amp; k); template<class k=""> size_type erase(const K&amp; k); ```</class>

en	Erases the element with key equivalent to `k` if it exists.
zh-hans	删除键与 `k` 等价的元素（若该元素存在）。

en	Returns:;; The number of elements erased (0 or 1). 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.
zh-hans	返回值：;; 删除的元素数量（0 或 1）。 异常：;; 仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出异常。 注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时，`template<class k="">` 重载才参与重载决议。标准库假定 `Hash` 可同时接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机制支持异构查找，避免了实例化 `Key` 类型对象的开销。</class>

en	---

en	erase_if by Key
zh-hans	通过键进行条件擦除

en	```c++ template<class F> size_type erase_if(const key_type& k, F f); template<class K, class F> size_type erase_if(const K& k, F f); ```
zh-hans	```c++ template<class f=""> size_type erase_if(const key_type&amp; k, F f); template<class k,="" class="" f=""> size_type erase_if(const K&amp; k, F f); ```</class></class>

en	Erases the element `x` with key equivalent to `k` if it exists and `f(x)` is `true`.
zh-hans	若键与 `k` 等价的元素 `x` 存在且 `f(x)` 为 `true`，则删除该元素。

en	Returns:;; The number of elements erased (0 or 1). Throws:;; Only throws an exception if it is thrown by `hasher`, `key_equal` or `f`. Notes:;; The `template<class K, class F>` overload only participates in overload resolution if `std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is `false`. + + The `template<class K, class F>` 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.
zh-hans	返回值：;; 删除的元素数量（0 或 1）。 异常：;; 仅当 `hasher`、`key_equal` 或 `f` 抛出异常时才会抛出异常。 注意：;; 仅当 `std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt;` 为 `false` 时，`template<class k,="" class="" f="">` 重载才参与重载决议。 注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时，`template<class k,="" class="" f="">` 重载才参与重载决议。标准库假定 `Hash` 可同时接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机制支持异构查找，避免了实例化 `Key` 类型对象的开销。</class></class></std::remove_cvref_t<executionpolicy>

en	---

en	erase_if

en	```c++ template<class F> size_type erase_if(F f); ```
zh-hans	```c++ template<class f=""> size_type erase_if(F f); ```</class>

en	Successively invokes `f` with references to each of the elements in the table, and erases those for which `f` returns `true`.
zh-hans	依次以表中每个元素的引用调用 `f`，并删除所有 `f` 返回 `true` 的元素。

en	Returns:;; The number of elements erased. Throws:;; Only throws an exception if it is thrown by `f`.
zh-hans	返回值：;; 删除的元素数量。 异常：;; 仅当 `f` 抛出异常时才会抛出异常。

en	---

en	Parallel erase_if
zh-hans	并行条件擦除

en	```c++ template<class ExecutionPolicy, class F> void erase_if(ExecutionPolicy&& policy, F f); ```
zh-hans	```c++ template<class executionpolicy,="" class="" f=""> void erase_if(ExecutionPolicy&amp;&amp; policy, F f); ```</class>

en	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.
zh-hans	以表中每个元素的引用调用 `f`，并删除所有 `f` 返回 `true` 的元素。执行过程将根据指定执行策略的语义进行并行化处理。

en	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.
zh-hans	异常：;; 依据所使用执行策略的异常处理机制，若 `f` 内部抛出异常，则可能调用 `std::terminate`。 注意：;; 仅在支持 C++17 并行算法的编译器中可用。 注意：;; 仅当 `std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt;` 为 `true` 时，该重载才参与重载决议。 注意：;; 不允许使用无序执行策略。</std::remove_cvref_t<executionpolicy>

en	---

en	swap
zh-hans	交换

en	```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); ```
zh-hans	```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>

en	Swaps the contents of the table with the parameter.
zh-hans	将当前表与参数对象的内容进行交换。

en	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.
zh-hans	若 `Allocator::propagate_on_container_swap` 已声明且 `Allocator::propagate_on_container_swap::value` 为 `true`，则交换两个表的分配器。否则，使用不相等的分配器进行交换会导致未定义行为。

en	Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
zh-hans	异常：;; 除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。 并发：;; 阻塞 `*this` 和 `other`。

en	---

en	extract

en	```c++ node_type extract(const key_type& k); template<class K> node_type extract(K&& k); ```
zh-hans	```c++ node_type extract(const key_type&amp; k); template<class k=""> node_type extract(K&amp;&amp; k); ```</class>

en	Extracts the element with key equivalent to `k`, if it exists.
zh-hans	返回值：;; 提取键与 `k` 等价的元素（若该元素存在）。

en	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.
zh-hans	返回值：;; 存储提取元素的 `node_type` 对象，若未提取任何元素则为空。 异常：;; 仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出异常。 注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时，`template<class k="">` 重载才参与重载决议。标准库假定 `Hash` 可同时接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机制支持异构查找，避免了实例化 `Key` 类型对象的开销。</class>

en	---

en	extract_if
zh-hans	条件提取

en	```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); ```
zh-hans	```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>

en	Extracts the element `x` with key equivalent to `k`, if it exists and `f(x)` is `true`.
zh-hans	若键与 `k` 等价的元素 `x` 存在且 `f(x)` 为 `true`，则提取该元素。

en	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.
zh-hans	返回值：;; 存储被提取元素的 `node_type` 对象，若未提取任何元素则为空。 异常：;; 仅当 `hasher`、`key_equal` 或 `f` 抛出异常时才会抛出异常。 注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时，`template<class k="">` 重载才参与重载决议。标准库假定 `Hash` 可同时接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机制支持异构查找，避免了实例化 `Key` 类型对象的开销。</class>

en	---

en	clear
zh-hans	清空

en	```c++ void clear() noexcept; ```

en	Erases all elements in the table.
zh-hans	删除表中的所有元素。

en	Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * bucket_count()` Concurrency:;; Blocking on `*this`.
zh-hans	后置条件：;; `size() == 0`，`max_load() >= max_load_factor() * bucket_count()` 并发：;; 阻塞 `*this`。

en	---

en	merge
zh-hans	合并

en	```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); ```
zh-hans	```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>

en	Move-inserts all the elements from `source` whose key is not already present in `*this`, and erases them from `source`.
zh-hans	将 `source` 中所有键尚未存在于 `*this` 内的元素移动插入，并从 `source` 中删除这些元素。

en	Returns:;; The number of elements inserted. Concurrency:;; Blocking on `*this` and `source`.
zh-hans	返回值：;; 插入的元素数量。 并发：;; 阻塞 `*this` 和 `source`。

en	---

en	Observers
zh-hans	观察器

en	get_allocator

en	``` allocator_type get_allocator() const noexcept; ```

en	Returns:;; The table's allocator.
zh-hans	返回值：;; 表的分配器。

en	---

en	hash_function
zh-hans	哈希函数

en	``` hasher hash_function() const; ```

en	Returns:;; The table's hash function.
zh-hans	返回值：;; 表的哈希函数。

en	---

en	key_eq

en	``` key_equal key_eq() const; ```

en	Returns:;; The table's key equality predicate.
zh-hans	返回值：;; 表的键相等性断言。

en	---

en	Set Operations
zh-hans	集合操作

en	count

en	```c++ size_type count(const key_type& k) const; template<class K> size_type count(const K& k) const; ```
zh-hans	```c++ size_type count(const key_type&amp; k) const; template<class k=""> size_type count(const K&amp; k) const; ```</class>

en	Returns:;; The number of elements with key equivalent to `k` (0 or 1). 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. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
zh-hans	返回值：;; 键与 `k` 等价的元素数量（0 或 1）。 注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时，`template<class k="">` 重载才参与重载决议。标准库假定 `Hash` 可同时接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机制支持异构查找，避免了实例化 `Key` 类型对象的开销。 注意：;; 若存在并发插入操作，返回值可能无法精确反映执行后表的真实状态。</class>

en	---

en	contains
zh-hans	包含

en	```c++ bool contains(const key_type& k) const; template<class K> bool contains(const K& k) const; ```
zh-hans	```c++ bool contains(const key_type&amp; k) const; template<class k=""> bool contains(const K&amp; k) const; ```</class>

en	Returns:;; A boolean indicating whether or not there is an element with key equal to `k` in the table. 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. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
zh-hans	返回值：;; 布尔值，表示表中是否存在键等于 `k` 的元素。 注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时，`template<class k="">` 重载才参与重载决议。标准库假定 `Hash` 可同时接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机制支持异构查找，避免了实例化 `Key` 类型对象的开销。 注意：;; 若存在并发插入操作，返回值可能无法精确反映执行后表的真实状态。</class>

en	---

en	Bucket Interface
zh-hans	桶接口

en	bucket_count

en	```c++ size_type bucket_count() const noexcept; ```

en	Returns:;; The size of the bucket array.
zh-hans	返回值：;; 桶数组的大小。

en	---

en	Hash Policy
zh-hans	哈希策略

en	load_factor
zh-hans	负载因子

en	```c++ float load_factor() const noexcept; ```

en	Returns:;; `static_cast<float>(size())/static_cast<float>(bucket_count())`, or `0` if `bucket_count() == 0`.
zh-hans	返回值：;; `static_cast<float>(size())/static_cast<float>(bucket_count())`，若 `bucket_count() == 0` 则返回 `0`。</float></float>

en	---

en	max_load_factor

en	```c++ float max_load_factor() const noexcept; ```

en	Returns:;; Returns the table's maximum load factor.
zh-hans	返回值：;; 表的最大负载因子。

en	---

en	Set max_load_factor
zh-hans	设置最大负载因子

en	```c++ void max_load_factor(float z); ```

en	Effects:;; Does nothing, as the user is not allowed to change this parameter. Kept for compatibility with `boost::unordered_set`.
zh-hans	效果：;; 不执行任何操作，因为不允许用户修改此参数。保留该函数是为了与 `boost::unordered_set` 保持兼容。

en	---

en	max_load
zh-hans	max++_++load（最大负载）

en	```c++ size_type max_load() const noexcept; ```

en	Returns:;; The maximum number of elements the table can hold without rehashing, assuming that no further elements will be erased. Note:;; After construction, rehash or clearance, the table's maximum load is at least `max_load_factor() * bucket_count()`. This number may decrease on erasure under high-load conditions. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
zh-hans	返回值：;; 表在不进行重哈希的情况下可容纳的最大元素数量（假定不会再删除任何元素）。 注意：;; 构造、重哈希或清空后，表的最大负载量至少为 `max_load_factor() * bucket_count()`。在高负载条件下执行删除操作时，该数值可能会降低。 注意：;; 若存在并发插入操作，返回值可能无法精确反映执行后表的真实状态。

en	---

en	rehash
zh-hans	重哈希

en	```c++ void rehash(size_type n); ```

en	Changes if necessary the size of the bucket array so that there are at least `n` buckets, and so that the load factor is less than or equal to the maximum load factor. When applicable, this will either grow or shrink the `bucket_count()` associated with the table.
zh-hans	效果：;; 必要时调整桶数组大小，确保桶数量至少为 `n`，且负载因子小于等于最大负载因子。适用时，会增大或缩小表关联的桶数量 `bucket_count()`。

en	When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array.
zh-hans	效果：;; 当 `size() == 0` 时，调用 `rehash(0)` 会释放底层桶数组的内存。

en	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`. ---
zh-hans	如有必要，将改变桶数组的大小，使其至少包含 `n` 个桶，并确保负载因子小于或等于最大负载因子。此操作将根据情况增加或减少容器的 `bucket++_++count()` 。

en	reserve
zh-hans	保留

en	```c++ void reserve(size_type n); ```

en	Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`.
zh-hans	效果：;; 等价于 `a.rehash(ceil(n / a.max_load_factor()))`。

en	Similar to `rehash`, this function can be used to grow or shrink the number of buckets in the table.
zh-hans	效果：;; 与 `rehash` 功能类似，该函数可用于增大或缩小表中的桶数量。

en	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`.
zh-hans	抛出异常：;; 若抛出异常，函数无任何效果（由表的哈希函数或比较函数抛出的异常除外）。 并发：;; 阻塞 `*this`。

en	---

en	Statistics
zh-hans	统计信息

en	get_stats

en	```c++ stats get_stats() const; ```

en	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_node_set_boost_unordered_enable_stats[enabled].
zh-hans	返回值：;; 截至目前，由该表执行的插入与查找操作的统计信息描述。 注意：;; 仅当**统计计算功能启用**时可用。

en	---

en	reset_stats

en	```c++ void reset_stats() noexcept; ```

en	Effects:;; Sets to zero the internal statistics kept by the table. Notes:;; Only available if xref:reference/stats.adoc#stats[statistics calculation] is xref:concurrent_node_set_boost_unordered_enable_stats[enabled].
zh-hans	效果：;; 将该哈希表所维护的内部统计数据清零。 注意：;; 仅当xref:reference/stats.adoc#stats[statistics calculation]（统计计算功能）被xref:concurrent_node_set_boost_unordered_enable_stats[enabled]（启用状态）激活时，本函数才可使用。

en	---

en	Deduction Guides
zh-hans	推导指引

en	A deduction guide will not participate in overload resolution if any of the following are true:
zh-hans	如果以下任何一条件为真，则推导指引将不参与重载决议：

en	- It has an `InputIterator` template parameter and a type that does not qualify as an input iterator is deduced for that parameter. - It has an `Allocator` template parameter and a type that does not qualify as an allocator is deduced for that parameter. - It has a `Hash` template parameter and an integral type or a type that qualifies as an allocator is deduced for that parameter. - It has a `Pred` template parameter and a type that qualifies as an allocator is deduced for that parameter.
zh-hans	- 该推导指引包含 `InputIterator` 模板参数，且为此参数推导出的类型不符合输入迭代器的要求。 - 该推导指引包含 `Allocator` 模板参数，且为该参数推导出的类型不符合分配器要求。 - 该推导指引包含 `Hash` 模板参数，且为该参数推导出的类型为整型或符合分配器要求。 - 该推导指引包含 `Pred` 模板参数，且为该参数推导出的类型符合分配器要求。

en	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.
zh-hans	推导指引中的 `size++_++type` 参数类型，指向由该推导指引所推导容器类型的 `size++_++type` 成员类型。其默认值与所选构造函数的默认值一致。

en	__iter-value-type__
zh-hans	_iter-value-type_

en	Equality Comparisons
zh-hans	相等性比较

en	operator

en	```c++ template<class Key, class Hash, class Pred, class Alloc> bool operator==(const concurrent_node_set<Key, Hash, Pred, Alloc>& x, const concurrent_node_set<Key, Hash, Pred, Alloc>& y); ```
zh-hans	```c++ template<class key,="" class="" hash,="" pred,="" alloc=""> bool operator==(const concurrent_node_set<key, hash,="" pred,="" alloc="">&amp; x, const concurrent_node_set<key, hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>

en	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).
zh-hans	返回值：;; 当且仅当 `x.size() == y.size()`，且对于 `x` 中的每个元素，`y` 中都存在一个拥有相同键、值相等（使用 `operator==` 比较值类型）的元素时，返回 `true`。

en	Concurrency:;; Blocking on `x` and `y`. Notes:;; Behavior is undefined if the two tables don't have equivalent equality predicates.
zh-hans	并发：;; 对 `x` 和 `y` 进行阻塞操作。 注意：;; 若两个哈希表的相等性断言不匹配，则行为未定义。

en	---

en	operator!

en	```c++ template<class Key, class Hash, class Pred, class Alloc> bool operator!=(const concurrent_node_set<Key, Hash, Pred, Alloc>& x, const concurrent_node_set<Key, Hash, Pred, Alloc>& y); ```
zh-hans	```c++ template<class key,="" class="" hash,="" pred,="" alloc=""> bool operator!=(const concurrent_node_set<key, hash,="" pred,="" alloc="">&amp; x, const concurrent_node_set<key, hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>

en	Returns `false` 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).
zh-hans	返回值：;; 当 `x.size() == y.size()` 且对于 `x` 中的每个元素，`y` 中都存在一个拥有相同键、值相等（使用 `operator==` 比较值类型）的元素时，返回 `false`。

en	Concurrency:;; Blocking on `x` and `y`. Notes:;; Behavior is undefined if the two tables don't have equivalent equality predicates.
zh-hans	并发：;; 对 `x` 和 `y` 执行阻塞操作。 注意：;; 若两个哈希表不具备等价的相等性断言，则行为未定义。

en	---

en	Swap
zh-hans	交换

en	```c++ template<class Key, class Hash, class Pred, class Alloc> void swap(concurrent_node_set<Key, Hash, Pred, Alloc>& x, concurrent_node_set<Key, Hash, Pred, Alloc>& y) noexcept(noexcept(x.swap(y))); ```
zh-hans	```c++ template<class key,="" class="" hash,="" pred,="" alloc=""> void swap(concurrent_node_set<key, hash,="" pred,="" alloc="">&amp; x, concurrent_node_set<key, hash,="" pred,="" alloc="">&amp; y) noexcept(noexcept(x.swap(y))); ```</key,></key,></class>

en	Equivalent to [listing,subs="+macros,+quotes"]
zh-hans	等价于 [listing,subs="+macros,+quotes"]

en	---

en	erase_if

en	```c++ template<class K, class H, class P, class A, class Predicate> typename concurrent_node_set<K, H, P, A>::size_type erase_if(concurrent_node_set<K, H, P, A>& c, Predicate pred); ```
zh-hans	```c++ template<class k,="" class="" h,="" p,="" a,="" predicate=""> typename concurrent_node_set<k, h,="" p,="" a="">::size_type erase_if(concurrent_node_set<k, h,="" p,="" a="">&amp; c, Predicate pred); ```</k,></k,></class>

en	Equivalent to [listing,subs="+macros,+quotes"]
zh-hans	等价于 [listing,subs="+macros,+quotes"]

en	Serialization
zh-hans	序列化

en	``concurrent_node_set``s can be archived/retrieved by means of link:../../../../../serialization/index.html[Boost.Serialization^] using the API provided by this library. Both regular and XML archives are supported.
zh-hans	`concurrent++_++node++_++set` 可通过本组件库提供的 API，借助 link:../../../../../serialization/index.html[Boost.Serialization] 进行归档/检索。支持常规归档与 XML 归档两种格式。

en	Saving an concurrent_node_set to an archive
zh-hans	将 concurrent++_++node++_++set 保存到归档

en	Saves all the elements of a `concurrent_node_set` `x` to an archive (XML archive) `ar`.
zh-hans	将 `concurrent++_++node++_++set` `x` 的所有元素保存至归档（XML 归档） `ar` 。

en	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`.
zh-hans	要求;; `value++_++type` 必须可序列化（支持 XML 序列化），且需要支持 Boost.Serialization 的 `save++_++construct++_++data` / `load++_++construct++_++data` 协议（该协议自动支持满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求的类型）。 并发性;; 阻塞于 `x` 。

en	---

en	Loading an concurrent_node_set from an archive
zh-hans	从归档加载 concurrent++_++node++_++set

en	Deletes all preexisting elements of a `concurrent_node_set` `x` and inserts from an archive (XML archive) `ar` restored copies of the elements of the original `concurrent_node_set` `other` saved to the storage read by `ar`.
zh-hans	删除 `concurrent++_++node++_++set` 容器 `x` 中所有已存在的元素，并从归档（XML 归档） `ar` 中插入原始 `concurrent++_++node++_++set` 容器 `other` 的元素副本，这些副本是从 `ar` 所读取的存储中恢复的。

en	Requires:;; `x.key_equal()` is functionally equivalent to `other.key_equal()`. Concurrency:;; Blocking on `x`.
zh-hans	要求;; `x.key++_++equal()` 需要在功能上等价于 `other.key++_++equal()` 。 并发性;; 阻塞于 `x` 。