[#unordered_node_set]
== 类模板 unordered_node_set

:idprefix: unordered_node_set_

`boost::unordered_node_set`  — 一种基于节点的开放寻址无序关联容器，用于存储唯一值。

`boost::unordered_node_set` 使用与 `boost::unordered_flat_set` 类似的开放寻址布局，但由于其基于节点的特性，它提供了指针稳定性和节点处理功能。其性能介于 `boost::unordered_set` 和 `boost::unordered_flat_set` 之间。

由于使用开放寻址，`boost::unordered_node_set` 的接口在多个方面与 `boost::unordered_set`/`std::unordered_set` 有所不同：

- `begin()` 不是常数时间复杂度的。
- 没有用于桶操作的 API（除了 `bucket_count` 之外）。
- 容器的最大负载因子由内部管理，用户无法设置。

除此之外， `boost::unordered_node_set` 几乎可以完全替代标准无序关联容器。

=== 概要

[listing,subs="+macros,+quotes"]
-----
// #include xref:reference/header_unordered_node_set.adoc[`<boost/unordered/unordered_node_set.hpp>`]

namespace boost {
namespace unordered {

  template<class Key,
           class Hash = boost::hash<Key>,
           class Pred = std::equal_to<Key>,
           class Allocator = std::allocator<Key>>
  class unordered_node_set {
  public:
    // types
    using key_type             = Key;
    using value_type           = Key;
    using init_type            = Key;
    using hasher               = Hash;
    using key_equal            = Pred;
    using allocator_type       = Allocator;
    using pointer              = typename std::allocator_traits<Allocator>::pointer;
    using const_pointer        = typename std::allocator_traits<Allocator>::const_pointer;
    using reference            = value_type&;
    using const_reference      = const value_type&;
    using size_type            = std::size_t;
    using difference_type      = std::ptrdiff_t;

    using iterator             = _implementation-defined_;
    using const_iterator       = _implementation-defined_;

    using node_type            = _implementation-defined_;
    using insert_return_type   = _implementation-defined_;

    using stats                = xref:reference/stats.adoc#stats_stats_type[__stats-type__]; // if statistics are xref:unordered_node_set_boost_unordered_enable_stats[enabled]

    // construct/copy/destroy
    xref:#unordered_node_set_default_constructor[unordered_node_set]();
    explicit xref:#unordered_node_set_bucket_count_constructor[unordered_node_set](size_type n,
                                const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
    template<class InputIterator>
      xref:#unordered_node_set_iterator_range_constructor[unordered_node_set](InputIterator f, InputIterator l,
                         size_type n = _implementation-defined_,
                         const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& a = allocator_type());
    xref:#unordered_node_set_copy_constructor[unordered_node_set](const unordered_node_set& other);
    xref:#unordered_node_set_move_constructor[unordered_node_set](unordered_node_set&& other);
    template<class InputIterator>
      xref:#unordered_node_set_iterator_range_constructor_with_allocator[unordered_node_set](InputIterator f, InputIterator l, const allocator_type& a);
    explicit xref:#unordered_node_set_allocator_constructor[unordered_node_set](const Allocator& a);
    xref:#unordered_node_set_copy_constructor_with_allocator[unordered_node_set](const unordered_node_set& other, const Allocator& a);
    xref:#unordered_node_set_move_constructor_with_allocator[unordered_node_set](unordered_node_set&& other, const Allocator& a);
    xref:#unordered_node_set_move_constructor_from_concurrent_node_set[unordered_node_set](concurrent_node_set<Key, Hash, Pred, Allocator>&& other);
    xref:#unordered_node_set_initializer_list_constructor[unordered_node_set](std::initializer_list<value_type> il,
                       size_type n = _implementation-defined_
                       const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
    xref:#unordered_node_set_bucket_count_constructor_with_allocator[unordered_node_set](size_type n, const allocator_type& a);
    xref:#unordered_node_set_bucket_count_constructor_with_hasher_and_allocator[unordered_node_set](size_type n, const hasher& hf, const allocator_type& a);
    template<class InputIterator>
      xref:#unordered_node_set_iterator_range_constructor_with_bucket_count_and_allocator[unordered_node_set](InputIterator f, InputIterator l, size_type n, const allocator_type& a);
    template<class InputIterator>
      xref:#unordered_node_set_iterator_range_constructor_with_bucket_count_and_hasher[unordered_node_set](InputIterator f, InputIterator l, size_type n, const hasher& hf,
                         const allocator_type& a);
    xref:#unordered_node_set_initializer_list_constructor_with_allocator[unordered_node_set](std::initializer_list<value_type> il, const allocator_type& a);
    xref:#unordered_node_set_initializer_list_constructor_with_bucket_count_and_allocator[unordered_node_set](std::initializer_list<value_type> il, size_type n,
                       const allocator_type& a);
    xref:#unordered_node_set_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_node_set](std::initializer_list<value_type> il, size_type n, const hasher& hf,
                       const allocator_type& a);
    xref:#unordered_node_set_destructor[~unordered_node_set]();
    unordered_node_set& xref:#unordered_node_set_copy_assignment[operator++=++](const unordered_node_set& other);
    unordered_node_set& xref:#unordered_node_set_move_assignment[operator++=++](unordered_node_set&& other) ++noexcept(
      (boost::allocator_traits<Allocator>::is_always_equal::value ||
       boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value) &&
       std::is_same<pointer, value_type*>::value);++
    unordered_node_set& xref:#unordered_node_set_initializer_list_assignment[operator++=++](std::initializer_list<value_type>);
    allocator_type xref:#unordered_node_set_get_allocator[get_allocator]() const noexcept;

    // iterators
    iterator       xref:#unordered_node_set_begin[begin]() noexcept;
    const_iterator xref:#unordered_node_set_begin[begin]() const noexcept;
    iterator       xref:#unordered_node_set_end[end]() noexcept;
    const_iterator xref:#unordered_node_set_end[end]() const noexcept;
    const_iterator xref:#unordered_node_set_cbegin[cbegin]() const noexcept;
    const_iterator xref:#unordered_node_set_cend[cend]() const noexcept;

    // capacity
    ++[[nodiscard]]++ bool xref:#unordered_node_set_empty[empty]() const noexcept;
    size_type xref:#unordered_node_set_size[size]() const noexcept;
    size_type xref:#unordered_node_set_max_size[max_size]() const noexcept;

    // modifiers
    template<class... Args> std::pair<iterator, bool> xref:#unordered_node_set_emplace[emplace](Args&&... args);
    template<class... Args> iterator xref:#unordered_node_set_emplace_hint[emplace_hint](const_iterator position, Args&&... args);
    std::pair<iterator, bool> xref:#unordered_node_set_copy_insert[insert](const value_type& obj);
    std::pair<iterator, bool> xref:#unordered_node_set_move_insert[insert](value_type&& obj);
    template<class K> std::pair<iterator, bool> xref:#unordered_node_set_transparent_insert[insert](K&& k);
    iterator xref:#unordered_node_set_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj);
    iterator xref:#unordered_node_set_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
    template<class K> iterator xref:#unordered_node_set_transparent_insert_with_hint[insert](const_iterator hint, K&& k);
    template<class InputIterator> void xref:#unordered_node_set_insert_iterator_range[insert](InputIterator first, InputIterator last);
    void xref:#unordered_node_set_insert_initializer_list[insert](std::initializer_list<value_type>);
    insert_return_type xref:#unordered_node_set_insert_node[insert](node_type&& nh);
    iterator xref:#unordered_node_set_insert_node_with_hint[insert](const_iterator hint, node_type&& nh);

    _convertible-to-iterator_     xref:#unordered_node_set_erase_by_position[erase](iterator position);
    _convertible-to-iterator_     xref:#unordered_node_set_erase_by_position[erase](const_iterator position);
    size_type                   xref:#unordered_node_set_erase_by_key[erase](const key_type& k);
    template<class K> size_type xref:#unordered_node_set_erase_by_key[erase](K&& k);
    iterator  xref:#unordered_node_set_erase_range[erase](const_iterator first, const_iterator last);
    void      xref:#unordered_node_set_swap[swap](unordered_node_set& other)
      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
               boost::allocator_traits<Allocator>::propagate_on_container_swap::value);
    node_type xref:#unordered_node_set_extract_by_position[extract](const_iterator position);
    node_type xref:#unordered_node_set_extract_by_key[extract](const key_type& key);
    template<class K> node_type xref:#unordered_node_set_extract_by_key[extract](K&& key);
    init_type xref:#unordered_node_set_pull[pull](const_iterator position);
    void      xref:#unordered_node_set_clear[clear]() noexcept;

    template<class H2, class P2>
      void xref:#unordered_node_set_merge[merge](unordered_node_set<Key, T, H2, P2, Allocator>& source);
    template<class H2, class P2>
      void xref:#unordered_node_set_merge[merge](unordered_node_set<Key, T, H2, P2, Allocator>&& source);

    // observers
    hasher xref:#unordered_node_set_hash_function[hash_function]() const;
    key_equal xref:#unordered_node_set_key_eq[key_eq]() const;

    // set operations
    iterator         xref:#unordered_node_set_find[find](const key_type& k);
    const_iterator   xref:#unordered_node_set_find[find](const key_type& k) const;
    template<class K>
      iterator       xref:#unordered_node_set_find[find](const K& k);
    template<class K>
      const_iterator xref:#unordered_node_set_find[find](const K& k) const;
    size_type        xref:#unordered_node_set_count[count](const key_type& k) const;
    template<class K>
      size_type      xref:#unordered_node_set_count[count](const K& k) const;
    bool             xref:#unordered_node_set_contains[contains](const key_type& k) const;
    template<class K>
      bool           xref:#unordered_node_set_contains[contains](const K& k) const;
    std::pair<iterator, iterator>               xref:#unordered_node_set_equal_range[equal_range](const key_type& k);
    std::pair<const_iterator, const_iterator>   xref:#unordered_node_set_equal_range[equal_range](const key_type& k) const;
    template<class K>
      std::pair<iterator, iterator>             xref:#unordered_node_set_equal_range[equal_range](const K& k);
    template<class K>
      std::pair<const_iterator, const_iterator> xref:#unordered_node_set_equal_range[equal_range](const K& k) const;

    // bucket interface
    size_type xref:#unordered_node_set_bucket_count[bucket_count]() const noexcept;

    // hash policy
    float xref:#unordered_node_set_load_factor[load_factor]() const noexcept;
    float xref:#unordered_node_set_max_load_factor[max_load_factor]() const noexcept;
    void xref:#unordered_node_set_set_max_load_factor[max_load_factor](float z);
    size_type xref:#unordered_node_set_max_load[max_load]() const noexcept;
    void xref:#unordered_node_set_rehash[rehash](size_type n);
    void xref:#unordered_node_set_reserve[reserve](size_type n);

    // statistics (if xref:unordered_node_set_boost_unordered_enable_stats[enabled])
    stats xref:#unordered_node_set_get_stats[get_stats]() const;
    void xref:#unordered_node_set_reset_stats[reset_stats]() noexcept;
  };

  // Deduction Guides
  template<class InputIterator,
           class Hash = boost::hash<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>>,
           class Pred = std::equal_to<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>>,
           class Allocator = std::allocator<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>>>
    unordered_node_set(InputIterator, InputIterator, typename xref:#unordered_node_set_deduction_guides[__see below__]::size_type = xref:#unordered_node_set_deduction_guides[__see below__],
                       Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      -> unordered_node_set<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>, Hash, Pred, Allocator>;

  template<class T, class Hash = boost::hash<T>, class Pred = std::equal_to<T>,
           class Allocator = std::allocator<T>>
    unordered_node_set(std::initializer_list<T>, typename xref:#unordered_node_set_deduction_guides[__see below__]::size_type = xref:#unordered_node_set_deduction_guides[__see below__],
                       Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      -> unordered_node_set<T, Hash, Pred, Allocator>;

  template<class InputIterator, class Allocator>
    unordered_node_set(InputIterator, InputIterator, typename xref:#unordered_node_set_deduction_guides[__see below__]::size_type, Allocator)
      -> unordered_node_set<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>,
                            boost::hash<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>>,
                            std::equal_to<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>>, Allocator>;

  template<class InputIterator, class Allocator>
    unordered_node_set(InputIterator, InputIterator, Allocator)
      -> unordered_node_set<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>,
                            boost::hash<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>>,
                            std::equal_to<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>>, Allocator>;

  template<class InputIterator, class Hash, class Allocator>
    unordered_node_set(InputIterator, InputIterator, typename xref:#unordered_node_set_deduction_guides[__see below__]::size_type, Hash,
                       Allocator)
      -> unordered_node_set<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>, Hash,
                            std::equal_to<xref:#unordered_node_set_iter_value_type[__iter-value-type__]<InputIterator>>, Allocator>;

  template<class T, class Allocator>
    unordered_node_set(std::initializer_list<T>, typename xref:#unordered_node_set_deduction_guides[__see below__]::size_type, Allocator)
      -> unordered_node_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;

  template<class T, class Allocator>
    unordered_node_set(std::initializer_list<T>, Allocator)
      -> unordered_node_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;

  template<class T, class Hash, class Allocator>
    unordered_node_set(std::initializer_list<T>, typename xref:#unordered_node_set_deduction_guides[__see below__]::size_type, Hash, Allocator)
      -> unordered_node_set<T, Hash, std::equal_to<T>, Allocator>;

} // namespace unordered
} // namespace boost
-----

---

=== 描述

*模板参数*

[cols="1,1"]
|===

|_Key_
|`Key` must be https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from the container.

|_Hash_
|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`.

|_Pred_
|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`.

|_Allocator_
|An allocator whose value type is the same as the container's value type.
支持使用 https://en.cppreference.com/w/cpp/named_req/Allocator#Fancy_pointers[异形指针] 的分配器。

|===

容器的元素节点被保存在内部的 _桶数组_ 中。节点根据其元素的哈希码被插入到对应的桶中，但如果该桶已被占用（发生 _冲突_），则会使用原始位置附近的一个可用桶。

桶数组的大小可以通过调用 `insert`/`emplace` 自动增加，或者作为调用 `rehash`/`reserve` 的结果。容器的 _负载因子_（元素数量除以桶数量）永远不会大于 `max_load_factor()`，但在容器规模较小时，实现可能会允许更高的负载。

如果 `link:../../../../../container_hash/doc/html/hash.html#ref_hash_is_avalanching[hash_is_avalanching]<hash>::value` 为 `true`，则哈希函数将按原样使用；否则，会增加一个位混合后处理阶段，以牺牲额外的计算成本为代价来提高哈希质量。</hash>

---

=== 配置宏

==== `BOOST_UNORDERED_ENABLE_STATS`

全局定义此宏，以启用容器的 xref:reference/stats.adoc#stats[统计计算] 功能。请注意，此选项会降低许多操作的总体性能。

---

=== 类型定义

[source,c++,subs=+quotes]
----
typedef _implementation-defined_ iterator;
----

一个常量迭代器，其值类型为 `value_type` 。

迭代器类别至少为前向迭代器。

可转换为 `const_iterator` 。

---

[source,c++,subs=+quotes]
----
typedef _implementation-defined_ const_iterator;
----

一个常量迭代器，其值类型为 `value_type` 。

迭代器类别至少为前向迭代器。

---

[source,c++,subs=+quotes]
----
typedef _implementation-defined_ node_type;
----

用于保存已提取容器元素的类，其建模自 https://en.cppreference.com/w/cpp/container/node_handle[NodeHandle] 。

---

[source,c++,subs=+quotes]
----
typedef _implementation-defined_ insert_return_type;
----

内部类模板的特化：

[source,c++,subs=+quotes]
----
template<class Iterator, class NodeType>
struct _insert_return_type_ // name is exposition only
{
  Iterator position;
  bool     inserted;
  NodeType node;
};
----

其中 `Iterator` = `iterator` ，且 `NodeType` = `node_type` 。

---

=== 构造函数

==== 默认构造函数
```c++ unordered_node_set(); ```

使用 `hasher()` 作为哈希函数、`key_equal()` 作为键相等谓词以及 `allocator_type()` 作为分配器，构造一个空容器。

[horizontal]
后置条件：`size() == 0`  
要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。

---

==== 桶数构造函数
```c++ explicit unordered_node_set(size_type n, const hasher&amp; hf = hasher(), const key_equal&amp; eql = key_equal(), const allocator_type&amp; a = allocator_type()); ```

构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，`eql` 作为键相等谓词，`a` 作为分配器。

[horizontal]
后置条件：`size() == 0`  
要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。

---

==== 迭代器范围构造函数
[source,c++,subs="+quotes"]
----
template<class InputIterator>
  unordered_node_set(InputIterator f, InputIterator l,
                     size_type n = _implementation-defined_,
                     const hasher& hf = hasher(),
                     const key_equal& eql = key_equal(),
                     const allocator_type& a = allocator_type());
----

构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等性谓词、 `a` 作为分配器，并将区间 `++[++f, l)` 中的元素插入其中。

[horizontal]
要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。

---

==== 复制构造函数
```c++ unordered_node_set(unordered_node_set const&amp; other); ```

拷贝构造函数。拷贝所包含的元素、哈希函数、谓词和分配器。

如果 `Allocator::select_on_container_copy_construction` 存在且具有正确的签名，则分配器将根据其结果进行构造。

[horizontal]
要求：`value_type` 可拷贝构造

---

==== 移动构造函数
```c++ unordered_node_set(unordered_node_set&amp;&amp; other); ```

移动构造函数。`other` 的内部桶数组会被直接转移给新容器。哈希函数、谓词和分配器通过移动构造从 `other` 获得。如果启用了统计信息（详见 xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]），则会从 `other` 转移内部的统计信息，并调用 `other.reset_stats()`。

---

==== 带分配器的迭代器范围构造函数
```c++ template<class inputiterator=""> unordered_node_set(InputIterator f, InputIterator l, const allocator_type&amp; a); ```</class>

使用 `a` 作为分配器，以默认哈希函数和键相等谓词构造一个空容器，并将 `[f, l)` 范围内的元素插入其中。

[horizontal]
要求：`hasher`、`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。

---

==== 分配器构造函数
```c++ explicit unordered_node_set(Allocator const&amp; a); ```

使用分配器 `a` 构造一个空容器。

---

==== 带分配器的复制构造函数
```c++ unordered_node_set(unordered_node_set const&amp; other, Allocator const&amp; a); ```

构造一个容器，拷贝 `other` 所包含的元素、哈希函数和谓词，但使用分配器 `a`。

---

==== 带分配器的移动构造函数
```c++ unordered_node_set(unordered_node_set&amp;&amp; other, Allocator const&amp; a); ```

如果 `a == other.get_allocator()`，则 `other` 的元素节点会直接转移给新容器；否则，元素将从 `other` 中的元素通过移动构造获得。哈希函数和谓词通过移动构造从 `other` 获得，而分配器则通过拷贝构造从 `a` 获得。如果启用了统计信息（详见 xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]），则当 `a == other.get_allocator()` 时，会从 `other` 转移内部的统计信息，并且始终会调用 `other.reset_stats()`。

---

==== 从 concurrent_node_set 的移动构造函数

```c++ unordered_node_set(concurrent_node_set<key, hash,="" pred,="" allocator="">&amp;&amp; other); ```</key,>

从 xref:#concurrent_node_set[`concurrent_node_set`] 进行移动构造。`other` 的内部桶数组直接转移给新容器。哈希函数、谓词和分配器通过移动构造从 `other` 获得。如果启用了统计信息（详见 xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]），则从 `other` 转移内部的统计信息，并调用 `other.reset_stats()`。

[horizontal]
复杂度：常数时间。  
并发性：在 `other` 上阻塞。

---

==== 初始化列表构造函数
[source,c++,subs="+quotes"]
----
unordered_node_set(std::initializer_list<value_type> il,
              size_type n = _implementation-defined_
              const hasher& hf = hasher(),
              const key_equal& eql = key_equal(),
              const allocator_type& a = allocator_type());
----

构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等性谓词、以及 `a` 作为分配器，并将 `il` 中的元素插入其中。

[horizontal]
要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 必须满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。

---

==== 带分配器的桶数构造函数
```c++ unordered_node_set(size_type n, allocator_type const&amp; a); ```

构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，使用默认的哈希函数和键相等谓词，并以 `a` 作为分配器。

[horizontal]
后置条件：`size() == 0`  要求：`hasher` 和 `key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。

---

==== 带哈希函数和分配器的桶数构造函数
```c++ unordered_node_set(size_type n, hasher const&amp; hf, allocator_type const&amp; a); ```

构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，使用默认的键相等谓词，并以 `a` 作为分配器。

[horizontal]
后置条件：`size() == 0`  要求：`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。

---

==== 带桶数和分配器的迭代器范围构造函数
[source,c++,subs="+quotes"]
----
template<class InputIterator>
  unordered_node_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a);
----

构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器、以及默认的哈希函数和键相等性谓词，并将 `++[++f, l)` 范围内的元素插入其中。

[horizontal]
要求：`hasher`、`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。

---

==== 带桶数和哈希函数的迭代器范围构造函数
[source,c++,subs="+quotes"]
----
    template<class InputIterator>
      unordered_node_set(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                         const allocator_type& a);
----

构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `a` 作为分配器以及默认的键相等性谓词，并将 `[f, l)` 范围内的元素插入其中。

[horizontal]
要求;; `key++_++equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。

---

==== 带分配器的初始化列表构造函数

```c++ unordered_node_set(std::initializer_list<value_type> il, const allocator_type&amp; a); ```</value_type>

使用 `a` 以及默认的哈希函数和键相等谓词构造一个空容器，并将 `il` 中的元素插入其中。

[horizontal]
要求：`hasher` 和 `key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。

---

==== 带桶数和分配器的初始化列表构造函数

```c++ unordered_node_set(std::initializer_list<value_type> il, size_type n, const allocator_type&amp; a); ```</value_type>

使用 `a` 以及默认的哈希函数和键相等谓词，构造一个至少包含 `n` 个桶的空容器，并将 `il` 中的元素插入其中。

[horizontal]
要求：`hasher` 和 `key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。

---

==== 带桶数、哈希函数和分配器的初始化列表构造函数

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

构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，`a` 作为分配器，使用默认的键相等谓词，并将 `il` 中的元素插入其中。

[horizontal]
要求;; `key++_++equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。

---

=== 析构函数

```c++ ~unordered_node_set(); ```

[horizontal]
注意：析构函数会应用于每个元素，并且所有内存都会被释放。

---

=== 赋值操作

==== 复制赋值

```c++ unordered_node_set&amp; operator=(unordered_node_set const&amp; other); ```

赋值运算符。销毁之前存在的元素，从 `other` 拷贝赋值哈希函数和谓词，如果 `Alloc::propagate_on_container_copy_assignment` 存在且 `Alloc::propagate_on_container_copy_assignment::value` 为 `true`，则从 `other` 拷贝赋值分配器，最后插入 `other` 中元素的副本。

[horizontal]
要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^]

---

==== 移动赋值
```c++
unordered_node_set&amp; operator=(unordered_node_set&amp;&amp; other) noexcept((boost::allocator_traits<allocator>::is_always_equal::value || boost::allocator_traits<allocator>::propagate_on_container_move_assignment::value) &amp;&amp; std::is_same<pointer, value_type*="">::value);
```
移动赋值运算符。销毁之前存在的元素，交换来自 `other` 的哈希函数和谓词，并且如果 `Alloc::propagate_on_container_move_assignment` 存在且 `Alloc::propagate_on_container_move_assignment::value` 为 `true`，则从 `other` 移动赋值分配器。如果此时分配器与 `other.get_allocator()` 相等，则 `other` 的内部桶数组直接转移给当前容器；否则，插入从 `other` 元素移动构造而来的副本。如果启用了统计信息（详见 xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]），则当最终分配器与 `other.get_allocator()` 相等时，从 `other` 转移内部的统计信息，并且始终会调用 `other.reset_stats()`。</pointer,></allocator></allocator>

---

==== 初始化列表赋值
```c++ unordered_node_set&amp; operator=(std::initializer_list<value_type> il); ```</value_type>

从初始化列表中的值进行赋值。所有之前存在的元素都会被销毁。

[horizontal]
要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^]

=== 迭代器

==== begin
```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```

[horizontal]
返回：指向容器第一个元素的迭代器，如果容器为空则返回容器的尾后迭代器。  
复杂度：O(`bucket_count()`)

---

==== end
```c++ iterator end() noexcept; const_iterator end() const noexcept; ```

[horizontal]
返回：指向容器尾后值的迭代器。

---

==== cbegin
```c++ const_iterator cbegin() const noexcept; ```

[horizontal]
Returns:;; A `const_iterator` referring to the first element of the container, or if the container is empty the past-the-end value for the container. Complexity:;; O(`bucket_count()`)

---

==== cend
```c++ const_iterator cend() const noexcept; ```

[horizontal]
返回：指向容器尾后值的 `const_iterator`。

---

=== 大小与容量

==== 空

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

[horizontal]
Returns:;; `size() == 0`

---

==== 大小

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

[horizontal]
Returns:;; `std::distance(begin(), end())`

---

==== max_size

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

[horizontal]
返回：;; 可能的最大容器的 `size()`。

---

=== 修改器

==== 原地构造
```c++ template<class... args=""> std::pair<iterator, bool=""> emplace(Args&amp;&amp;... args); ```</iterator,></class...>

当且仅当容器中没有具有等价键的元素时，才插入一个使用参数 `args` 构造的对象。

[horizontal]
要求：`value_type` 可从 `args` 构造。  
返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。  
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

---

==== emplace_hint
```c++ template<class... args=""> iterator emplace_hint(const_iterator position, Args&amp;&amp;... args); ```</class...>

当且仅当容器中没有具有等价键的元素时，才插入一个使用参数 `args` 构造的对象。

`position` 是关于元素插入位置的建议。此实现会忽略该建议。

[horizontal]
要求：`value_type` 可从 `args` 构造。  
返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。  
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

---

==== 复制插入
```c++ std::pair<iterator, bool=""> insert(const value_type&amp; obj); ```</iterator,>

当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。

[horizontal]
要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^]。  
返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。  
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

---

==== 移动插入
```c++ std::pair<iterator, bool=""> insert(value_type&amp;&amp; obj); ```</iterator,>

当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。

[horizontal]
要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入^]。  
返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。  
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

---

==== 透明插入
```c++ template<class k=""> std::pair<iterator, bool=""> insert(K&amp;&amp; k); ```</iterator,></class>

当且仅当容器中没有具有等价键的元素时，才将在容器中插入一个从 `std::forward<k>(k)` 构造的元素。</k>

[horizontal]
要求：`value_type` 可以从 `k` 进行 https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。  
返回：如果发生了插入，则返回类型的 bool 分量为 true。  
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。  

只有当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时，此重载才会参与重载决议。库假定 `Hash` 可同时用 `K` 和 `Key` 调用，并且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。

---

==== 带提示的复制插入
```c++ iterator insert(const_iterator hint, const value_type&amp; obj); ```当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。

`hint` 是关于元素插入位置的建议。此实现会忽略该建议。

[horizontal]
要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^]。  
返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。  
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

---

==== 带提示的移动插入
```c++ iterator insert(const_iterator hint, value_type&amp;&amp; obj); ```

当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。

`hint` 是关于元素插入位置的建议。此实现会忽略该建议。

[horizontal]
要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入^]。  
返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。  
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

---

==== 带提示的透明插入
```c++ template<class k=""> std::pair<iterator, bool=""> insert(const_iterator hint, K&amp;&amp; k); ```</iterator,></class>

当且仅当容器中没有具有等价键的元素时，才将在容器中插入一个从 `std::forward<k>(k)` 构造的元素。</k>

`hint` 是关于元素插入位置的建议。此实现会忽略该建议。

[horizontal]
要求：`value_type` 可以从 `k` 进行 https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。  
返回：如果发生了插入，则返回类型的 bool 分量为 true。  
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。  

只有当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时，此重载才会参与重载决议。库假定 `Hash` 可同时用 `K` 和 `Key` 调用，并且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。

---

==== 迭代器范围插入
```c++ template<class inputiterator=""> void insert(InputIterator first, InputIterator last); ```</class>

将一个范围内的元素插入容器中。当且仅当容器中没有具有等价键的元素时，才会插入这些元素。

[horizontal]
要求：`value_type` 可以从 `*first` 出发在容器中进行 https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。  
抛出：当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

---

==== 初始化列表插入
```c++ void insert(std::initializer_list<value_type>); ```</value_type>

将一个范围内的元素插入容器中。当且仅当容器中没有具有等价键的元素时，才会插入这些元素。

[horizontal]
要求：`value_type` 可以在容器中进行 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可拷贝插入^]。  
抛出：当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

---

==== 节点插入
```c++ insert_return_type insert(node_type&amp;&amp; nh); ```

如果 `nh` 非空，则当且仅当容器中没有键与 `nh.value()` 等价的元素时，才将关联的元素插入容器。函数返回时 `nh` 变为空。

[horizontal]
返回：一个 `insert_return_type` 对象，由 `position`、`inserted` 和 `node` 构造而成：
* 若 `nh` 为空，则 `inserted` 为 `false` ， `position` 为 `end()` ，且 `node` 为空。
* 否则，若插入操作发生，则 `inserted` 为 `true` ， `position` 指向被插入的元素，且 `node` 为空。
* 若插入操作失败，则 `inserted` 为 `false` ， `node` 保留 `nh` 的原始值，且 `position` 指向一个键等价于 `nh.value()` 的元素。
如果 `nh` 非空，则当且仅当容器中不存在键等价于 `nh.value()` 的元素时，插入其关联的元素。函数返回时， `nh` 为空。

---

==== 带提示的节点插入
```c++ iterator insert(const_iterator hint, node_type&amp;&amp; nh); ```

如果 `nh` 非空，则当且仅当容器中没有键与 `nh.value()` 等价的元素时，才将关联的元素插入容器。如果插入发生，则 `nh` 变为空；否则 `nh` 不变。

`hint` 是关于元素插入位置的建议。此实现会忽略该建议。

[horizontal]
返回：如果 `nh` 为空，则返回的迭代器为 `end()`。如果插入发生，则迭代器指向新插入的元素；否则，指向具有等价键的元素。  
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  
注意：如果 `nh` 非空且 `nh` 与容器的分配器不相等，则行为未定义。

---

==== 通过位置擦除

[source,c++,subs=+quotes]
----
_convertible-to-iterator_ erase(iterator position);
_convertible-to-iterator_ erase(const_iterator position);
----

擦除由 `position` 指向的元素。

[horizontal]
返回;; 返回一个不透明对象，该对象可隐式转换为擦除前紧接在 `position` 之后的 `iterator` 或 `const++_++iterator` 。 抛出;; 无。 注意;; 返回的不透明对象必须被立即丢弃或转换为 `iterator` 或 `const++_++iterator` 。

---

==== 通过键擦除
```c++ size_type erase(const key_type&amp; k); template<class k=""> size_type erase(K&amp;&amp; k); ```</class>

擦除所有键与 `k` 等价的元素。

[horizontal]
返回：被擦除的元素数量。  
抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。  
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时，才参与重载决议。库假定 `Hash` 可同时用 `K` 和 `Key` 调用，并且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>

---

==== 范围擦除

```c++ iterator erase(const_iterator first, const_iterator last); ```

擦除从 `first` 到 `last` 范围内的元素。

[horizontal]
返回：被擦除元素之后的迭代器——即 `last`。  
抛出：在此实现中不抛出任何异常（既不调用 `hasher` 也不调用 `key_equal` 对象）。

---

==== 交换
```c++ void swap(unordered_node_set&amp; other) noexcept(boost::allocator_traits<allocator>::is_always_equal::value || boost::allocator_traits<allocator>::propagate_on_container_swap::value); ```</allocator></allocator>

交换容器的内容与参数的内容。

如果 `Allocator::propagate_on_container_swap` 被声明且 `Allocator::propagate_on_container_swap::value` 为 `true`，则交换容器的分配器。否则，使用不相等的分配器进行交换将导致未定义行为。

[horizontal]
抛出：除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。

---

==== 通过位置提取
```c++ node_type extract(const_iterator position); ```

提取 `position` 所指向的元素。

[horizontal]
返回：一个持有被提取元素的 `node_type` 对象。  
抛出：不抛出任何异常。

---

==== 通过键提取
```c++ node_type extract(const key_type&amp; k); template<class k=""> node_type extract(K&amp;&amp; k); ```</class>

提取键与 `k` 等价的元素（如果存在）。

[horizontal]
返回：一个持有被提取元素的 `node_type` 对象；如果未提取到任何元素，则返回空。  
抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。  
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时才参与重载决议。库假定 `Hash` 可同时用 `K` 和 `Key` 调用，并且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>

---

==== pull
```c++ init_type pull(const_iterator position); ```

从 `position` 指向的元素移动构造一个 `init_value` 对象 `x`，擦除该元素并返回 `x`。

---

==== 清空
```c++ void clear() noexcept; ```

擦除容器中的所有元素。

[horizontal]
后置条件：`size() == 0`，`max_load() &gt;= max_load_factor() * bucket_count()`

---

==== 合并
```c++ template<class h2,="" class="" p2=""> void merge(unordered_node_set<key, t,="" h2,="" p2,="" allocator="">&amp; source); template<class h2,="" class="" p2=""> void merge(unordered_node_set<key, t,="" h2,="" p2,="" allocator="">&amp;&amp; source); ```</key,></class></key,></class>

从 `source` 转移所有键在 `*this` 中尚未存在的元素节点。

[horizontal]
要求：`this-&gt;get_allocator() == source.get_allocator()`。  
注意：会使被转移元素的迭代器失效。如果 `*this` 的结果大小大于其原始最大负载，则会使与 `*this` 关联的所有迭代器失效。

---

=== 观察器

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

[horizontal]
返回：容器的分配器。

---

==== 哈希函数
```cpp
hasher hash_function() const;
```

[horizontal]
返回：容器的哈希函数对象。

---

==== key_eq
``` key_equal key_eq() const; ```

[horizontal]
返回：容器的键相等谓词。

---

=== 查找

==== find
```c++ iterator         find(const key_type&amp; k); const_iterator   find(const key_type&amp; k) const; template<class k=""> iterator       find(const K&amp; k);</class>

```

[horizontal]
返回：指向键与 `k` 等价的元素的迭代器；如果不存在这样的元素，则返回 `end()`。  
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>

---

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

[horizontal]
返回：键与 `k` 等价的元素数量。  
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>

---

==== 包含
```c++ bool             contains(const key_type&amp; k) const; template<class k=""> bool           contains(const K&amp; k) const; ```</class>

[horizontal]
返回：一个布尔值，指示容器中是否存在键等于 `key` 的元素。  
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>

---

==== equal_range
```c++ std::pair<iterator, iterator="">               equal_range(const key_type&amp; k); std::pair<const_iterator, const_iterator="">   equal_range(const key_type&amp; k) const; template<class k=""> std::pair<iterator, iterator="">             equal_range(const K&amp; k); template<class k=""> std::pair<const_iterator, const_iterator=""> equal_range(const K&amp; k) const; ```</const_iterator,></class></iterator,></class></const_iterator,></iterator,>

[horizontal]
返回：包含所有键与 `k` 等价的元素的范围。如果容器不包含任何此类元素，则返回 `std::make_pair(b.end(), b.end())`。  
注意：`template<class k="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>

---

=== 桶接口

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

[horizontal]
返回：桶数组的大小。

---

=== 哈希策略

==== 负载因子
```c++ float load_factor() const noexcept; ```

[horizontal]
返回：`static_cast<float>(size())/static_cast<float>(bucket_count())`，如果 `bucket_count() == 0` 则返回 `0`。</float></float>

---

==== max_load_factor

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

[horizontal]
返回：容器的最大负载因子。

---

==== 设置最大负载因子
```c++ void max_load_factor(float z); ```

[horizontal]
效果：不执行任何操作，因为用户不允许更改此参数。保留此函数是为了与 `boost::unordered_set` 保持兼容。

---


==== max_load

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

[horizontal]
返回：容器在不触发重哈希的情况下能够容纳的最大元素数量（假设不再有元素被擦除）。  
注意：在构造、重哈希或清空操作之后，容器的最大负载至少为 `max_load_factor() * bucket_count()`。在高负载条件下，该数值可能会因元素擦除而减小。

---

==== 重哈希
```c++ void rehash(size_type n); ```

必要时更改桶数组的大小，使其至少包含 `n` 个桶，并且使得负载因子小于或等于最大负载因子。在适用的情况下，这将增大或缩小与容器关联的 `bucket_count()`。

当 `size() == 0` 时，`rehash(0)` 将释放底层的桶数组。如果提供的分配器使用异形指针，则会随后执行一次默认分配。

使迭代器失效并改变元素的顺序。

[horizontal]
抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果。

---

==== 保留
```c++ void reserve(size_type n); ```

等价于 `a.rehash(ceil(n / a.max_load_factor()))`。

与 `rehash` 类似，此函数可用于增大或缩小容器中的桶数量。

使迭代器失效并改变元素的顺序。

[horizontal]
抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果。

---

=== 统计信息

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

[horizontal]
返回：容器迄今为止所执行插入和查找操作的统计描述。  
注意：仅在 xref:reference/stats.adoc#stats[统计计算] 通过 xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`] 启用时才可用。

---

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

[horizontal]
效果：将容器内部维护的统计信息归零。  
注意：仅在 xref:reference/stats.adoc#stats[统计计算] 通过 xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`] 启用时才可用。

---

=== 推导指引
如果以下任何一条件为真，则推导指引将不参与重载决议：

- 它具有一个 `InputIterator` 模板参数，并且为该参数推导出的类型不符合输入迭代器的要求。
- 它具有一个 `Allocator` 模板参数，并且为该参数推导出的类型不符合分配器的要求。
- 它具有一个 `Hash` 模板参数，并且为该参数推导出的类型是整数类型或符合分配器的要求。
- 它具有一个 `Pred` 模板参数，并且为该参数推导出的类型符合分配器的要求。

推导指引中的 `size_type` 参数类型指的是由该推导指引所推导出的容器类型的 `size_type` 成员类型。其默认值与所选构造函数的默认值一致。

==== _iter-value-type_
[listings,subs="+macros,+quotes"]
-----
template<class InputIterator>
  using __iter-value-type__ =
    typename std::iterator_traits<InputIterator>::value_type; // exposition only
-----

=== 相等性比较

==== operator
```c++ template<class key,="" class="" t,="" hash,="" pred,="" alloc=""> bool operator==(const unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; x, const unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>

若 `x.size() == y.size()` 且对于 `x` 中的每个元素，在 `y` 中均存在一个具有相同键且值相等（使用 `operator==` 比较值类型）的元素，则返回 `true`。

[horizontal]
注意：如果两个容器不具有等价的相等谓词，则行为未定义。

---

==== operator!
```c++ template<class key,="" class="" t,="" hash,="" pred,="" alloc=""> bool operator!=(const unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; x, const unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>

若 `x.size() == y.size()` 且对于 `x` 中的每个元素，在 `y` 中均存在一个具有相同键且值相等（使用 `operator==` 比较值类型）的元素，则返回 `false`。

[horizontal]
注意：如果两个容器不具有等价的相等谓词，则行为未定义。

=== 交换
```c++ template<class key,="" class="" t,="" hash,="" pred,="" alloc=""> void swap(unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; x, unordered_node_set<key, t,="" hash,="" pred,="" alloc="">&amp; y) noexcept(noexcept(x.swap(y))); ```</key,></key,></class>

交换 `x` 和 `y` 的内容。

如果 `Allocator::propagate_on_container_swap` 被声明且 `Allocator::propagate_on_container_swap::value` 为 `true`，则交换容器的分配器。否则，使用不相等的分配器进行交换将导致未定义行为。

[horizontal]
效果：`x.swap(y)`  
抛出：除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。

---

=== erase_if
```c++ template<class k,="" class="" t,="" h,="" p,="" a,="" predicate=""> typename unordered_node_set<k, t,="" h,="" p,="" a="">::size_type erase_if(unordered_node_set<k, t,="" h,="" p,="" a="">&amp; c, Predicate pred); ```</k,></k,></class>

遍历容器 `c`，并移除所有使给定谓词返回 `true` 的元素。

[horizontal]
返回：被擦除的元素数量。  
注意：等价于：  
```c++
auto original_size = c.size();
for (auto i = c.begin(), last = c.end(); i != last; ) {
    if (pred(*i)) {
        i = c.erase(i);
    } else {
        ++i;
    }
}
return original_size - c.size();
```

=== 序列化

`unordered++_++node++_++set` 可通过本组件库提供的 API，借助 link:../../../../../serialization/index.html[Boost.Serialization] 进行归档/检索。支持常规归档与 XML 归档两种格式。

==== 将 `unordered_node_set` 保存到归档中

将 `unordered_node_set` 容器 `x` 的所有元素保存到归档（XML 归档）`ar` 中。

[horizontal]
要求：`value_type` 必须是可序列化的（对于 XML 归档需支持 XML 序列化），并且支持 Boost.Serialization 的 `save_construct_data`/`load_construct_data` 协议（该协议由满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 的类型自动支持）。

---

==== 从归档中加载 `unordered_node_set`

删除 `unordered_node_set` 容器 `x` 中所有已存在的元素，并从归档（XML 归档）`ar` 中插入从原始 `unordered_node_set` 容器 `other` 保存到 `ar` 所读取存储中的元素恢复出的副本。

[horizontal]
要求;; `value++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入] 要求，且 `x.key++_++equal()` 在功能上需等价于 `other.key++_++equal()` 。

---

==== 将迭代器/常量迭代器保存到归档

将迭代器（或常量迭代器）`it` 的位置信息保存到归档（XML 归档）`ar` 中。`it` 可以是一个 `end()` 迭代器。

[horizontal]
要求：`it` 所指向的 `unordered_node_set` 容器 `x` 必须先被保存到 `ar` 中，并且在保存 `x` 和保存 `it` 之间，不能对 `x` 执行任何修改操作。

---

==== 从归档加载迭代器/常量迭代器

使迭代器（或常量迭代器）`it` 指向原始迭代器（或常量迭代器）被保存到归档（XML 归档）`ar` 所读取存储中的位置恢复后的位置。

[horizontal]
要求：如果 `x` 是 `it` 所指向的 `unordered_node_set` 容器，则在加载 `x` 和加载 `it` 之间，不能对 `x` 执行任何修改操作。
