简介

在头文件<set> 中定义

namespace std 
{
    template <typename T,
            typename Compare = less<T>,
            typename Allocator = allocator<T> >
        class set;
    template <typename T,
            typename Compare = less<T>,
            typename Allocator = allocator<T> >
        class multiset;
}

set和multiset都是关联容器，是有序的集合，集合中包含不可重复的、类型为Key的元素。排序通过使用类型为Compare的比较函数比较来实现。搜索，删除和插入操作具有对数时间复杂度。set和multiset通常都以红黑树实现。multiset相对set来说能够允许重复值的存在。

set和multiset不提供用来直接存取元素的任何操作函数

通过迭代器进行元素间存取，有一个限制：从迭代器角度看，元素值是常数。

set和multiset操作

构造、复制与析构

set c //默认构造函数；创建一个空set/multiset

set c(op) //创建一个空set/multiset，并以op原则作为排序准则

set c(c2) //复制构造函数；创建一个新的set/multiset作为c2的副本（所有元素都被复制）

set c = c2 //复制构造函数；创建一个新的set作为c2的副本（所有元素都被复制）

set c(rv) //移动构造函数；使用右值对象rv创建一个新set/multiset

set c = rv //移动构造函数；使用右值对象rv创建一个新set/multiset

set c(beg,end) //创建一个set/multiset，并使用beg到end范围内的值进行初始化

set c(beg,end,op) //创建一个set/multiset，并使用beg到end范围内以op原则排序后的值进行初始化

set c(initlist) //创建一个set/multiset，并使用初始化列表进行初始化

set c = initlist //创建一个set/multiset，并使用初始化列表进行初始化

c.~set() //销毁所有元素并释放内存

在这里set可能是如下的一种：

set<Elem> //以less<>为排序准则的set

set<Elem,Op> //以op为排序准则的set

multiset<Elem> //以less<>为排序准则的multiset

multiset<Elem,Op> //以op为排序准则的multiset

非变动性操作

c.key_comp() //返回比较准则

c.value_comp() //返回对值比较的标准 (与
key_comp()相同)

c.empty() //判断容器是否为空，与size()==0相同，但可能更快

c.size() //返回当前元素数量

c.max_size() //返回可容纳的元素最大数量

c1 == c2 //判断c1与c2是否相等

c1 != c2 //判断c1与c2是否不相等，等同于!(c1==c2)

c1 < c2 //判断c1是否小于c2

c1 > c2 //判断c1是否大于c2

c1 <= c2 //判断c1是否小于等于c2

c1 >= c2 //判断c1是否大于等于c2

特殊查询操作

c.count(val) //返回值为val的元素个数

c.find(val) //返回第一个值为val的位置，若没找到返回end()

c.lower_bound(val) //返回val值的第一个可插入的位置，也就是元素值 >= val的第一个元素位置

c.upper_bound(val) //返回val值的最后一个可插入的位置，也就是元素值 > val的第一个元素位置

c.equal_range(val) //返回val值可插入的第一个位置和最后一个位置的区间，也就是元素值 == val的元素区间

赋值

c = c2 //将c2所有元素赋值给c

c = rv //将右值对象rv的所有元素移动赋值给c

c = initlist //使用初始化列表进行赋值

c1.swap(c2) //交换c1和c2的数

swap(c1,c2) //交换c1和c2的数

迭代器相关函数

c.begin() //返回一个双向迭代器，指向第一个元素

c.end() //返回一个双向迭代器，指向最后一个元素

c.cbegin() //返回一个双向常迭代器，指向第一个元素

c.cend() //返回一个双向常迭代器，指向最后一个元素

c.rbegin() //返回一个逆向迭代器，指向逆向迭代的第一个元素

c.rend() //返回一个逆向迭代器，指向逆向迭代的最后一个元素

c.crbegin() //返回一个逆向常迭代器，指向逆向迭代的第一个元素

c.crend() //返回一个逆向常迭代器，指向逆向迭代的最后一个元素

插入和移除元素

c.insert(val) //插入一个val的副本，返回新元素位置（对set来说不论成功与否）

c.insert(pos,val) //插入一个val副本，返回新元素位置（pos应该是插入的搜寻起点）

c.insert(beg,end) //将范围beg到end的所有元素的副本插入到c（无返回值）

c.insert(initlist) //插入初始化列表的所有元素的副本（无返回值）

c.emplace(args...) //插入一个使用args初始化的元素副本，返回新元素位置（对set来说不论成功与否）

c.emplace_hint(pos,args...) //插入一个使用args初始化的元素副本，返回新元素位置（pos应该是插入的搜寻起点）

c.erase(val) //移除所有与val值相等的元素，并返移除的元素个数

c.erase(pos) //移除迭代器位置的元素，并返回下个元素的位置

c.erase(beg,end) //移除beg到end范围内的所有元素，并返回下个元素的位置

c.clear() //移除所以元素，清空容器

栗子

#include <iostream>
#include <set>
#include <algorithm>
#include <iterator>

using namespace std;

int main()
{

    //无重复、int型、降序
    set<int,greater<int>> coll1;

    //无序插入元素
    coll1.insert({4,3,5,1,6,2});
    coll1.insert(5);

    //输出元素
    for (int elem : coll1)
    {
        cout << elem << ' ';
    }
    cout << endl;

    //插入4并处理返回值
    auto status = coll1.insert(4);
    if (status.second)
    {
        cout << "4 inserted as element "
             << distance(coll1.begin(),status.first) + 1 << endl;
    }
    else
    {
        cout << "4 already exists" << endl;
    }

    //把coll1以增序赋值给coll2
    set<int> coll2(coll1.cbegin(),coll1.cend());

    //输出元素
    copy (coll2.cbegin(), coll2.cend(),
          ostream_iterator<int>(cout," "));
    cout << endl;

    //删除3之前的所有元素
    coll2.erase (coll2.begin(), coll2.find(3));

    //删除所有值为5的元素
    int num;
    num = coll2.erase (5);
    cout << num << " element(s) removed" << endl;

    //输出元素
    copy (coll2.cbegin(), coll2.cend(),
          ostream_iterator<int>(cout," "));
    cout << endl;

    return 0;
}

输出

6 5 4 3 2 1
4 already exists
1 2 3 4 5 6
1 element(s) removed
3 4 6