Namespaces
Variants

Standard library header <set>

From cppreference.net
C++
Standard library headers

此头文件是 容器 库的组成部分。

目录

包含文件

(C++20)
三路比较运算符 支持
(C++11)
std::initializer_list 类模板

类

唯一键的集合，按键排序
(类模板)
键的集合，按键排序
(类模板)

函数

(C++20 中移除) (C++20 中移除) (C++20 中移除) (C++20 中移除) (C++20 中移除) (C++20)
按字典序比较两个 set 的值
(函数模板)
特化 std::swap 算法
(函数模板)
(C++20)
擦除所有满足特定条件的元素
(函数模板)
(C++20 中移除) (C++20 中移除) (C++20 中移除) (C++20 中移除) (C++20 中移除) (C++20)
按字典序比较两个 multiset 的值
(函数模板)
特化 std::swap 算法
(函数模板)
(C++20)
擦除所有满足特定条件的元素
(函数模板)
范围访问
(C++11) (C++14)
返回指向容器或数组起始的迭代器
(函数模板)
(C++11) (C++14)
返回指向容器或数组末尾的迭代器
(函数模板)
(C++14)
返回指向容器或数组起始的反向迭代器
(函数模板)
(C++14)
返回指向容器或数组末尾的反向迭代器
(函数模板)
(C++17) (C++20)
</td

概要 

#include <compare>
#include <initializer_list>
namespace std {
  // 类模板 set
  template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
  class set;
  template<class Key, class Compare, class Allocator>
  bool operator==(const set<Key, Compare, Allocator>& x,
                  const set<Key, Compare, Allocator>& y);
  template<class Key, class Compare, class Allocator>
  /*synth-three-way-result*/<Key> operator<=>(const set<Key, Compare, Allocator>& x,
                                              const set<Key, Compare, Allocator>& y);
  template<class Key, class Compare, class Allocator>
  void swap(set<Key, Compare, Allocator>& x,
            set<Key, Compare, Allocator>& y) noexcept(noexcept(x.swap(y)));
  // set 的擦除操作
  template<class Key, class Compare, class Allocator, class Predicate>
  typename set<Key, Compare, Allocator>::size_type erase_if(
    set<Key, Compare, Allocator>& c,
    Predicate pred);
  // 类模板 multiset
  template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
  class multiset;
  template<class Key, class Compare, class Allocator>
  bool operator==(const multiset<Key, Compare, Allocator>& x,
                  const multiset<Key, Compare, Allocator>& y);
  template<class Key, class Compare, class Allocator>
  /*synth-three-way-result*/<Key> operator<=>(const multiset<Key, Compare, Allocator>& x,
                                              const multiset<Key, Compare, Allocator>& y);
  template<class Key, class Compare, class Allocator>
  void swap(multiset<Key, Compare, Allocator>& x,
            multiset<Key, Compare, Allocator>& y) noexcept(noexcept(x.swap(y)));
  // multiset 的擦除操作
  template<class Key, class Compare, class Allocator, class Predicate>
  typename multiset<Key, Compare, Allocator>::size_type erase_if(
    multiset<Key, Compare, Allocator>& c,
    Predicate pred);
  namespace pmr {
    template<class Key, class Compare = less<Key>>
    using set = std::set<Key, Compare, polymorphic_allocator<Key>>;
    template<class Key, class Compare = less<Key>>
    using multiset = std::multiset<Key, Compare, polymorphic_allocator<Key>>;
  }
}

类模板 std::set 

namespace std {
  template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
  class set
  {
  public:
    // 类型定义
    using key_type               = Key;
    using key_compare            = Compare;
    using value_type             = Key;
    using value_compare          = Compare;
    using allocator_type         = Allocator;
    using pointer                = typename allocator_traits<Allocator>::pointer;
    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
    using reference              = value_type&;
    using const_reference        = const value_type&;
    using size_type              = /* 实现定义 */;
    using difference_type        = /* 实现定义 */;
    using iterator               = /* 实现定义 */;
    using const_iterator         = /* 实现定义 */;
    using reverse_iterator       = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    using node_type              = /* 未指定 */;
    using insert_return_type     = /*插入返回类型*/<iterator, node_type>;
    // 构造/复制/销毁
    set()
      : set(Compare())
    {
    }
    explicit set(const Compare& comp, const Allocator& = Allocator());
    template<class InputIter>
    set(InputIter first,
        InputIter last,
        const Compare& comp = Compare(),
        const Allocator&    = Allocator());
    template<container-compatible-range<value_type> R>
    set(from_range_t,
        R&& rg,
        const Compare& comp = Compare(),
        const Allocator&    = Allocator());
    set(const set& x);
    set(set&& x);
    explicit set(const Allocator&);
    set(const set&, const type_identity_t<Allocator>&);
    set(set&&, const type_identity_t<Allocator>&);
    set(initializer_list<value_type>,
        const Compare&   = Compare(),
        const Allocator& = Allocator());
    template<class InputIter>
    set(InputIter first, InputIter last, const Allocator& a)
      : set(first, last, Compare(), a)
    {
    }
    template<container-compatible-range<value_type> R>
      set(from_range_t, R&& rg, const Allocator& a))
        : set(from_range, std::forward<R>(rg), Compare(), a)
    {
    }
    set(initializer_list<value_type> il, const Allocator& a)
      : set(il, Compare(), a)
    {
    }
    ~set();
    set& operator=(const set& x);
    set& operator=(set&& x) noexcept(allocator_traits<Allocator>::is_always_equal::value&&
                                       is_nothrow_move_assignable_v<Compare>);
    set& operator=(initializer_list<value_type>);
    allocator_type get_allocator() const noexcept;
    // 迭代器
    iterator begin() noexcept;
    const_iterator begin() const noexcept;
    iterator end() noexcept;
    const_iterator end() const noexcept;
    reverse_iterator rbegin() noexcept;
    const_reverse_iterator rbegin() const noexcept;
    reverse_iterator rend() noexcept;
    const_reverse_iterator rend() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
    const_reverse_iterator crbegin() const noexcept;</

类模板 std::multiset 

namespace std {
  template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
  class multiset
  {
  public:
    // 类型定义
    using key_type               = Key;
    using key_compare            = Compare;
    using value_type             = Key;
    using value_compare          = Compare;
    using allocator_type         = Allocator;
    using pointer                = typename allocator_traits<Allocator>::pointer;
    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
    using reference              = value_type&;
    using const_reference        = const value_type&;
    using size_type              = /* 由实现定义 */;
    using difference_type        = /* 由实现定义 */;
    using iterator               = /* 由实现定义 */;
    using const_iterator         = /* 由实现定义 */;
    using reverse_iterator       = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    using node_type              = /* 未指定 */;
    // 构造/复制/销毁
    multiset()
      : multiset(Compare())
    {
    }
    explicit multiset(const Compare& comp, const Allocator& = Allocator());
    template<class InputIter>
    multiset(InputIter first,
             InputIter last,
             const Compare& comp = Compare(),
             const Allocator&    = Allocator());
    template<container-compatible-range<value_type> R>
    multiset(from_range_t,
             R&& rg,
             const Compare& comp = Compare(),
             const Allocator&    = Allocator());
    multiset(const multiset& x);
    multiset(multiset&& x);
    explicit multiset(const Allocator&);
    multiset(const multiset&, const type_identity_t<Allocator>&);
    multiset(multiset&&, const type_identity_t<Allocator>&);
    multiset(initializer_list<value_type>,
             const Compare&   = Compare(),
             const Allocator& = Allocator());
    template<class InputIter>
    multiset(InputIter first, InputIter last, const Allocator& a)
      : multiset(first, last, Compare(), a)
    {
    }
    template<container-compatible-range<value_type> R>
      multiset(from_range_t, R&& rg, const Allocator& a))
        : multiset(from_range, std::forward<R>(rg), Compare(), a)
    {
    }
    multiset(initializer_list<value_type> il, const Allocator& a)
      : multiset(il, Compare(), a)
    {
    }
    ~multiset();
    multiset& operator=(const multiset& x);
    multiset& operator=(multiset&& x) noexcept(
      allocator_traits<Allocator>::is_always_equal::value&&
        is_nothrow_move_assignable_v<Compare>);
    multiset& operator=(initializer_list<value_type>);
    allocator_type get_allocator() const noexcept;
    // 迭代器
    iterator begin() noexcept;
    const_iterator begin() const noexcept;
    iterator end() noexcept;
    const_iterator end() const noexcept;
    reverse_iterator rbegin() noexcept;
    const_reverse_iterator rbegin() const noexcept;
    reverse_iterator rend() noexcept;
    const_reverse_iterator rend() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
    const_reverse_iterator crbegin() const noexcept;
    const_reverse_iterator crend() const <span class="kw

缺陷报告

下列行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

DR 适用范围 发布时的行为 正确行为
LWG 214 C++98 find 、 lower_bound 、 upper_bound
和 equal_range 成员在 std::set 和 std::multiset
概要中的声明与关联容器的要求不匹配 		已修正