STL容器之set/multiset

set/multiset会根据待定的排序准则，自动将元素排序。两者不同在于前者不允许元素重复，而后者允许。

关于set

对于set，元素的值标识这个元素。每个元素必须是唯一的，且一旦存入set就不可修改(the elements are always const)，但是可以进行插入和删除操作。

访问单个元素，set通常比unordered_set慢，但是set允许按顺序直接插入。
set通常用二叉搜索树实现（sgi用红黑树实现）。

关于Compare
Compare可以是一个函数指针或函数对象，Compare(a,b) shall return true if a is considered to go before b in the strict weak ordering。

关于strict weak ordering
The STL algorithms for stable_sort( ) and sort( ) require the binary predicate to be strict weak ordering.
For example:
· Strict: pred (X, X) is always false.
· Weak: If !pred(X,Y) && !pred(Y,X), then X==Y.
· Ordering:If pred(X,Y) && pred(Y,Z), then pred(X,Z).

set的迭代器是双向迭代器。

set的接口如下，至于实现，基本是转调了红黑树的函数而已：

template < typename T, typename Compare = less<T>,         typename Alloc = allocator<T> >class set{public:    typedef T       key_type;    typedef T       value_type;    typedef Compare key_compare;    typedef Compare value_compare;    typedef Alloc   allocator_type;    typedef typename allocator_type::pointer             pointer;    typedef typename allocator_type::const_pointer       const_pointer;    typedef typename allocator_type::reference           reference;    typedef typename allocator_type::const_reference     const_reference;private:    // 红黑树    typedef _Rb_tree<key_type, value_type, _Identity<key_type>, key_compare, allocator_type> _Rep_type;public:    typedef typename _Rep_type::const_iterator            iterator;    typedef typename _Rep_type::const_iterator            const_iterator;    typedef typename _Rep_type::const_reverse_iterator    reverse_iterator;    typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;    typedef typename _Rep_type::size_type                 size_type;    typedef typename _Rep_type::difference_type           difference_type;    // 构造    explicit set(const key_compare& comp = key_compare(),                 const allocator_type& alloc = allocator_type());    template <typename InputIterator>    set(InputIterator first, InputIterator last,        const key_compare& comp = key_compare(),        const allocator_type& alloc = allocator_type());    set (const set& x);    // 析构    ~set();    // 赋值    set& operator=(const set& x);    // 迭代器    iterator begin();    const_iterator begin() const;    iterator end();    const_iterator end() const;    reverse_iterator rbegin();    const_reverse_iterator rbegin() const;    reverse_iterator rend();    const_reverse_iterator rend() const;    // Capacity    bool empty() const;    size_type size() const;    size_type max_size() const;    // Modifiers    /**    由于set的元素是唯一的, 如果val已存在于set中, 插入操作则会失败;    插入操作的状态存入返回值的第二个元素里,    如果插入失败, 返回pair的第一个元素存储的是指向此元素的迭代器,    如果插入成功, 其存储的是指向新插入元素的迭代器.    */    pair<iterator,bool> insert(const value_type& val);    /**    此函数不关心插入是否成功, 返回值和上个函数返回pair的第一个元素相同.    第一个参数仅是一个hint, 它可能会提高插入的效率.    A bad hint would cause no gains in efficiency.    Insertion requires logarithmic time (if the hint is not taken).    */    iterator insert(iterator position, const value_type& val);    template <typename InputIterator>    void insert(InputIterator first, InputIterator last);    void erase(iterator position);    size_type erase(const value_type& val);    void erase(iterator first, iterator last);    void swap (set& x);    void clear();    // get操作    key_compare key_comp() const;    value_compare value_comp() const;    allocator_type get_allocator() const;    // Operations    // 没有找到将返回end()    iterator find(const value_type& val) const;    // 返回0或1    size_type count(const value_type& val) const;    /**    Return iterator to lower bound    返回指向第一个满足not considered to go before val的元素的迭代器    即key_compare(element,val)返回false, 也就是element>=val    */    iterator lower_bound(const value_type& val) const;    // 返回指向第一个满足considered to go after val的元素的迭代器    // 当set包含一个等于val的元素时, lower_bound(val)返回指向这个元素的迭代器, 而upper_bound(val)返回指向下个元素的迭代器    iterator upper_bound(const value_type& val) const;    /**    返回与val相等的所有元素的边界    因为set里所有元素都是唯一的, 所以此序列最多包含一个元素    如果没有符合的值, 两个迭代器都指向val的下一个元素, 此元素被认为go after val    如果找到, 第一个迭代器指向val, 第二个迭代器指向下一个元素    */    pair<iterator,iterator> equal_range(const value_type& val) const;}

关于multiset

multiset的特性以及用法和set完全相同，唯一的差别在于它允许键值重复。另外还要注意以下几点：
multiset::find()仅返回第一个查找到的元素，如要获得所有元素序列，可使用multiset::equal_range()。
size_type multiset::erase (const value_type& val);会erase掉所有与val相等的元素。
对于插入操作，不能保证相等元素的相对顺序。

例子1

cplusplus.com上自定义Comparator的例子：

// http://www.cplusplus.com/reference/set/set/set/// 其实是关于构造函数的例子// constructing sets#include <iostream>#include <set>bool fncomp(int lhs, int rhs) {return lhs<rhs;}struct classcomp {  bool operator() (const int& lhs, const int& rhs) const  {return lhs<rhs;}};int main(){  std::set<int> first;                           // empty set of ints  int myints[] = {10,20,30,40,50};  std::set<int> second(myints,myints+5);        // range  std::set<int> third(second);                  // a copy of second  std::set<int> fourth(second.begin(), second.end());  // iterator ctor.  std::set<int,classcomp> fifth;                 // class as Compare  bool (*fn_pt)(int,int) = fncomp;  std::set<int,bool(*)(int,int)> sixth(fn_pt);  // function pointer as Compare  return 0;}

本来我是不准备展示这个例子的，但是在思考下一个例子的时候，发现还是有必要对class和function pointer作为Comparator的不同做些说明。
可以看到，当用class作为Comparator时，构造函数并不需要参数，因为有默认参数key_compare()，这样OK；但是当用function pointer作为Comparator的时候就不OK了，虽然编译不会出错，但运行起来肯定会出错！

那为什么会编译通过？
考虑到

int m = int();cout << m << endl;

会输出0，我认为（不一定对啊）c++对基本数据类型进行了“类”化，主要出于一些算法对基本类型进行specialize时，接口统一（可能描述有问题）的考虑。int()相当于用0初始化m，bool(*)(int,int)()就是用0初始化这个函数指针类型。

所以，一定要用实际的函数指针来初始化Comparator。

例子2

当set用int作为参数时，key就是int类型，insert一个元素就是拷贝一个int，也没啥开销。但当元素类型是一个类时，insert一个元素就会调用拷贝构造函数，这开销就可能很大了。
可以用指向类的指针作为set的参数啊！只要自定义Comparator就OK了。
下面就是一个例子：

#include <iostream>#include <set>#include <cstdlib>using namespace std;struct Cont{    Cont(int m=0,int n=0):a(m),b(n) {}    int a,b;    void show() { cout << a+b << endl; }};bool com(Cont *a, Cont *b){    return a->a+a->b < b->a+b->b;}int main (){    set<Cont*,bool (*)(Cont*,Cont*)> myset(com);    Cont *p = NULL;    for(int i=0; i<5; ++i)    {        p = new Cont(rand(),rand());        myset.insert(p);    }    set<Cont*,bool (*)(Cont*,Cont*)>::iterator ite;    for(ite=myset.begin(); ite!=myset.end(); ++ite)    {        (*ite)->show();        delete *ite;    }    return 0;}

既然可以用指针，那么可以用引用吗？答案是不行。
set用到的很多类里都有类似这样的定义：typedef T* pointer;，然而定义一个指向引用的指针是非法的：typedef int&*pointer;（错误！）。

能想出这样的例子来，我都佩服我自己，然而为什么我还没有找到实习？crying…

---

参考
http://www.cplusplus.com/reference/set/
STL源码剖析