[STL]set/multiset用法详解[自从VS2010开始，set的iterator类型自动就是const的引用类型]

集合

使用set或multiset之前，必须加入头文件<set>

Set、multiset都是集合类，差别在与set中不允许有重复元素，multiset中允许有重复元素。

sets和multiset内部以平衡二叉树实现

1.   常用函数

1)        构造函数和析构函数

set c:创建空集合,不包含任何元素

set c(op):以op为排序准则，产生一个空的set

set c1(c2):复制c2中的元素到c1中

set c(const value_type *first, const value_type* last):复制[first, last)之间元素构成新集合

set c(const value_type *first, const value_type* last,op):以op为排序准则，复制[first, last)之间元素构成新集合。

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

multiset mc:创建空集合,不包含任何元素

multiset mc(op):以op为排序准则，产生一个空的set

multiset c1(c2):复制c2中的元素到c1中

multiset c(const value_type *first, const value_type* last):复制[first, last)之间元素构成新集合

multiset c(const value_type *first, const value_type* last,op):以op为排序准则，复制[first, last)之间元素构成新集合。

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

1. // constructing sets
2. #include <iostream>
3. #include <set>
4. bool fncomp (int lhs, int rhs) {return lhs<rhs;}
5. struct classcomp {
6. bool operator() (const int& lhs, const int& rhs) const
7. {return lhs<rhs;}
8. };
9. int main ()
10. {
11. std::set<int> first;                           // empty set of ints
12. int myints[]= {10,20,30,40,50};
13. std::set<int> second (myints,myints+5);        // range
14. std::set<int> third (second);                  // a copy of second
15. std::set<int> fourth (second.begin(), second.end());  // iterator ctor.
16. std::set<int,classcomp> fifth;                 // class as Compare
17. bool(*fn_pt)(int,int) = fncomp;
18. std::set<int,bool(*)(int,int)> sixth (fn_pt);  // function pointer as Compare
19. return 0;
20. }

2)        大小、判断空函数

int size() const:返回容器元素个数
    bool empty() const:判断容器是否为空，若返回true，表明容器已空

3)        增加、删除函数

pair<iterator,bool> insert( x):插入元素x

iterator insert(iterator it,x):在迭代器it处插入元素x

void insert(const value_type *first,const value_type *last):插入[first, last)之间元素

iterator erase(iterator it):删除迭代器指针it处元素

iterator erase(iterator first,iterator last):删除[first, last)之间元素

size_type erase(const Key& key):删除元素值等于key的元素

1. #include <iostream>
2. #include <set>
3. int main ()
4. {
5. std::set<int> myset;
6. std::set<int>::iterator it;
7. std::pair<std::set<int>::iterator,bool> ret;
8. // set some initial values:
9. for (int i=1; i<=5; ++i) myset.insert(i*10);    // set: 10 20 30 40 50
10. ret = myset.insert(20);               // no new element inserted
11. if (ret.second==false) it=ret.first;  // "it" now points to element 20
12. myset.insert (it,25);                 // max efficiency inserting
13. myset.insert (it,24);                 // max efficiency inserting
14. myset.insert (it,26);                 // no max efficiency inserting
15. int myints[]= {5,10,15};              // 10 already in set, not inserted
16. myset.insert (myints,myints+3);
17. std::cout << "myset contains:";
18. for (it=myset.begin(); it!=myset.end(); ++it)
19. std::cout << ' ' << *it;
20. std::cout << '\n';
21. return 0;
22. }

1. #include <iostream>
2. #include <set>
3. int main ()
4. {
5. std::set<int> myset;
6. std::set<int>::iterator it;
7. // insert some values:
8. for (int i=1; i<10; i++) myset.insert(i*10);  // 10 20 30 40 50 60 70 80 90
9. it = myset.begin();
10. ++it;                                         // "it" points now to 20
11. myset.erase (it);
12. myset.erase (40);
13. it = myset.find (60);
14. myset.erase (it, myset.end());
15. std::cout << "myset contains:";
16. for (it=myset.begin(); it!=myset.end(); ++it)
17. std::cout << ' ' << *it;
18. std::cout << '\n';
19. return 0;
20. }

4)        遍历函数

iterator begin():返回首元素的迭代器指针

iterator end()：返回尾元素的迭代器指针
    reverse_iterator rbegin():返回尾元素的逆向迭代器指针
    reverse_iterator rend():返回首元素前一个位置的迭代器指针

1. #include <iostream>
2. #include <set>
3. int main ()
4. {
5. int myints[] = {75,23,65,42,13};
6. std::set<int> myset (myints,myints+5);
7. std::cout << "myset contains:";
8. for (std::set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)
9. std::cout << ' ' << *it;
10. std::cout << '\n';
11. return 0;
12. }

5)        操作函数

const_iterator lower_bound(const Key& key):返回容器中大于等于key的迭代器指针

const_iterator upper_bound(const Key& key):返回容器中大于key的迭代器指针

int count(const Key& key) const:返回容器中元素等于key的元素的个数
    pair<const_iterator,const_iterator> equal_range(const Key& key) const:返回容器中元素值等于key的迭代指针[first, last)
    const_iterator find(const Key& key) const:查找功能，返回元素值等于key的迭代器指针
    void swap(set& s):交换集合元素
    void swap(multiset& s):交换多集合元素

1. #include <iostream>
2. #include <set>
3. int main ()
4. {
5. std::set<int> myset;
6. std::set<int>::iterator itlow,itup;
7. for (int i=1; i<10; i++) myset.insert(i*10); // 10 20 30 40 50 60 70 80 90
8. itlow=myset.lower_bound (30);                //       ^
9. itup=myset.upper_bound (60);                 //                   ^
10. myset.erase(itlow,itup);                     // 10 20 70 80 90
11. std::cout << "myset contains:";
12. for (std::set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)
13. std::cout << ' ' << *it;
14. std::cout << '\n';
15. return 0;
16. }

1. #include "stdafx.h"
2. #include <iostream>
3. #include <set>
4. using namespace std;
5. int main ()
6. {
7. set<int> myset;
8. for (int i=1; i<=5; i++) myset.insert(i*10);   // myset: 10 20 30 40 50
9. pair<set<int>::const_iterator,set<int>::const_iterator> ret;
10. ret = myset.equal_range(30);
11. cout << "the lower bound points to: " << *ret.first << '\n';
12. cout << "the upper bound points to: " << *ret.second << '\n';
13. return 0;
14. }

1. #include "stdafx.h"
2. #include <iostream>
3. #include <set>
4. using namespace std;
5. int main ()
6. {
7. int myints[]={12,75,10,32,20,25};
8. set<int> first (myints,myints+3);     // 10,12,75
9. set<int> second (myints+3,myints+6);  // 20,25,32
10. first.swap(second);
11. cout << "first contains:";
12. for (set<int>::iterator it=first.begin(); it!=first.end(); ++it)
13. cout << ' ' << *it;
14. cout << '\n';
15. cout << "second contains:";
16. for (set<int>::iterator it=second.begin(); it!=second.end(); ++it)
17. cout << ' ' << *it;
18. cout << '\n';
19. return 0;
20. }

21. 自从VS2010开始，set的iterator类型自动就是const的引用类型，因此当set保存的是类类型时，对iterator解引用无法调用类的非const成员。

    解决方法为：

    1. //item是一个类，bool isEnd()是Item的一个成员
    2. for (set<Item>::iterator i = ItemSet.begin(); i != ItemSet.end(); i++)
    3. {
    4. const Item &item1 = const_cast<Item&>(*i);
    5. Item  &item2 = const_cast<Item&>(item1);
    6. if (item2.isEnd())
    7. {//do something}
    const_cast:(转自百度百科)
    用法：const_cast<type_id> (expression)
    该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。
    一、常量指针被转化成非常量的指针，并且仍然指向原来的对象；
    二、常量引用被转换成非常量的引用，并且仍然指向原来的对象；

    为什么要设置为const reference?

    转自：http://stackoverflow.com/questions/2523139/const-references-when-dereferencing-iterator-on-set-starting-from-visual-studio

    The iterator should give you a const reference (and that's what the Standard says it should do), because changing the thing referred to would destroy the validity of the set's underlying data structure - the set doesn't "know" that the field you are changing is not actually part of the key. The alternatives are to make changes by removing and re-adding, or to use a std::map instead.

    因为改变引用指向的对象会破坏set隐藏的数据结构的正确性。