set<Key, Compare, Alloc>


类别: 容器	组件类型: 类型

描述

集合是一个排序关联容器，它存储类型为Key. 集合的对象。它是一个简单关联容器，这意味着它的值类型和键类型都是Key。它也是一个唯一关联容器，这意味着没有两个元素是相同的。

集合以及多重集合特别适合集合算法包含, 集合并, 集合交, 集合差，以及集合对称差。原因有两个。首先，集合算法要求其参数是排序的范围，并且，由于集合以及多重集合是排序关联容器，它们的元素总是按升序排序。其次，这些算法的输出范围总是排序的，将排序范围插入到集合或多重集合是一个快速操作：唯一排序关联容器和多重排序关联容器的要求保证，如果范围已排序，则插入范围只需线性时间。

集合具有重要的属性，即向集合中插入新元素不会使指向现有元素的迭代器失效。从集合中删除元素也不会使任何迭代器失效，当然，指向要删除的元素的迭代器除外。

示例

struct ltstr
{
  bool operator()(const char* s1, const char* s2) const
  {
    return strcmp(s1, s2) < 0;
  }
};

int main()
{
  const int N = 6;
  const char* a[N] = {"isomer", "ephemeral", "prosaic", 
                      "nugatory", "artichoke", "serif"};
  const char* b[N] = {"flat", "this", "artichoke",
                      "frigate", "prosaic", "isomer"};

  set<const char*, ltstr> A(a, a + N);
  set<const char*, ltstr> B(b, b + N);
  set<const char*, ltstr> C;

  cout << "Set A: ";
  copy(A.begin(), A.end(), ostream_iterator<const char*>(cout, " "));
  cout << endl;
  cout << "Set B: ";
  copy(B.begin(), B.end(), ostream_iterator<const char*>(cout, " "));   
  cout << endl;

  cout << "Union: ";
  set_union(A.begin(), A.end(), B.begin(), B.end(),
            ostream_iterator<const char*>(cout, " "),
            ltstr());   
  cout << endl;

  cout << "Intersection: ";
  set_intersection(A.begin(), A.end(), B.begin(), B.end(),
                   ostream_iterator<const char*>(cout, " "),
                   ltstr());    
  cout << endl;

  set_difference(A.begin(), A.end(), B.begin(), B.end(),
                 inserter(C, C.begin()),
                 ltstr());
  cout << "Set C (difference of A and B): ";
  copy(C.begin(), C.end(), ostream_iterator<const char*>(cout, " "));
  cout << endl;
}

定义

定义在标准头文件 set 中，以及非标准向后兼容的头文件 set.h 中。

模板参数

参数	描述	默认
`Key`	集合的键类型和值类型。这也定义为`set::key_type`以及`set::value_type`
`Compare`	键比较函数，一个严格弱排序，其参数类型为`key_type`；它返回`true`如果它的第一个参数小于它的第二个参数，则返回`false`否则。这也定义为`set::key_compare`以及`set::value_compare`.	`less<Key>`
`Alloc`	的`集合`分配器，用于所有内部内存管理。	`alloc`

模型

唯一排序关联容器，简单关联容器

类型要求

Key是可赋值的。
Compare是一个严格弱排序，其参数类型为Key.
Alloc是分配器。

公共基类

无。

成员

成员	定义位置	描述
`value_type`	容器	对象类型，`T`，存储在集合中。
`key_type`	关联容器	与`value_type`.
`key_compare`	排序关联容器	函数对象，比较两个键以进行排序。
`value_compare`	排序关联容器	函数对象，比较两个值以进行排序。
`pointer`	容器	指向`T`.
`reference`	容器	指向`T`
`const_reference`	容器	指向`T`
`size_type`	容器	无符号整型类型。
`difference_type`	容器	有符号整型类型。
`iterator`	容器	迭代器，用于遍历`集合`.
`const_iterator`	容器	常量迭代器，用于遍历`集合`. (`迭代器`以及`const_iterator`是同一类型。）
`reverse_iterator`	可逆容器	迭代器，用于反向遍历`集合`.
`const_reverse_iterator`	可逆容器	常量迭代器，用于反向遍历`集合`. (`Reverse_iterator`以及`const_reverse_iterator`是同一类型。）
`iterator begin() const`	容器	返回一个`iterator`，指向`集合`.
`iterator end() const`	容器	返回一个`iterator`，指向`集合`.
`reverse_iterator rbegin() const`	可逆容器	返回一个`reverse_iterator`，指向反转后的集合的开头。
`reverse_iterator rend() const`	可逆容器	返回一个`reverse_iterator`，指向反转后的集合的末尾。
`size_type size() const`	容器	返回`集合`.
`size_type max_size() const`	容器	返回`集合`.
`bool empty() const`	容器	`true`如果`集合`的大小是`0`.
`key_compare key_comp() const`	排序关联容器	返回`key_compare`对象，由`集合`.
`value_compare value_comp() const`	排序关联容器	返回`value_compare`对象，由`集合`.
`set()`	容器	创建一个空的`集合`.
`set(const key_compare& comp)`	排序关联容器	创建一个空的`集合`，使用`comp`作为`key_compare`对象。
template <class InputIterator> set(InputIterator f, InputIterator l) [1]	唯一排序关联容器	创建一个具有范围副本的集合。
template <class InputIterator> set(InputIterator f, InputIterator l, const key_compare& comp) [1]	唯一排序关联容器	创建一个具有范围副本的集合，使用`comp`作为`key_compare`对象。
`set(const set&)`	容器	复制构造函数。
`set& operator=(const set&)`	容器	赋值运算符
`void swap(set&)`	容器	交换两个集合的内容。
pair<iterator, bool> insert(const value_type& x)	唯一关联容器	插入`x`到`集合`.
iterator insert(iterator pos, const value_type& x)	唯一排序关联容器	插入`x`到`集合`，使用`pos`中，作为插入位置的提示。
template <class InputIterator> void insert(InputIterator, InputIterator) [1]	唯一排序关联容器	将范围插入到`集合`.
`void erase(iterator pos)`	关联容器	删除`pos`.
`size_type erase(const key_type& k)`	关联容器	删除键为`k`.
`的元素`	关联容器	void erase(iterator first, iterator last)
`删除范围内的所有元素。`	关联容器	void clear()
`删除所有元素。`	关联容器	iterator find(const key_type& k) const`k`.
`找到键为`	唯一关联容器	size_type count(const key_type& k) const`k`.
`计算键为`	排序关联容器	iterator lower_bound(const key_type& k) const`k`.
`找到第一个键不小于`	排序关联容器	iterator upper_bound(const key_type& k) const`k`.
pair<iterator, iterator> equal_range(const key_type& k) const	排序关联容器	找到第一个键大于`k`.
bool operator==(const set&, const set&)	找到一个范围，包含所有键为	Forward Container
bool operator<(const set&, const set&)	找到一个范围，包含所有键为	测试两个集合是否相等。这是一个全局函数，而不是成员函数。

字典序比较。这是一个全局函数，而不是成员函数。

新成员集合所有集合的成员都定义在唯一排序关联容器和简单关联容器要求中。

没有引入任何新成员。

注释[1] 此成员函数依赖于成员模板函数，目前（1998 年初）并非所有编译器都支持。如果您的编译器支持成员模板，则可以使用任何类型的输入迭代器调用此函数。但是，如果您的编译器尚未支持成员模板，则参数必须是类型const value_type*或类型.

set::const_iterator

另请参见关联容器，排序关联容器，简单关联容器，唯一排序关联容器，, 多重集合, 映射, 多重映射, 哈希集合, 哈希映射, 哈希多重集合