Boost C++ 库

splay_multiset();

效果：构造一个空容器。

复杂度：常数时间。

抛出：如果 value_traits::node_traits::node 构造函数抛出异常（这在使用预定义的 Boost.Intrusive 钩子时不会发生）或 key_compare 对象的复制构造函数抛出异常。基本保证。

explicit splay_multiset(const key_compare & cmp, 
                        const value_traits & v_traits = value_traits());

template<typename Iterator> 
  splay_multiset(Iterator b, Iterator e, 
                 const key_compare & cmp = key_compare(), 
                 const value_traits & v_traits = value_traits());

splay_multiset(splay_multiset && x);

效果：构造一个容器，从另一个容器移动资源。内部比较对象和值特征进行移动构造，并且属于 x 的节点（除了代表“末尾”的节点）链接到 *this。

复杂度：常数时间。

抛出：如果 value_traits::node_traits::node 的移动构造函数抛出异常（这在使用预定义的 Boost.Intrusive 钩子时不会发生）或比较对象的移动构造函数抛出异常。

splay_multiset & operator=(splay_multiset && x);

效果：等同于 swap

~splay_multiset();

效果：从 *this 分离所有元素。集合中的对象不会被删除（即不调用析构函数），但根据 value_traits 模板参数的节点将被重新初始化，因此可以重用。

复杂度：与 *this 中包含的元素数量成线性关系。

抛出：无。

iterator begin() noexcept;

效果：返回一个指向容器开头的迭代器。

复杂度：常数时间。

抛出：无。

const_iterator begin() const noexcept;

效果：返回一个指向容器开头的 const_iterator。

复杂度：常数时间。

抛出：无。

const_iterator cbegin() const noexcept;

效果：返回一个指向容器开头的 const_iterator。

复杂度：常数时间。

抛出：无。

iterator end() noexcept;

效果：返回一个指向容器末尾的迭代器。

复杂度：常数时间。

抛出：无。

const_iterator end() const noexcept;

效果：返回一个指向容器末尾的 const_iterator。

复杂度：常数时间。

抛出：无。

const_iterator cend() const noexcept;

效果：返回一个指向容器末尾的 const_iterator。

复杂度：常数时间。

抛出：无。

reverse_iterator rbegin() noexcept;

效果：返回一个指向反向容器开头的 reverse_iterator。

复杂度：常数时间。

抛出：无。

const_reverse_iterator rbegin() const noexcept;

效果：返回一个指向反向容器开头的 const_reverse_iterator。

复杂度：常数时间。

抛出：无。

const_reverse_iterator crbegin() const noexcept;

效果：返回一个指向反向容器开头的 const_reverse_iterator。

复杂度：常数时间。

抛出：无。

reverse_iterator rend() noexcept;

效果：返回一个指向反向容器末尾的 reverse_iterator。

复杂度：常数时间。

抛出：无。

const_reverse_iterator rend() const noexcept;

效果：返回一个指向反向容器末尾的 const_reverse_iterator。

复杂度：常数时间。

抛出：无。

const_reverse_iterator crend() const noexcept;

效果：返回一个指向反向容器末尾的 const_reverse_iterator。

复杂度：常数时间。

抛出：无。

iterator root() noexcept;

效果：返回一个指向容器根节点的迭代器，如果不存在则返回 end()。

复杂度：常数时间。

抛出：无。

const_iterator root() const noexcept;

效果：返回一个指向容器根节点的 const_iterator，如果不存在则返回 cend()。

复杂度：常数时间。

抛出：无。

const_iterator croot() const noexcept;

效果：返回一个指向容器根节点的 const_iterator，如果不存在则返回 cend()。

复杂度：常数时间。

抛出：无。

key_compare key_comp() const;

效果：返回容器使用的 key_compare 对象。

复杂度：常数时间。

抛出：如果 key_compare 复制构造函数抛出异常。

value_compare value_comp() const;

效果：返回容器使用的 value_compare 对象。

复杂度：常数时间。

抛出：如果 value_compare 复制构造函数抛出异常。

bool empty() const noexcept;

效果：如果容器为空，则返回 true。

复杂度：常数时间。

抛出：无。

size_type size() const noexcept;

效果：返回容器中存储的元素数量。

复杂度：如果禁用常数时间大小选项，则与 *this 中包含的元素数量成线性关系。否则为常数时间。

抛出：无。

void swap(splay_multiset & other);

效果：交换两个容器的内容。

复杂度：常数时间。

抛出：如果比较仿函数的 swap 调用抛出异常。

template<typename Cloner, typename Disposer> 
  void clone_from(const splay_multiset & src, Cloner cloner, 
                  Disposer disposer);

要求：Disposer::operator()(pointer) 不应抛出异常。Cloner 应该产生等同于原始节点的节点。

效果：从 *this 中擦除所有元素，调用 Disposer::operator()(pointer)，从 src 中克隆所有元素，调用 Cloner::operator()(const_reference )，并将它们插入到 *this 中。复制源容器的谓词。

如果 cloner 抛出异常，则所有克隆的元素都将被取消链接并调用 Disposer::operator()(pointer) 进行处理。

复杂度：与擦除的元素加上插入的元素数量成线性关系。

抛出：如果 cloner 抛出异常或谓词复制赋值抛出异常。基本保证。附加说明：它还会复制源容器的 alpha 因子。

template<typename Cloner, typename Disposer> 
  void clone_from(splay_multiset && src, Cloner cloner, Disposer disposer);

要求：Disposer::operator()(pointer) 不应抛出异常。Cloner 应该产生等同于原始节点的节点。

效果：从 *this 中擦除所有元素，调用 Disposer::operator()(pointer)，从 src 中克隆所有元素，调用 Cloner::operator()(reference)，并将它们插入到 *this 中。复制源容器的谓词。

如果 cloner 抛出异常，则所有克隆的元素都将被取消链接并调用 Disposer::operator()(pointer) 进行处理。

复杂度：与擦除的元素加上插入的元素数量成线性关系。

抛出：如果 cloner 抛出异常或谓词复制赋值抛出异常。基本保证。

注意：此版本可以修改源容器，用于实现移动语义。

iterator insert(reference value);

iterator insert(const_iterator hint, reference value);

template<typename Iterator> void insert(Iterator b, Iterator e);

要求：解引用迭代器必须产生 value_type 类型的左值。

效果：将范围内的每个元素插入到容器中，插入位置在每个元素键的上限之前。

复杂度：插入范围通常为 O(N * log(N))，其中 N 是范围的大小。但是，如果范围已经按 value_comp() 排序，则复杂度为线性 O(N)。

抛出：如果比较仿函数调用抛出异常。

注意：不影响迭代器和引用的有效性。不调用复制构造函数。

iterator insert_before(const_iterator pos, reference value) noexcept;

要求：value 必须是左值，“pos” 必须是有效的迭代器（或 end），并且必须是根据谓词插入后 value 的后继者

效果：将 x 插入到容器中的 “pos” 之前。

复杂度：常数时间。

抛出：无。

注意：此函数不检查先决条件，因此如果 “pos” 不是 “value” 的后继者，则容器排序不变量将被破坏。这是一个低级函数，仅供高级用户出于性能原因使用。

void push_back(reference value) noexcept;

要求：value 必须是左值，并且必须不小于最大的已插入键

效果：将 x 插入到容器的最后一个位置。

复杂度：常数时间。

抛出：无。

注意：此函数不检查先决条件，因此如果 value 小于最大的已插入键，则容器排序不变量将被破坏。此函数比使用 “insert_before” 稍微有效率。这是一个低级函数，仅供高级用户出于性能原因使用。

void push_front(reference value) noexcept;

要求：value 必须是左值，并且必须不大于最小的已插入键

效果：将 x 插入到容器的第一个位置。

复杂度：常数时间。

抛出：无。

注意：此函数不检查先决条件，因此如果 value 大于最小的已插入键，则容器排序不变量将被破坏。此函数比使用 “insert_before” 稍微有效率。这是一个低级函数，仅供高级用户出于性能原因使用。

iterator erase(const_iterator i) noexcept;

iterator erase(const_iterator b, const_iterator e) noexcept;

size_type erase(const key_type & key);

template<typename KeyType, typename KeyTypeKeyCompare> 
  size_type erase(const KeyType & key, KeyTypeKeyCompare comp);

要求：key 是一个值，使得 *this 相对于 comp(nk, key) 和 !comp(key, nk) 进行分区，其中 comp(nk, key) 意味着 !comp(key, nk)，nk 是插入到 *this 中的 value_type 的 key_type。

效果：根据比较仿函数 “comp”，擦除所有具有给定键的元素。

返回：擦除的元素数量。

复杂度：O(log(size() + N))。

抛出：无。

注意：使指向已擦除元素的迭代器（但不是引用）无效。不调用析构函数。

template<typename Disposer> 
  iterator erase_and_dispose(const_iterator i, Disposer disposer) noexcept;

template<typename Disposer> 
  iterator erase_and_dispose(const_iterator b, const_iterator e, 
                             Disposer disposer) noexcept;

template<typename Disposer> 
  size_type erase_and_dispose(const key_type & key, Disposer disposer);

template<typename KeyType, typename KeyTypeKeyCompare, typename Disposer> 
  size_type erase_and_dispose(const KeyType & key, KeyTypeKeyCompare comp, 
                              Disposer disposer);

要求：key 是一个值，使得 *this 相对于 comp(nk, key) 和 !comp(key, nk) 进行分区，其中 comp(nk, key) 意味着 !comp(key, nk)，nk 是插入到 *this 中的 value_type 的 key_type。

要求：Disposer::operator()(pointer) 不应抛出异常。

效果：根据比较仿函数 “comp”，擦除所有具有给定键的元素。为删除的元素调用 Disposer::operator()(pointer) 。

返回：擦除的元素数量。

复杂度：O(log(size() + N))。

抛出：无。

注意：使指向已擦除元素的迭代器无效。

void clear() noexcept;

效果：擦除所有元素。

复杂度：与容器中的元素数量成线性关系。如果是安全模式或自动取消链接 value_type，则为常数时间。

抛出：无。

注意：使指向已擦除元素的迭代器（但不是引用）无效。不调用析构函数。

template<typename Disposer> void clear_and_dispose(Disposer disposer) noexcept;

效果：擦除所有元素，并为每个要擦除的节点调用 disposer(p)。复杂度：平均复杂度最多为 O(log(size() + N))，其中 N 是容器中的元素数量。

抛出：无。

注意：使指向已擦除元素的迭代器（但不是引用）无效。调用 N 次 disposer 仿函数。

size_type count(const key_type &);

附加说明：非 const 函数，执行伸展操作。

template<typename KeyType, typename KeyTypeKeyCompare> 
  size_type count(const KeyType & key, KeyTypeKeyCompare comp);

要求：key 是一个值，使得 *this 相对于 comp(nk, key) 和 !comp(key, nk) 进行分区，其中 comp(nk, key) 意味着 !comp(key, nk)，nk 是插入到 *this 中的 value_type 的 key_type。

效果：返回包含给定键的元素数量

复杂度：对数复杂度加上与给定键的对象数量成线性关系。

抛出：如果 comp 抛出异常。附加说明：const 函数，不执行伸展操作

iterator lower_bound(const key_type & key);

附加说明：非 const 函数，执行伸展操作。

template<typename KeyType, typename KeyTypeKeyCompare> 
  iterator lower_bound(const KeyType & key, KeyTypeKeyCompare comp);

附加说明：非 const 函数，为 “key” 的相等范围的第一个元素执行伸展操作

const_iterator lower_bound(const key_type & key) const;

附加说明：const 函数，不执行伸展操作

template<typename KeyType, typename KeyTypeKeyCompare> 
  const_iterator 
  lower_bound(const KeyType & key, KeyTypeKeyCompare comp) const;

附加说明：const 函数，不执行伸展操作

iterator upper_bound(const key_type & key);

附加说明：非 const 函数，为 “value” 的相等范围的第一个元素执行伸展操作

template<typename KeyType, typename KeyTypeKeyCompare> 
  iterator upper_bound(const KeyType & key, KeyTypeKeyCompare comp);

要求：key 是一个值，使得 *this 相对于 !comp(key, nk) 进行分区，其中 nk 是插入到 *this 中的 value_type 的 key_type。

效果：返回一个迭代器，指向根据 comp 键大于 k 的第一个元素，如果该元素不存在，则返回 end()。

复杂度：对数复杂度。

抛出：如果 comp 抛出异常。附加说明：非 const 函数，为 “key” 的相等范围的第一个元素执行伸展操作

const_iterator upper_bound(const key_type & key) const;

附加说明：const 函数，不执行伸展操作

template<typename KeyType, typename KeyTypeKeyCompare> 
  const_iterator 
  upper_bound(const KeyType & key, KeyTypeKeyCompare comp) const;

要求：key 是一个值，使得 *this 相对于 !comp(key, nk) 进行分区，其中 nk 是插入到 *this 中的 value_type 的 key_type。

效果：返回一个迭代器，指向根据 comp 键大于 k 的第一个元素，如果该元素不存在，则返回 end()。

复杂度：对数复杂度。

抛出：如果 comp 抛出异常。附加说明：const 函数，不执行伸展操作

iterator find(const key_type & key);

附加说明：非 const 函数，为 “value” 的相等范围的第一个元素执行伸展操作

template<typename KeyType, typename KeyTypeKeyCompare> 
  iterator find(const KeyType & key, KeyTypeKeyCompare comp);

要求：key 是一个值，使得 *this 相对于 comp(nk, key) 和 !comp(key, nk) 进行分区，其中 comp(nk, key) 意味着 !comp(key, nk)，nk 是插入到 *this 中的 value_type 的 key_type。

效果：查找一个迭代器，指向键为 k 的第一个元素，如果该元素不存在，则返回 end()。

复杂度：对数复杂度。

抛出：如果 comp 抛出异常。附加说明：非 const 函数，为 “key” 的相等范围的第一个元素执行伸展操作

const_iterator find(const key_type & key) const;

附加说明：const 函数，不执行伸展操作

template<typename KeyType, typename KeyTypeKeyCompare> 
  const_iterator find(const KeyType & key, KeyTypeKeyCompare comp) const;

要求：key 是一个值，使得 *this 相对于 comp(nk, key) 和 !comp(key, nk) 进行分区，其中 comp(nk, key) 意味着 !comp(key, nk)，nk 是插入到 *this 中的 value_type 的 key_type。

效果：查找一个迭代器，指向键为 k 的第一个元素，如果该元素不存在，则返回 end()。

复杂度：对数复杂度。

抛出：如果 comp 抛出异常。附加说明：const 函数，不执行伸展操作

std::pair< iterator, iterator > equal_range(const key_type & key);

附加说明：非 const 函数，为 “value” 的相等范围的第一个元素执行伸展操作

template<typename KeyType, typename KeyTypeKeyCompare> 
  std::pair< iterator, iterator > 
  equal_range(const KeyType & key, KeyTypeKeyCompare comp);

要求：key 是一个值，使得 *this 相对于 comp(nk, key) 和 !comp(key, nk) 进行分区，其中 comp(nk, key) 意味着 !comp(key, nk)，nk 是插入到 *this 中的 value_type 的 key_type。

效果：查找一个范围，其中包含所有键为 k 的元素；如果没有键为 k 的元素，则返回一个空范围，指示这些元素应在的位置。

复杂度：对数复杂度。

抛出：如果 comp 抛出异常。附加说明：非 const 函数，为 “key” 的相等范围的第一个元素执行伸展操作

std::pair< const_iterator, const_iterator > 
equal_range(const key_type & key) const;

附加说明：const 函数，不执行伸展操作

template<typename KeyType, typename KeyTypeKeyCompare> 
  std::pair< const_iterator, const_iterator > 
  equal_range(const KeyType & key, KeyTypeKeyCompare comp) const;

要求：key 是一个值，使得 *this 相对于 comp(nk, key) 和 !comp(key, nk) 进行分区，其中 comp(nk, key) 意味着 !comp(key, nk)，nk 是插入到 *this 中的 value_type 的 key_type。

效果：查找一个范围，其中包含所有键为 k 的元素；如果没有键为 k 的元素，则返回一个空范围，指示这些元素应在的位置。

复杂度：对数复杂度。

抛出：如果 comp 抛出异常。附加说明：const 函数，不执行伸展操作

std::pair< iterator, iterator > 
bounded_range(const_reference lower_value, const_reference upper_value, 
              bool left_closed, bool right_closed);

template<typename KeyType, typename KeyTypeKeyCompare> 
  std::pair< iterator, iterator > 
  bounded_range(const KeyType & lower_key, const KeyType & upper_key, 
                KeyTypeKeyCompare comp, bool left_closed, bool right_closed);

要求：lower_key 是一个值，使得 *this 相对于 comp(nk, lower_key) 进行分区（如果 left_closed 为 true），否则相对于 !comp(lower_key, nk) 进行分区。

upper_key 是一个值，使得 *this 相对于 !comp(upper_key, nk) 进行分区（如果 right_closed 为 true），否则相对于 comp(nk, upper_key) 进行分区。

upper_key 根据 comp 不应先于 lower_key [comp(upper_key, lower_key) 应为 false]

如果 lower_key 等效于 upper_key [!comp(upper_key, lower_key) && !comp(lower_key, upper_key)]，则 ('left_closed' || 'right_closed') 必须为 false。

效果：返回一个具有以下标准的对

first = lower_bound(lower_key, comp) 如果 left_closed，否则为 upper_bound(lower_key, comp)

second = upper_bound(upper_key, comp) 如果 right_closed，否则为 lower_bound(upper_key, comp)

复杂度：对数复杂度。

抛出：如果 comp 抛出异常。

注意：此函数可能比为 lower_key 和 upper_key 调用 upper_bound 和 lower_bound 更有效率。

注意：实验性函数，接口在未来版本中可能会更改。

std::pair< const_iterator, const_iterator > 
bounded_range(const_reference lower_value, const_reference upper_value, 
              bool left_closed, bool right_closed) const;

template<typename KeyType, typename KeyTypeKeyCompare> 
  std::pair< const_iterator, const_iterator > 
  bounded_range(const KeyType & lower_key, const KeyType & upper_key, 
                KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;

要求：lower_key 是一个值，使得 *this 相对于 comp(nk, lower_key) 进行分区（如果 left_closed 为 true），否则相对于 !comp(lower_key, nk) 进行分区。

upper_key 是一个值，使得 *this 相对于 !comp(upper_key, nk) 进行分区（如果 right_closed 为 true），否则相对于 comp(nk, upper_key) 进行分区。

upper_key 根据 comp 不应先于 lower_key [comp(upper_key, lower_key) 应为 false]

如果 lower_key 等效于 upper_key [!comp(upper_key, lower_key) && !comp(lower_key, upper_key)]，则 ('left_closed' || 'right_closed') 必须为 false。

效果：返回一个具有以下标准的对

first = lower_bound(lower_key, comp) 如果 left_closed，否则为 upper_bound(lower_key, comp)

second = upper_bound(upper_key, comp) 如果 right_closed，否则为 lower_bound(upper_key, comp)

复杂度：对数复杂度。

抛出：如果 comp 抛出异常。

注意：此函数可能比为 lower_key 和 upper_key 调用 upper_bound 和 lower_bound 更有效率。

注意：实验性函数，接口在未来版本中可能会更改。

iterator iterator_to(reference value) noexcept;

const_iterator iterator_to(const_reference value) const noexcept;

pointer unlink_leftmost_without_rebalance() noexcept;

效果：从容器中取消链接最左边的节点。

复杂度：平均复杂度为常数时间。

抛出：无。

注意：此函数会破坏容器，并且容器只能用于更多 unlink_leftmost_without_rebalance 调用。此函数通常用于实现容器的逐步受控销毁。

void replace_node(iterator replace_this, reference with_this) noexcept;

要求：replace_this 必须是 *this 的有效迭代器，并且 with_this 不得插入到任何容器中。

效果：用 with_this 替换容器中 replace_this 的位置。容器不需要重新平衡。

复杂度：常数时间。

抛出：无。

注意：如果 with_this 根据排序规则不等同于 *replace_this，则此函数将破坏容器排序不变量。此函数比擦除和插入节点更快，因为不需要重新平衡或比较。

void remove_node(reference value) noexcept;

效果：从容器中移除 “value”。

抛出：无。

复杂度：对数时间。

注意：此静态函数仅适用于具有无状态比较仿函数的非常数时间大小容器。

如果用户使用常数时间大小容器或有状态比较仿函数调用此函数，则会发出编译错误。

void splay_up(iterator i) noexcept;

要求：i 必须是 *this 的有效迭代器。

效果：重新排列容器，使迭代器 i 指向的元素放置在树的根部，从而改善未来对该值的搜索。

复杂度：摊销对数时间。

抛出：无。

template<typename KeyType, typename KeyTypeKeyCompare> 
  iterator splay_down(const KeyType & key, KeyTypeKeyCompare comp);

效果：重新排列容器，使得如果 *this 存储了键等同于 value 的元素，则该元素将放置在树的根部。如果该元素不存在，则返回与键比较的最后一个节点。如果树为空，则返回 end()。

复杂度：摊销对数时间。

返回：指向树的新根的迭代器，如果树为空，则返回 end()。

抛出：如果比较仿函数抛出异常。

iterator splay_down(const key_type & key);

效果：重新排列容器，使得如果 *this 存储了键等同于 value 的元素，则该元素将放置在树的根部。

复杂度：摊销对数时间。

返回：指向树的新根的迭代器，如果树为空，则返回 end()。

抛出：如果谓词抛出异常。

void rebalance() noexcept;

效果：重新平衡树。

抛出：无。

复杂度：线性时间。

iterator rebalance_subtree(iterator root) noexcept;

要求：old_root 是树的节点。

效果：重新平衡以 old_root 为根的子树。

返回：子树的新根。

抛出：无。

复杂度：与子树中的元素数量成线性关系。

template<class ... Options2> 
  void merge(splay_multiset< T, Options2... > & source);

template<class ... Options2> void merge(splay_set< T, Options2... > & source);

static splay_multiset & 
container_from_end_iterator(iterator end_iterator) noexcept;

static const splay_multiset & 
container_from_end_iterator(const_iterator end_iterator) noexcept;

static splay_multiset & container_from_iterator(iterator it) noexcept;

static const splay_multiset & 
container_from_iterator(const_iterator it) noexcept;

static iterator s_iterator_to(reference value) noexcept;

static const_iterator s_iterator_to(const_reference value) noexcept;

static void init_node(reference value) noexcept;