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源码剖析