[#concurrent_flat_set]
类模板 concurrent++_++flat++_++set
:idprefix: concurrent_flat_set_
`boost::concurrent++_++flat++_++set` —— 一种存储唯一值的哈希表，它支持并发的元素插入、删除、查找及访问操作，且无需外部同步机制。
尽管 `boost::concurrent++_++flat++_++set` 具备容器特性，但它并不符合 C{plus}{plus}标准中的 https://en.cppreference.com/w/cpp/named_req/Container[容器] 概念。具体而言，该容器未提供迭代器及相关操作（如 `begin` 、 `end` 等）。元素访问通过用户提供的__访问函数__实现，这些函数被传递至 `concurrent++_++flat++_++set` 操作中，并在其内部以受控方式执行。这种基于访问机制的 API 设计能够有效支持低争用的并发应用场景。
`boost::concurrent++_++flat++_++set` 的内部数据结构类似于 `boost::unordered++_++flat++_++set` 。由于其采用开放寻址技术， `value++_++type` 必须满足可移动构造要求，且在重哈希过程中无法保持指针稳定性。
概要
---
描述
*模板参数*
_键_
Key 必须满足
https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入] 到容器中的要求，且需满足从容器中 https://en.cppreference.com/w/cpp/named_req/Erasable[可擦除] 的要求。
_Hash_
一种为`Key`提供哈希功能的一元函数对象类型。它接受单个`Key`类型参数，并返回`std::size_t`类型的值。
_Pred_
一种二元函数对象，用于在Key类型的值上构建等价关系。它接受两个Key类型的参数，并返回一个bool类型的值。
_Allocator_
值类型与该表的值类型相同的分配器。
`std::allocator_traits::pointer` 与 `std::allocator_traits::const_pointer` 必须分别可与 `value_type*` 和 `const value_type*` 相互转换。
容器的元素存储在内部的桶数组中。元素根据其哈希值被插入到对应的桶中，若该桶已被占用（即发生哈希冲突），则使用原位置附近的可用桶。
调用 `insert`/`emplace` 或执行 `rehash`/`reserve` 操作时，桶数组的大小会自动扩容。容器的负载因子（元素数量除以桶数量）永远不会超过 `max_load_factor()`，仅在尺寸较小时，实现可能允许更高的负载因子。
若 `link:../../../../../container_hash/doc/html/hash.html#ref_hash_is_avalanchinghash[hash_is_avalanching]::value` 为 `true`，则哈希函数直接使用；否则会添加一个位混合后处理阶段，以额外的计算开销为代价提升哈希质量。
---
并发要求与保证
要求对同一 `Hash` 或 `Pred` 常量实例并发调用 `operator()` 时不得引入数据竞争。对于 `Alloc` （即 `Allocator` 或其重绑定后的任意分配器类型），在同一实例 `al` 上并发调用以下操作时不得引入数据竞争：
通过从`Alloc`重新绑定的分配器以`al`进行拷贝构造
`std::allocator_traits::allocate`
`std::allocator_traits::deallocate`
`std::allocator_traits::construct`
`std::allocator_traits::destroy`
通常而言，若 `Hash` 、 `Pred` 和 `Allocator` 这些类型不包含状态，或其操作仅涉及对内部数据成员的常量访问，即可满足上述要求。
除析构操作外，对同一个 `concurrent++_++flat++_++set` 实例并发调用任何操作都不会引发数据竞争——即这些操作是线程安全的。
若操作 *op* 显式指定为__阻塞于__ 容器 `x` （其中 `x` 是 `boost::concurrent++_++flat++_++set` 的实例），则先前对 `x` 的阻塞操作将与 *op* 同步。因此，在多线程场景下，对同一 `concurrent++_++flat++_++set` 的阻塞操作将按顺序执行。
若某个操作仅在触发内部重哈希时才会阻塞于 _`x`_，则称该操作__阻塞于 _`x`_ 的重哈希过程__。
当由 `boost::concurrent++_++flat++_++set` 内部执行时，用户提供的访问函数对传入元素的以下操作不会引发数据竞争：
对元素的读取访问。
对元素的非可变修改。
对元素的可变修改：
** 在容器接受两个访问函数的操作中，此条件始终适用于第一个访问函数。 ** 在名称不包含 `cvisit` 的非常量容器函数中，此条件适用于最后一个（或唯一一个）访问函数。
任何插入或修改元素 `e` 的 `boost::concurrent++_++flat++_++set` 操作都会与在 `e` 的内部调用的访问函数同步。
由 `boost::concurrent++_++flat++_++set` `x` 执行的访问函数不允许调用 `x` 上的任何操作；若并发未完成操作不直接或间接访问 `x` ，则允许调用不同 `boost::concurrent++_++flat++_++set` 实例 `y` 上的操作。
---
配置宏
`BOOST++_++UNORDERED++_++DISABLE++_++REENTRANCY++_++CHECK`
在调试版本中（更准确地说，当未定义 link:../../../../../assert/doc/html/assert.html#boost_assert_is_void[`BOOST++_++ASSERT++_++IS++_++VOID`] 时），系统会检测__容器重入__行为（即在访问 `m` 元素的函数内部非法调用 `m` 上的操作），并通过 `BOOST++_++ASSERT++_++MSG` 发出信号。若需关注运行时速度，可通过全局定义此宏来禁用该功能。
---
`BOOST_UNORDERED_ENABLE_STATS`
全局定义此宏以启用容器的 xref:reference/stats.adoc#stats[统计计算] 功能。请注意，此选项会降低多数操作的总体性能。
---
常量
```cpp static constexpr size_type bulk_visit_size; ```
xref:concurrent_flat_set_bulk_visit[批量访问]操作内部使用的块大小。
构造函数
默认构造函数
```c++ concurrent_flat_set(); ```
构造一个空容器，使用`hasher()`作为哈希函数，`key_equal()`作为键相等谓词，`allocator_type()`作为分配器。
后置条件：`size() == 0` 要求：若使用默认参数，则 `hasher`、`key_equal` 和 `allocator_type` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。
---
桶数构造函数
```c++ explicit concurrent_flat_set(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); ```
构造一个拥有至少`n`个桶的空容器，使用`hf`作为哈希函数，`eql`作为键相等谓词，`a`作为分配器。
后置条件：`size() == 0` \n要求：若使用默认参数，则 `hasher`、`key_equal` 和 `allocator_type` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。
---
迭代器范围构造函数
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等性谓词、 `a` 作为分配器，并将 `++[++f, l)` 范围内的元素插入其中。
要求;; 若使用默认值，则 `hasher` 、 `key++_++equal` 和 `allocator++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。
---
复制构造函数
```c++ concurrent_flat_set(concurrent_flat_set const& other); ```
拷贝构造函数。拷贝容器内的元素、哈希函数、相等谓词及分配器。
若`Allocator::select_on_container_copy_construction`存在且签名正确，则分配器将根据其返回值构造。
要求：`value_type` 可复制构造。并发：阻塞 `other`。
---
移动构造函数
```c++ concurrent_flat_set(concurrent_flat_set&& other); ```
移动构造函数。`other` 的内部桶数组将直接转移至新容器。哈希函数、谓词及分配器均从 `other` 移动构造。若统计功能已通过 xref:concurrent_flat_set_boost_unordered_enable_stats[启用]，则从 `other` 转移内部统计信息并调用 `other.reset_stats()`。
并发说明：;; 对 `other` 产生阻塞
---
带分配器的迭代器范围构造函数
```c++ template concurrent_flat_set(InputIterator f, InputIterator l, const allocator_type& a); ```
构造一个以`a`为分配器、使用默认哈希函数与键相等谓词的空容器，并将`[f, l)`范围内的元素插入其中。
要求：`hasher`、`key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。
---
分配器构造函数
```c++ explicit concurrent_flat_set(Allocator const& a); ```
构造一个使用分配器`a`的空容器。
---
带分配器的复制构造函数
```c++ concurrent_flat_set(concurrent_flat_set const& other, Allocator const& a); ```
构造一个容器，复制 `other` 中的元素、哈希函数和谓词，但使用分配器 `a`。
并发说明：;; 对 `other` 产生阻塞
---
带分配器的移动构造函数
```c++ concurrent_flat_set(concurrent_flat_set&& other, Allocator const& a); ```
若`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()`。
并发说明：;; 对 `other` 产生阻塞
---
从 unordered++_++flat++_++set 的移动构造函数
```c++ concurrent_flat_set(unordered_flat_set<key, hash,=\"\" pred,=\"\" allocator=\"\">&& other); ```</key,>
通过 xref:#unordered_flat_set[`unordered_flat_set`] 移动构造。`other` 的内部桶数组直接转移至新容器。哈希函数、谓词及分配器均从 `other` 移动构造。若统计功能已通过 xref:concurrent_flat_set_boost_unordered_enable_stats[enabled]，则从 `other` 转移内部统计信息并调用 `other.reset_stats()`。
Complexity:;; O(`bucket_count()`)
---
初始化列表构造函数
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等性谓词、 `a` 作为分配器，并 `il` 中的元素插入其中。
要求;; 若使用默认值，则 `hasher` 、 `key++_++equal` 和 `allocator++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。
---
带分配器的桶数构造函数
```c++ concurrent_flat_set(size_type n, allocator_type const& a); ```
构造一个至少包含 `n` 个桶的空容器，以 `hf` 作为哈希函数，使用默认键相等谓词，并以 `a` 作为分配器。
后置条件：`size() == 0` 要求：`hasher` 和 `key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。
---
带哈希函数和分配器的桶数构造函数
```c++ concurrent_flat_set(size_type n, hasher const& hf, allocator_type const& a); ```
构造一个至少包含 `n` 个桶的空容器，以 `hf` 作为哈希函数，使用默认键相等谓词，并以 `a` 作为分配器。
后置条件：`size() == 0` 要求：`key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。
---
带桶数和分配器的迭代器范围构造函数
构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器以及默认的哈希函数和键相等性谓词，并将 `++[++f, l)` 范围内的元素插入其中。
要求;; `hasher` 和 `key++_++equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。
---
带桶数和哈希函数的迭代器范围构造函数
构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `a` 作为分配器以及默认的键相等性谓词，并将 `++[++f, l)` 范围内的元素插入其中。
要求;; `key++_++equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。
---
带分配器的初始化列表构造函数
```c++ concurrent_flat_set(std::initializer_list il, const allocator_type& a); ```
构造一个使用分配器`a`、默认哈希函数和键相等谓词的空容器，并将`il`中的元素插入其中。
要求：`hasher` 和 `key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。
---
带桶数和分配器的初始化列表构造函数
```c++ concurrent_flat_set(std::initializer_list il, size_type n, const allocator_type& a); ```
构造一个至少包含 `n` 个桶的空容器，使用分配器 `a` 以及默认哈希函数和键相等谓词，并将 `il` 中的元素插入其中。
要求：`hasher` 和 `key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。
---
带桶数、哈希函数和分配器的初始化列表构造函数
```c++ concurrent_flat_set(std::initializer_list il, size_type n, const hasher& hf, const allocator_type& a); ```
构造一个至少包含 `n` 个桶的空容器，以 `hf` 作为哈希函数、`a` 作为分配器，使用默认键相等谓词，并将 `il` 中的元素插入其中。
要求：`key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。
---
析构函数
```c++ ~concurrent_flat_set(); ```
注意：;; 析构函数会作用于所有元素，且所有内存都会被释放
---
赋值操作
复制赋值
```c++ concurrent_flat_set& operator=(concurrent_flat_set const& other); ```
赋值运算符。销毁先前已存在的元素，从 `other` 拷贝赋值哈希函数和谓词；若 `Alloc::propagate_on_container_copy_assignment` 存在且其值为 `true`，则从 `other` 拷贝赋值分配器；最后插入 `other` 元素的副本。
要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可复制插入^] 要求。并发：阻塞 `*this` 和 `other`。
---
移动赋值
```c++ concurrent_flat_set& operator=(concurrent_flat_set&& other) noexcept(boost::allocator_traits::is_always_equal::value || boost::allocator_traits::propagate_on_container_move_assignment::value); ```\n移动赋值运算符。销毁先前已存在的元素，交换当前对象与 other 的哈希函数和谓词；若 Alloc::propagate_on_container_move_assignment 存在且其值为 true，则从 other 移动赋值分配器。若此时分配器与 other.get_allocator() 相等，other 的内部桶数组将直接转移给 *this；否则，插入由 other 元素移动构造的副本。若统计功能已通过 xref:concurrent_flat_set_boost_unordered_enable_stats [enabled]，仅当最终分配器与 other.get_allocator() 相等时，从 other 转移内部统计信息，且始终调用 other.reset_stats()。
并发特性：;; 阻塞 `*this` 与 `other`
---
初始化列表赋值
```c++ concurrent_flat_set& operator=(std::initializer_list il); ```
通过初始化列表中的值进行赋值。先前存在的所有元素都会被销毁。
前置要求：;; `value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^]\n并发特性：;; 阻塞 `*this`
---
访问操作
[c]visit
```c++ template<class f=\"\"> size_t visit(const key_type& k, F f); template<class f=\"\"> size_t visit(const key_type& k, F f) const; template<class f=\"\"> size_t cvisit(const key_type& k, F f) const; template<class k,=\"\" class=\"\" f=\"\"> size_t visit(const K& k, F f); template<class k,=\"\" class=\"\" f=\"\"> size_t visit(const K& k, F f) const; template<class k,=\"\" class=\"\" f=\"\"> size_t cvisit(const K& k, F f) const; ```</class></class></class></class></class></class>
若存在键与 `k` 等价的元素 `x`，则以指向 `x` 的常量引用调用函数 `f`。
返回值：;; 访问到的元素数量（0 或 1）。\n注意：;; 仅当 `Hash::is_transparent` 与 `Pred::is_transparent` 为合法成员别名时，`template<class k,=\"\" class=\"\" f=\"\">` 重载版本才会参与重载决议。库假定 `Hash` 可同时接收 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这支持异构查找，避免了实例化 `Key` 类型对象的开销。</class>
---
批量访问
```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>
对范围 `[first, last)` 中的每个元素 `k`，若容器中存在键与 `k` 等价的元素 `x`，则以指向 `x` 的常量引用调用函数 `f`。
尽管功能上等同于对每个键单独调用 `[c]visit`，但得益于内部的流式优化，批量访问通常性能更高。建议当 `std::distance(first,last)` 至少达到 `bulk_visit_size` 时使用批量访问以获得性能提升；超过该大小后，性能不会进一步提升。
前置要求：;; `FwdIterator` 是一个传统前向迭代器（C++11 至 C++17），或满足 `std::forward_iterator` 要求（C++20 及更高版本）。\n对于 `K = std::iterator_traits::value_type`，要么 `K` 是 `key_type`，要么 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员别名。\n在后一种情况下，库假定 `Hash` 可同时接收 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这支持异构查找，避免了实例化 `Key` 类型对象的开销。\n返回值：;; 访问到的元素数量。
---
[c]visit_all
```c++ template size_t visit_all(F f); template size_t visit_all(F f) const; template size_t cvisit_all(F f) const; ```
依次以指向哈希表中每个元素的常量引用调用函数 `f`。
返回值：;; 访问到的元素总数。
---
并行 [c]visit_all
```c++ template<class executionpolicy,=\"\" class=\"\" f=\"\"> void visit_all(ExecutionPolicy&& policy, F f); template<class executionpolicy,=\"\" class=\"\" f=\"\"> void visit_all(ExecutionPolicy&& policy, F f) const; template<class executionpolicy,=\"\" class=\"\" f=\"\"> void cvisit_all(ExecutionPolicy&& policy, F f) const; ```</class></class></class>
以指向哈希表中每个元素的常量引用调用函数 `f`。执行过程会根据指定执行策略的语义进行并行化。
抛出异常：;; 根据所使用执行策略的异常处理机制，若 `f` 内部抛出异常，则可能调用 `std::terminate`。\n注意：;; 仅在支持 C++17 并行算法的编译器中可用。\n仅当 `std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>>` 为 `true` 时，这些重载版本才会参与重载决议。\n不允许使用无序执行策略。</std::remove_cvref_t<executionpolicy>
---
[c]visit_while
```c++ template bool visit_while(F f); template bool visit_while(F f) const; template bool cvisit_while(F f) const; ```
依次以指向哈希表中每个元素的常量引用调用函数 `f`，直到 `f` 返回 `false` 或遍历完所有元素。
返回值：;; 当且仅当 `f` 返回过 `false` 时，返回 `false`。
---
并行 ++[++c++]++visit++_++while
```c++ template<class executionpolicy,=\"\" class=\"\" f=\"\"> bool visit_while(ExecutionPolicy&& policy, F f); template<class executionpolicy,=\"\" class=\"\" f=\"\"> bool visit_while(ExecutionPolicy&& policy, F f) const; template<class executionpolicy,=\"\" class=\"\" f=\"\"> bool cvisit_while(ExecutionPolicy&& policy, F f) const; ```</class></class></class>
以指向哈希表中每个元素的常量引用调用函数 `f`，直到 `f` 返回 `false` 或遍历完所有元素。执行过程会根据指定执行策略的语义进行并行化。
返回值：;; 当且仅当 `f` 返回过 `false` 时，返回 `false`。\n抛出异常：;; 根据所使用执行策略的异常处理机制，若 `f` 内部抛出异常，则可能调用 `std::terminate`。\n注意：;; 仅在支持 C++17 并行算法的编译器中可用。\n仅当 `std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>>` 为 `true` 时，这些重载版本才会参与重载决议。\n不允许使用无序执行策略。\n并行化意味着执行流程不会在 `f` 返回 `false` 时立即终止，因此 `f` 可能还会被后续元素调用并同样返回 `false`。</std::remove_cvref_t<executionpolicy>
---
大小与容量
空
```c++ [[nodiscard]] bool empty() const noexcept; ```
返回值：;; `size() == 0`
---
大小
```c++ size_type size() const noexcept; ```
返回值：;; 哈希表中的元素总数。
注意：;; 在存在并发插入操作时，返回的值可能无法准确反映函数执行后哈希表的真实大小。
---
max_size
```c++ size_type max_size() const noexcept; ```
返回值：;; 哈希表能容纳的最大元素数量（最大容量）。
---
修改器
原地构造
```c++ template bool emplace(Args&&... args); ```
当且仅当哈希表中不存在等价键的元素时，才会使用参数 `args` 构造对象并插入到哈希表中。
前置要求：;; `value_type` 可由参数 `args` 构造。\n返回值：;; 成功插入元素时返回 `true`。\n并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。\n注意：;; 若执行重哈希，将使指向元素的指针和引用失效。
---
复制插入
```c++ bool insert(const value_type& obj); ```
当且仅当哈希表中不存在等价键的元素时，才将 `obj` 插入到哈希表中。
前置要求：;; `value_type` 满足可复制插入要求。\n返回值：;; 成功插入元素时返回 `true`。\n并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。\n注意：;; 若执行重哈希，将使指向元素的指针和引用失效。
---
移动插入
```c++ bool insert(value_type&& obj); ```
当且仅当哈希表中不存在等价键的元素时，才将 `obj` 插入到哈希表中。
前置要求：;; `value_type` 满足可移动插入要求。\n返回值：;; 成功插入元素时返回 `true`。\n并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。\n注意：;; 若执行重哈希，将使指向元素的指针和引用失效。
---
透明插入
```c++ template bool insert(K&& k); ```
当且仅当容器中不存在等价键的元素时，才会使用 `std::forward(k)` 构造元素并插入到容器中。
前置要求：;; `value_type` 可通过 `k` 原位构造。\n返回值：;; 成功插入元素时返回 `true`。\n并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。\n注意：;; 若执行重哈希，将使指向元素的指针和引用失效。\n仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员别名时，该重载版本才参与重载决议。\n库假定 `Hash` 可同时接收 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这支持异构查找，避免实例化 `Key` 类型对象的开销。
---
迭代器范围插入
```c++ template size_type insert(InputIterator first, InputIterator last); ```
等效于 [listing,subs=\"+macros,+quotes\"]
返回值：;; 成功插入的元素数量。
---
初始化列表插入
```c++ size_type insert(std::initializer_list il); ```
等效于 [listing,subs=\"+macros,+quotes\"]
返回值：;; 成功插入的元素数量。
---
emplace_or_[c]visit
```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); ```</class...></class...>
若哈希表中不存在等价键的元素，则使用参数 `args` 构造对象并插入表中；否则，以等价元素的常量引用为参数调用函数 `f`。
前置要求：;; `value_type` 可由参数 `args` 构造。\n返回值：;; 成功插入元素时返回 `true`。\n并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。\n注意：;; 若执行重哈希，将使指向元素的指针和引用失效。\n该接口仅为说明性设计，因为 C++ 不允许在可变参数包之后声明参数 `f`。
---
复制 insert++_++or++_[++c++]++visit
```c++ template bool insert_or_visit(const value_type& obj, F f); template bool insert_or_cvisit(const value_type& obj, F f); ```
当且仅当哈希表中不存在等价键的元素时，才将 `obj` 插入表中；否则，以等价元素的常量引用为参数调用函数 `f`。
前置要求：;; `value_type` 满足可复制插入要求。\n返回值：;; 成功插入元素时返回 `true`。\n并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。\n注意：;; 若执行重哈希，将使指向元素的指针和引用失效。
---
移动 insert++_++or++_[++c++]++visit
```c++ template bool insert_or_visit(value_type&& obj, F f); template bool insert_or_cvisit(value_type&& obj, F f); ```
当且仅当哈希表中不存在等价键的元素时，才将 `obj` 插入表中；否则，以等价元素的常量引用为参数调用函数 `f`。
前置要求：;; `value_type` 满足可移动插入要求。\n返回值：;; 成功插入元素时返回 `true`。\n并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。\n注意：;; 若执行重哈希，将使指向元素的指针和引用失效。
---
透明 insert++_++or++_[++c++]++visit
```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); ```</class></class>
当且仅当容器中不存在等价键的元素时，才会使用 `std::forward(k)` 构造元素并插入容器；否则，以等价元素的常量引用为参数调用函数 `f`。
前置要求：;; `value_type` 可通过 `k` 原位构造。\n返回值：;; 成功插入元素时返回 `true`。\n并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。\n注意：;; 若执行重哈希，将使指向元素的指针和引用失效。\n仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员别名时，该组重载才参与重载决议。\n库假定 `Hash` 可同时接收 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这支持异构查找，避免实例化 `Key` 类型对象的开销。
---
迭代器范围插入或访问
```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>
等效于 [listing,subs=\"+macros,+quotes\"]
返回值：;; 成功插入的元素数量。
---
初始化列表插入或访问
```c++ template size_type insert_or_visit(std::initializer_list il, F f); template size_type insert_or_cvisit(std::initializer_list il, F f); ```
等效于 [listing,subs=\"+macros,+quotes\"]
返回值：;; 成功插入的元素数量。
---
emplace_and_[c]visit
```c++ template<class... args,=\"\" class=\"\" f1,=\"\" f2=\"\"> bool emplace_and_visit(Args&&... args, F1&& f1, F2&& f2); template<class... args,=\"\" class=\"\" f1,=\"\" f2=\"\"> bool emplace_and_cvisit(Args&&... args, F1&& f1, F2&& f2); ```</class...></class...>
若哈希表中不存在等价键的元素，则使用参数 `args` 构造对象并插入表中，随后以新创建元素的常量引用为参数调用函数 `f1`；否则，以等价元素的常量引用为参数调用函数 `f2`。
前置要求：;; `value_type` 可由参数 `args` 构造。\n返回值：;; 成功插入元素时返回 `true`。\n并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。\n注意：;; 若执行重哈希，将使指向元素的指针和引用失效。\n该接口仅为说明性设计，因为 C++ 不允许在可变参数包之后声明参数 `f1` 和 `f2`。
---
复制 insert++_++and++_[++c++]++visit
```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 f1, F2 f2); ```</class></class>
当且仅当哈希表中不存在等价键的元素时，将 `obj` 插入表中，随后以新创建元素的常量引用为参数调用函数 `f1`；否则，以等价元素的常量引用为参数调用函数 `f2`。
前置要求：;; `value_type` 满足可复制插入要求。\n返回值：;; 成功插入元素时返回 `true`。\n并发特性：;; 若触发重哈希，则会阻塞当前对象 `*this`。\n注意：;; 若执行重哈希，将使指向元素的指针和引用失效。
---
移动 insert++_++and++_[++c++]++visit
```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); ```</class></class>
当且仅当表中不存在键等价的元素时，将`obj`插入表中，随后使用新建元素的常量引用调用`f1`；否则使用等价元素的常量引用调用`f2`。
要求：;; `value_type` 满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]。\n返回值：;; 执行插入操作则返回 `true`。\n并发特性：;; 对 `*this` 执行重哈希时会阻塞。\n备注：;; 执行重哈希后，指向元素的指针和引用将会失效。
---
透明 insert++_++and++_[++c++]++visit（透明插入并 ++[++c++]++ 访问）
```c++ template<class k,=\"\" class=\"\" f1,=\"\" f2=\"\"> bool insert_and_visit(K&& k, F1 f1, F2 f2); template<class k,=\"\" class=\"\" f1,=\"\" f2=\"\"> bool insert_and_cvisit(K&& k, F1 f1, F2 f2); ```</class></class>
当且仅当容器中不存在键等价的元素时，将通过`std::forward(k)`构造的元素插入容器，随后使用新建元素的常量引用调用`f1`；否则使用等价元素的常量引用调用`f2`。
要求：;; `value_type` 可由 `k` 进行 https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] 构造。\n返回值：;; 执行插入操作则返回 `true`。\n并发特性：;; 对 `*this` 执行重哈希时会阻塞。\n备注：;; 执行重哈希后，指向元素的指针和引用将会失效。\n\n这些重载仅当 `Hash::is_transparent` 与 `Pred::is_transparent` 为合法成员类型别名时才参与重载决议。标准库假定 `Hash` 可同时接受 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这实现了异构查找，避免了实例化 `Key` 类型对象的开销。
---
迭代器范围插入并访问
```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>
等效于 [listing,subs=\"+macros,+quotes\"]
返回值：;; 插入的元素数量。
---
初始化列表插入并访问
```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>
等效于 [listing,subs=\"+macros,+quotes\"]
返回值：;; 插入的元素数量。
---
擦除
```c++ size_type erase(const key_type& k); template size_type erase(const K& k); ```
若存在键与`k`等价的元素，则将其删除。
返回值：;; 删除的元素数量（0 或 1）。\n抛出：;; 仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出异常。\n备注：;; `template` 重载仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时才参与重载决议。标准库假定 `Hash` 可同时接受 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这实现了异构查找，避免了实例化 `Key` 类型对象的开销。
---
通过键进行条件擦除
```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); ```</class></class>
若键与`k`等价的元素存在且`f(x)`为`true`，则删除该元素`x`。
返回值：;; 删除的元素数量（0 或 1）。\n抛出：;; 仅当 `hasher`、`key_equal` 或 `f` 抛出异常时才会抛出异常。\n备注：;; 仅当 `std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>>` 为 `false` 时，`template<class k,=\"\" class=\"\" f=\"\">` 重载才参与重载决议。\n\n仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时，`template<class k,=\"\" class=\"\" f=\"\">` 重载才参与重载决议。标准库假定 `Hash` 可同时接受 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这实现了异构查找，避免了实例化 `Key` 类型对象的开销。</class></class></std::remove_cvref_t<executionpolicy>
---
erase++_++if
```c++ template size_type erase_if(F f); ```
依次以表中每个元素的引用调用`f`，并删除`f`返回`true`的元素。
返回值：;; 删除的元素数量。\n抛出：;; 仅当 `f` 抛出异常时才会抛出异常。
---
并行条件擦除
```c++ template<class executionpolicy,=\"\" class=\"\" f=\"\"> void erase_if(ExecutionPolicy&& policy, F f); ```</class>
以表中每个元素的引用调用`f`，并删除`f`返回`true`的元素。执行过程将根据指定执行策略的语义进行并行化。
抛出：;; 根据所使用执行策略的异常处理机制，若`f`内抛出异常，则可能调用`std::terminate`。\n备注：;; 仅在支持C++17并行算法的编译器中可用。\n\n该重载仅当`std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>>`为`true`时才参与重载决议。\n\n不允许使用无顺序执行策略。</std::remove_cvref_t<executionpolicy>
---
交换
```c++ void swap(concurrent_flat_set& other) noexcept(boost::allocator_traits::is_always_equal::value || boost::allocator_traits::propagate_on_container_swap::value); ```
交换当前表与参数表的内容。
若`Allocator::propagate_on_container_swap`已声明且`Allocator::propagate_on_container_swap::value`为`true`，则交换两个表的分配器。否则，使用不相等的分配器进行交换会导致未定义行为。
抛出：;; 除非`key_equal`或`hasher`在交换时抛出异常，否则不抛出任何异常。\n并发：;; 阻塞`*this`和`other`。
---
清空
```c++ void clear() noexcept; ```
清空表中的所有元素。
后置条件：;; `size() == 0`，`max_load() >= max_load_factor() * bucket_count()`\n并发：;; 阻塞`*this`。
---
合并
```c++ template<class h2,=\"\" class=\"\" p2=\"\"> size_type merge(concurrent_flat_set<key, h2,=\"\" p2,=\"\" allocator=\"\">& source); template<class h2,=\"\" class=\"\" p2=\"\"> size_type merge(concurrent_flat_set<key, h2,=\"\" p2,=\"\" allocator=\"\">&& source); ```</key,></class></key,></class>
将`source`中所有键尚未存在于`*this`中的元素移动插入，并从`source`中删除这些元素。
返回值：;; 插入的元素数量。\n并发：;; 阻塞`*this`和`source`。
---
观察器
get_allocator
``` allocator_type get_allocator() const noexcept; ```
返回值：;; 表的分配器。
---
哈希函数
``` hasher hash_function() const; ```
返回值：;; 表的哈希函数。
---
key_eq
``` key_equal key_eq() const; ```
返回值：;; 表的键相等性断言。
---
集合操作
count
```c++ size_type \u0020 \u0020 \u0020 \u0020count(const key_type& k) const; template size_type \u0020 \u0020 \u0020count(const K& k) const; ```
返回值：;; 键与`k`等价的元素数量（0 或 1）。\n备注：;; `template` 重载仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时才参与重载决议。标准库假定 `Hash` 可同时接受 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这实现了异构查找，避免了实例化 `Key` 类型对象的开销。\n\n在存在并发插入操作时，返回的值可能无法准确反映执行后表的真实状态。
---
包含
```c++ bool \u0020 \u0020 \u0020 \u0020 \u0020 \u0020 contains(const key_type& k) const; template bool \u0020 \u0020 \u0020 \u0020 \u0020 contains(const K& k) const; ```
返回值：;; 布尔值，表示表中是否存在键与`k`相等的元素。\n备注：;; `template` 重载仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时才参与重载决议。标准库假定 `Hash` 可同时接受 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这实现了异构查找，避免了实例化 `Key` 类型对象的开销。\n在存在并发插入操作时，返回的值可能无法准确反映执行后表的真实状态。
---
桶接口
bucket_count
```c++ size_type bucket_count() const noexcept; ```
返回值：;; 哈希桶数组的大小。
---
哈希策略
负载因子
```c++ float load_factor() const noexcept; ```
返回值：;; `static_cast(size()) / static_cast(bucket_count())`；若`bucket_count() == 0`，则返回`0`。
---
max_load_factor
```c++ float max_load_factor() const noexcept; ```
返回值：;; 返回哈希表的最大负载因子。
---
设置最大负载因子
```c++ void max_load_factor(float z); ```
效果：;; 不执行任何操作，因为不允许用户修改此参数。保留该函数是为了与 `boost::unordered_set` 保持兼容。
---
max_load（最大负载）
```c++ size_type max_load() const noexcept; ```
返回值：;; 哈希表在不进行重哈希的前提下可容纳的最大元素数量（假设不会再删除任何元素）。\n备注：;; 构造完成、重哈希或清空后，哈希表的最大负载至少为 `max_load_factor() * bucket_count()`。在高负载条件下执行删除操作后，该数值可能会降低。\n在存在并发插入操作时，返回的值可能无法准确反映执行后哈希表的真实状态。
---
重哈希
```c++ void rehash(size_type n); ```
效果：;; 必要时调整哈希桶数组的大小，使桶数量至少为 `n`，且负载因子小于等于最大负载因子。\n适用情况下，该操作会**增大或缩小**哈希表的桶数量（`bucket_count()`）。
当 `size() == 0` 时，`rehash(0)` 会释放底层的哈希桶数组内存。
会使指向元素的指针和引用失效，并改变元素的存储顺序。
抛出：;; 若抛出异常，函数无任何效果（哈希函数或比较函数抛出的异常除外）。\n并发：;; 阻塞`*this`。\n---
保留
```c++ void reserve(size_type n); ```
等价于 `a.rehash(ceil(n / a.max_load_factor()))`。
与 `rehash` 功能类似，该函数可用于**增加或减少**哈希表中的桶数量。
会使指向元素的指针和引用失效，并改变元素的存储顺序。
抛出：;; 若抛出异常，函数不会产生任何效果（哈希表的哈希函数或比较函数抛出的异常除外）。\n并发：;; 阻塞`*this`。
---
统计信息
get_stats
```c++ stats get_stats() const; ```
返回值：;; 该哈希表迄今为止执行的插入与查找操作的统计信息。\n备注：;; 仅当 xref:reference/stats.adoc#stats[统计计算] 被 xref:concurrent_flat_set_boost_unordered_enable_stats[启用] 时，本接口方可使用。
---
reset_stats
```c++ void reset_stats() noexcept; ```
效果：;; 将哈希表内部统计数据置零。\n备注：;; 仅当 xref:reference/stats.adoc#stats[统计计算] 被 xref:concurrent_flat_set_boost_unordered_enable_stats[启用] 时，本接口方可使用。
---
推导指引
如果以下任何一条件为真，则推导指引将不参与重载决议：
- 该推导指引包含 `InputIterator` 模板参数，且为此参数推导出的类型不符合输入迭代器的要求。 - 该推导指引包含 `Allocator` 模板参数，且为该参数推导出的类型不符合分配器要求。 - 该推导指引包含 `Hash` 模板参数，且为该参数推导出的类型为整型或符合分配器要求。 - 该推导指引包含 `Pred` 模板参数，且为该参数推导出的类型符合分配器要求。
推导指引中的 `size++_++type` 参数类型，指向由该推导指引所推导容器类型的 `size++_++type` 成员类型。其默认值与所选构造函数的默认值一致。
_iter-value-type_
相等性比较
operator
```c++ template<class key,=\"\" class=\"\" hash,=\"\" pred,=\"\" alloc=\"\"> bool operator==(const concurrent_flat_set<key, hash,=\"\" pred,=\"\" alloc=\"\">& x, const concurrent_flat_set<key, hash,=\"\" pred,=\"\" alloc=\"\">& y); ```</key,></key,></class>
若 x.size() == y.size()，且对于 x 中的每个元素，y 中均存在一个具有相同键、值相等（使用 operator== 比较值类型）的元素，则返回 true。
并发：;; 对`x`和`y`进行阻塞。\n备注：;; 若两个哈希表的相等判断谓词不一致，行为未定义。
---
operator!
```c++ template<class key,=\"\" class=\"\" hash,=\"\" pred,=\"\" alloc=\"\"> bool operator!=(const concurrent_flat_set<key, hash,=\"\" pred,=\"\" alloc=\"\">& x, const concurrent_flat_set<key, hash,=\"\" pred,=\"\" alloc=\"\">& y); ```</key,></key,></class>
若 x.size() == y.size()，且对于 x 中的每个元素，y 中均存在一个具有相同键、值相等（使用 operator== 比较值类型）的元素，则返回 false。
并发：;; 阻塞`x`与`y`。\n备注：;; 若两个哈希表的相等谓词不兼容，行为未定义。
---
交换
```c++ template<class key,=\"\" class=\"\" hash,=\"\" pred,=\"\" alloc=\"\"> void swap(concurrent_flat_set<key, hash,=\"\" pred,=\"\" alloc=\"\">& x, concurrent_flat_set<key, hash,=\"\" pred,=\"\" alloc=\"\">& y) noexcept(noexcept(x.swap(y))); ```</key,></key,></class>
等价于 [listing,subs=\"+macros,+quotes\"]
---
erase_if
```c++ template<class k,=\"\" class=\"\" h,=\"\" p,=\"\" a,=\"\" predicate=\"\"> typename concurrent_flat_set<k, h,=\"\" p,=\"\" a=\"\">::size_type erase_if(concurrent_flat_set<k, h,=\"\" p,=\"\" a=\"\">& c, Predicate pred); ```</k,></k,></class>
等价于 [listing,subs=\"+macros,+quotes\"]
序列化
可通过本库提供的 API ，借助 link:../../../../../serialization/index.html[Boost.Serialization] 实现档归档/检索 `concurrent++_++flat++_++set` 。同时支持常规格式与 XML 格式的归档文件。
将 concurrent++_++flat++_++set 保存到归档
将 `concurrent++_++flat++_++set` 容器 `x` 的所有元素保存到归档（XML 归档） `ar` 中。
要求;; `value++_++type` 必须可序列化（支持 XML 序列化），且需要支持 Boost.Serialization 的 `save++_++construct++_++data` / `load++_++construct++_++data` 协议（该协议自动支持满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求的类型）。 并发性;; 阻塞于 `x` 。
---
从归档加载 concurrent++_++flat++_++set
删除 `concurrent++_++flat++_++set` 容器 `x` 中的所有现有元素，并从归档 `ar` （XML格式归档）中读取原始 `concurrent++_++flat++_++set` 容器 `other` 保存的元素副本并插入到 `x` 。
要求;; `x.key++_++equal()` 需要在功能上等价于 `other.key++_++equal()` 。 并发性;; 阻塞于 `x` 。