程序博客网 > 中山淘宝电商培训机构

vector interator map set(multiset)

来源：互联网 发布：中山淘宝电商培训机构 编辑：程序博客网 时间：2024/06/05 14:08
   map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，后边我们会见识到有序的好处。
下面举例说明什么是一对一的数据映射。比如一个班级中，每个学生的学号跟他的姓名就存在着一一映射的关系，这个模型用map可能轻易描述，很明显学号用int描述，姓名用字符串描述(本篇文章中不用char *来描述字符串，而是采用STL中string来描述),下面给出map描述代码：
[cpp] view plaincopy
  1. map<int, string> mapStudent;  
1.map的构造函数
map共提供了6个构造函数，这块涉及到内存分配器这些东西，略过不表，在下面我们将接触到一些map的构造方法，这里要说下的就是，我们通常用如下方法构造一个map：
[cpp] view plaincopy
  1. map<int, string> mapStudent;  
2.数据的插入
在构造map容器后，我们就可以往里面插入数据了。这里讲三种插入数据的方法：
第一种：用insert函数插入pair数据，下面举例说明(以下代码虽然是随手写的，应该可以在VC和GCC下编译通过，大家可以运行下看什么效果，在VC下请加入这条语句，屏蔽4786警告  #pragma warning (disable:4786) )
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.        map<int, string> mapStudent;//pair<int,string>p;p=make_pair(v1,v2);<span style="color: rgb(255, 0, 0); background-color: rgb(240, 248, 255); font-family: Arial; font-size: 13px; "> </span>  
  8.        mapStudent.insert(pair<int, string>(1, "student_one"));  
  9.        mapStudent.insert(pair<int, string>(2, "student_two"));  
  10.        mapStudent.insert(pair<int, string>(3, "student_three"));  
  11.        map<int, string>::iterator  iter;  
  12.        for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)  
  13.        {  
  14.           cout<<iter->first<<"  "<<iter->second<<endl;  
  15.        }  
  16. }  

[cpp] view plaincopy
  1. make_pair()//返回类型为对应的pair类型  
  2. 无需写出类别，就可以生成一个pair对象  
  3. 例：  
  4. make_pair(1,'@')  
  5. 而不必费力的写成  
  6. pair<int ,char>(1,'@')  
第二种：用insert函数插入value_type数据，下面举例说明
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.        map<int, string> mapStudent;  
  8.        mapStudent.insert(map<int, string>::value_type (1, "student_one"));  
  9.        mapStudent.insert(map<int, string>::value_type (2, "student_two"));  
  10.        mapStudent.insert(map<int, string>::value_type (3, "student_three"));  
  11.        map<int, string>::iterator  iter;  
  12.        for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)  
  13.        {  
  14.            cout<<iter->first<<" "<<iter->second<<endl;  
  15.        }  
  16. }  
第三种：用数组方式插入数据，下面举例说明
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.        map<int, string> mapStudent;  
  8.        mapStudent[1] =  "student_one";  
  9.        mapStudent[2] =  "student_two";  
  10.        mapStudent[3] =  "student_three";  
  11.        map<int, string>::iterator  iter;  
  12.        for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)  
  13.        {  
  14.           cout<<iter->first<<"   "<<iter->second<<endl;  
  15.        }  
  16. }  
以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的，当然了第一种和第二种在效果上是完成一样的，用insert函数插入数据，在数据的插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是插入数据不了的，但是用数组方式就不同了，它可以覆盖以前该关键字对应的值，用程序说明
[cpp] view plaincopy
  1. mapStudent.insert(map<int, string>::value_type (1, "student_one"));  
  2. mapStudent.insert(map<int, string>::value_type (1, "student_two"));  
上面这两条语句执行后，map中1这个关键字对应的值是"student_one"，第二条语句并没有生效，那么这就涉及到我们怎么知道insert语句是否插入成功的问题了，可以用pair来获得是否插入成功，程序如下
[cpp] view plaincopy
  1. Pair<map<int, string>::iterator, bool> Insert_Pair;  
  2. Insert_Pair = mapStudent.insert(map<int, string>::value_type (1, "student_one"));  
我们通过pair的第二个变量来知道是否插入成功，它的第一个变量返回的是一个map的迭代器，如果插入成功的话Insert_Pair.second应该是true的，否则为false。
下面给出完成代码，演示插入成功与否问题
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.        map<int, string> mapStudent;  
  8.        Pair<map<int, string>::iterator, bool> Insert_Pair;  
  9.        Insert_Pair ＝ mapStudent.insert(pair<int, string>(1, "student_one"));  
  10.        If(Insert_Pair.second == true)  
  11.        {  
  12.              cout<<"Insert Successfully"<<endl;  
  13.        }  
  14.        Else  
  15.        {  
  16.               cout<<"Insert Failure"<<endl;  
  17.        }  
  18.        Insert_Pair ＝ mapStudent.insert(pair<int, string>(1, "student_two"));  
  19.        If(Insert_Pair.second == true)  
  20.        {  
  21.               cout<<"Insert Successfully"<<endl;  
  22.        }  
  23.        Else  
  24.        {  
  25.               cout<<"Insert Failure"<<endl;  
  26.        }  
  27.        map<int, string>::iterator  iter;  
  28.        for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)  
  29.        {  
  30.             cout<<iter->first<<"   "<<iter->second<<endl;  
  31.        }  
  32. }  
大家可以用如下程序，看下用数组插入在数据覆盖上的效果
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.        map<int, string> mapStudent;  
  8.        mapStudent[1] =  "student_one";  
  9.        mapStudent[1] =  "student_two";  
  10.        mapStudent[2] =  "student_three";  
  11.        map<int, string>::iterator  iter;  
  12.        for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)  
  13.        {  
  14.           cout<<iter->first<<"   "<<iter->second<<endl;  
  15.        }  
  16. }  
3.map的大小
在往map里面插入了数据，我们怎么知道当前已经插入了多少数据呢，可以用size函数，用法如下：
[cpp] view plaincopy
  1. int nSize = mapStudent.size();  
4.数据的遍历
这里也提供三种方法，对map进行遍
第一种：应用前向迭代器，上面举例程序中到处都是了，略过不表
第二种：应用反相迭代器，下面举例说明，要体会效果，请自个动手运行程序
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.        map<int, string> mapStudent;  
  8.        mapStudent.insert(pair<int, string>(1, "student_one"));  
  9.        mapStudent.insert(pair<int, string>(2, "student_two"));  
  10.        mapStudent.insert(pair<int, string>(3, "student_three"));  
  11.        map<int, string>::reverse_iterator  iter;  
  12.        for(iter = mapStudent.rbegin(); iter != mapStudent.rend(); iter++)  
  13.        {  
  14.           cout<<iter->first<<"   "<<iter->second<<endl;  
  15.        }  
  16. }  
第三种：用数组方式，程序说明如下
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.        map<int, string> mapStudent;  
  8.        mapStudent.insert(pair<int, string>(1, "student_one"));  
  9.        mapStudent.insert(pair<int, string>(2, "student_two"));  
  10.        mapStudent.insert(pair<int, string>(3, "student_three"));  
  11.        int nSize = mapStudent.size()  
  12. //此处有误，应该是 for(int nIndex = 1; nIndex <= nSize; nIndex++)   
  13. //by rainfish  
  14.        for(int nIndex = 0; nIndex < nSize; nIndex++)  
  15.        {  
  16.            cout<<mapStudent[nIndex]<<end;  
  17.        }  
  18. }  
5.数据的查找（包括判定这个关键字是否在map中出现）
在这里我们将体会，map在数据插入时保证有序的好处。
要判定一个数据（关键字）是否在map中出现的方法比较多，这里标题虽然是数据的查找，在这里将穿插着大量的map基本用法。
这里给出三种数据查找方法
第一种：用count函数来判定关键字是否出现，其缺点是无法定位数据出现位置,由于map的特性，一对一的映射关系，就决定了count函数的返回值只有两个，要么是0，要么是1，出现的情况，当然是返回1了
第二种：用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器，程序说明
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.        map<int, string> mapStudent;  
  8.        mapStudent.insert(pair<int, string>(1, "student_one"));  
  9.        mapStudent.insert(pair<int, string>(2, "student_two"));  
  10.        mapStudent.insert(pair<int, string>(3, "student_three"));  
  11.        map<int, string>::iterator iter;  
  12.        iter = mapStudent.find(1);  
  13.        if(iter != mapStudent.end())  
  14.       {  
  15.            cout<<"Find, the value is "<<iter->second<<endl;  
  16.        }  
  17.        Else  
  18.        {  
  19.            cout<<"Do not Find"<<endl;  
  20.        }  
  21. }  
第三种：这个方法用来判定数据是否出现，是显得笨了点，但是，我打算在这里讲解
Lower_bound函数用法，这个函数用来返回要查找关键字的下界(是一个迭代器)
Upper_bound函数用法，这个函数用来返回要查找关键字的上界(是一个迭代器)
例如：map中已经插入了1，2，3，4的话，如果lower_bound(2)的话，返回的2，而upper-bound（2）的话，返回的就是3
Equal_range函数返回一个pair，pair里面第一个变量是Lower_bound返回的迭代器，pair里面第二个迭代器是Upper_bound返回的迭代器，如果这两个迭代器相等的话，则说明map中不出现这个关键字，程序说明
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.        map<int, string> mapStudent;  
  8.        mapStudent[1] =  "student_one";  
  9.        mapStudent[3] =  "student_three";  
  10.        mapStudent[5] =  "student_five";  
  11.        map<int, string>::iterator  iter;  
  12.        iter = mapStudent.lower_bound(2);  
  13.       {  
  14.        //返回的是下界3的迭代器  
  15.        cout<<iter->second<<endl;  
  16.        }  
  17.        iter = mapStudent.lower_bound(3);  
  18.        {  
  19.        //返回的是下界3的迭代器  
  20.        cout<<iter->second<<endl;  
  21.        }  
  22.         iter = mapStudent.upper_bound(2);  
  23.        {  
  24.        //返回的是上界3的迭代器  
  25.         cout<<iter->second<<endl;  
  26.        }  
  27.        iter = mapStudent.upper_bound(3);  
  28.       {  
  29.        //返回的是上界5的迭代器  
  30.        cout<<iter->second<<endl;  
  31. }  
  32.       Pair<map<int, string>::iterator, map<int, string>::iterator> mapPair;  
  33.       mapPair = mapStudent.equal_range(2);  
  34.       if(mapPair.first == mapPair.second)  
  35.       {  
  36.           cout<<"Do not Find"<<endl;  
  37.        }  
  38.        Else  
  39.        {  
  40.             cout<<"Find"<<endl;  
  41.         }  
  42.        mapPair = mapStudent.equal_range(3);  
  43.        if(mapPair.first == mapPair.second)  
  44.        {  
  45.             cout<<"Do not Find"<<endl;  
  46.         }  
  47.        Else  
  48.        {  
  49.            cout<<"Find"<<endl;  
  50.        }  
  51. }  
6.  数据的清空与判空
清空map中的数据可以用clear()函数，判定map中是否有数据可以用empty()函数，它返回true则说明是空map
7.  数据的删除
这里要用到erase函数，它有三个重载了的函数，下面在例子中详细说明它们的用法
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.        map<int, string> mapStudent;  
  8.        mapStudent.insert(pair<int, string>(1, "student_one"));  
  9.        mapStudent.insert(pair<int, string>(2, "student_two"));  
  10.        mapStudent.insert(pair<int, string>(3, "student_three"));  
  11.        //如果你要演示输出效果，请选择以下的一种，你看到的效果会比较好  
  12.        //如果要删除1,用迭代器删除  
  13.        map<int, string>::iterator iter;  
  14.        iter = mapStudent.find(1);  
  15.        mapStudent.erase(iter);  
  16.        //如果要删除1，用关键字删除  
  17.        int n = mapStudent.erase(1);//如果删除了会返回1，否则返回0  
  18.        //用迭代器，成片的删除  
  19.        //一下代码把整个map清空  
  20.        mapStudent.earse(mapStudent.begin(), mapStudent.end());  
  21.        //成片删除要注意的是，也是STL的特性，删除区间是一个前闭后开的集合  
  22.      //自个加上遍历代码，打印输出吧  
  23. }  
8.其他一些函数用法
这里有swap,key_comp,value_comp,get_allocator等函数，感觉到这些函数在编程用的不是很多，略过不表，有兴趣的话可以自个研究
9.排序
这里要讲的是一点比较高深的用法了,排序问题，STL中默认是采用小于号来排序的，以上代码在排序上是不存在任何问题的，因为上面的关键字是int型，它本身支持小于号运算，在一些特殊情况，比如关键字是一个结构体，涉及到排序就会出现问题，因为它没有小于号操作，insert等函数在编译的时候过不去，下面给出两个方法解决这个问题
第一种：小于号重载，程序举例
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. uing namespace std;  
  4. Typedef struct tagStudentInfo  
  5. {  
  6.        int      nID;  
  7.        String   strName;  
  8. }StudentInfo, *PStudentInfo;  //学生信息  
  9. int main()  
  10. {  
  11.        int nSize;  
  12.        //用学生信息映射分数  
  13.        map<StudentInfo, int>mapStudent;  
  14.        map<StudentInfo, int>::iterator iter;  
  15.        StudentInfo studentInfo;  
  16.        studentInfo.nID = 1;  
  17.        studentInfo.strName = "student_one"  
  18.        mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));  
  19.        studentInfo.nID = 2;  
  20.        studentInfo.strName = "student_two";  
  21.        mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));  
  22.        for (iter=mapStudent.begin(); iter!=mapStudent.end(); iter++)  
  23.          cout<<iter->first.nID<<endl<<iter->first.strName<<endl<<iter->second<<endl;  
  24. }  
以上程序是无法编译通过的，只要重载小于号，就OK了，如下：
[cpp] view plaincopy
  1. Typedef struct tagStudentInfo  
  2. {  
  3.        int      nID;  
  4.        String   strName;  
  5.        Bool operator < (tagStudentInfo const& _A) const  
  6.        {  
  7.               //这个函数指定排序策略，按nID排序，如果nID相等的话，按strName排序  
  8.               If(nID < _A.nID)  return true;  
  9.               If(nID == _A.nID) return strName.compare(_A.strName) < 0;  
  10.               Return false;  
  11.        }  
  12. }StudentInfo, *PStudentInfo;  //学生信息  
第二种：仿函数的应用，这个时候结构体中没有直接的小于号重载，程序说明
[cpp] view plaincopy
  1. #include <map>  
  2. #include <string>  
  3. using namespace std;  
  4. Typedef struct tagStudentInfo  
  5. {  
  6.        int      nID;  
  7.        String   strName;  
  8. }StudentInfo, *PStudentInfo;  //学生信息  
  9. class sort  
  10. {  
  11.        Public:  
  12.        Bool operator() (StudentInfo const &_A, StudentInfo const &_B) const  
  13.        {  
  14.               If(_A.nID < _B.nID) return true;  
  15.               If(_A.nID == _B.nID) return _A.strName.compare(_B.strName) < 0;  
  16.               Return false;  
  17.        }  
  18. };  
  19. int main()  
  20. {  
  21.        //用学生信息映射分数  
  22.        map<StudentInfo, int, sort>mapStudent;  
  23.        StudentInfo studentInfo;  
  24.        studentInfo.nID = 1;  
  25.        studentInfo.strName = "student_one";  
  26.        mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));  
  27.        studentInfo.nID = 2;  
  28.        studentInfo.strName = "student_two";  
  29.        mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));  
  30. }  
10.另外
由于STL是一个统一的整体，map的很多用法都和STL中其它的东西结合在一起，比如在排序上，这里默认用的是小于号，即less<>，如果要从大到小排序呢，这里涉及到的东西很多，在此无法一一加以说明。
还要说明的是，map中由于它内部有序，由红黑树保证，因此很多函数执行的时间复杂度都是log2N的，如果用map函数可以实现的功能，而STL  Algorithm也可以完成该功能，建议用map自带函数，效率高一些。

下面说下，map在空间上的特性，否则，估计你用起来会有时候表现的比较郁闷，由于map的每个数据对应红黑树上的一个节点，这个节点在不保存你的数据时，是占用16个字节的，一个父节点指针，左右孩子指针，还有一个枚举值（标示红黑的，相当于平衡二叉树中的平衡因子），我想大家应该知道，这些地方很费内存了。






1 set和multiset容器的能力
set 和multiset容器的内部结构通常由平衡二叉树(balancedbinary tree)来实现。当元素放入容器中时，会按照一定的排序法则自动排序，默认是按照less<>排序规则来排序。这种自动排序的特性加速了元素查找的过程，但是也带来了一个问题：不可以直接修改set或multiset容器中的元素值，因为这样做就可能违反了元素自动排序的规则。如果你希望修改一个元素的值，必须先删除原有的元素，再插入新的元素。

2 set和multiset容器的操作
Constructor and Destructor

[cpp] view plaincopy
  1. set c:创建一个空的set或multiset容器  
  2. set c(op):创建一个空的使用op作为排序法则的set或multiset容器  
  3. set c1(c2):创建一个已存在的set或multiset容器的复制品，容器的类型和所有元素一同复制  
  4. set c(beg, end):创建一个set或multiset容器，并且以[beg, end)范围中的元素进行初始化  
  5. set c(beg, end, op):创建一个使用op作为排序法则的set或multiset容器，并且以[beg, end)范围中的元素进行初始化  
  6. c.~set():容器的析构函数，销毁所有的元素，释放所有的分配内存  

上面的set可以是下面几种形式：

[cpp] view plaincopy
  1. set<type>:以less<>为排序法则的set  
  2. set<type, op>:以op为排序法则的set  
  3. multiset<type>:以less<>为排序法则的multiset  
  4. multiset<type, op>:以op为排序法则的multiset  

从上面我们可以看到，可以从两个地方来指定排序法则：

（1）作为模板参数

例如：std::set<int, greater<int> > col1;

这种情况下，排序法则本身作为容器类型的一部分。对于一个set或者multiset容器，只有当元素类型和排序法则类型都相同时，他们的类型才被认为相同，否则就是不同类型的容器。

（2）作为构造函数参数
例如：std::set<int> col1(greater<int>);

这种情况下指定的排序法则不作为容器类型的一部分，你可以为相同类型的容器指定不同的排序规则。这通常应用于要求相同的容器类型，但排序规则可以不同的场合。

Size and Comparing
set 和multiset容器同样提供size(), empty(), max_size()三个关于查询元素数目的接口，提供==,!=, <, <=, >, >=等比较操作符。但值得注意的是比较操作符只针对相同类型的容器，元素类型和排序法则类型都必须相同。

Special Search Operations
set和multiset容器的内部结构对于元素的查找提供了优化空间，所以它们提供了一些特殊的查找接口，这些查找操作通常要比同名的通用算法高效，所以在相同的条件下应该优先使用这些接口。

[cpp] view plaincopy
  1. count(val): 返回容器中值等于val的元素数目。  
  2. find(val): 返回容器中值等于val的第一个元素的iterator位置；如果没有匹配元素，则返回end()位置。  
  3. lower_bound(val): 返回容器中第一个值大于或等于val的元素的iterator位置。  
  4. upper_bound(val): 返回容器中第一个值大于val的元素的iterator位置。  
  5. equal_range(val): 返回容器中值等于val的所有元素的范围[beg, end)组成的pair<beg, end> 。  

下面我们看一个使用lower_bound(), upper_bound和equal_range(val)例子，以加深对它们的理解：

[cpp] view plaincopy
  1. #include <iostream>  
  2. #include <set>  
  3. #include "print.hpp"  
  4. using namespace std;  
  5. int main()  
  6. {  
  7.     multiset<int> col1;  
  8.    
  9.     col1.insert(2);  
  10.     col1.insert(5);  
  11.     col1.insert(4);  
  12.     col1.insert(6);  
  13.     col1.insert(1);  
  14.     col1.insert(5);  
  15.    
  16.     PRINT_ELEMENTS(col1, "col1:");  
  17.     cout << endl;  
  18.    
  19.     multiset<int>::const_iteratorpos;  
  20.     pair<multiset<int>::iterator,multiset<int>::iterator> range;  
  21.    
  22.     cout << "lower_bound(3):" << *col1.lower_bound(3) << endl;  
  23.     cout << "upper_bound(3):" << *col1.upper_bound(3) << endl;  
  24.     range = col1.equal_range(3);  
  25.     cout << "equal_range(3):" << *range.first << " " << *range.second<< endl;  
  26.     cout << "elements withvalue(3): ";  
  27.     for (pos = range.first; pos !=range.second; ++pos)  
  28.     {  
  29.         cout << *pos<< " ";  
  30.     }  
  31.     cout << endl;  
  32.     cout << endl;  
  33.    
  34.     cout << "lower_bound(5):" << *col1.lower_bound(5) << endl;  
  35.     cout << "upper_bound(5):" << *col1.upper_bound(5) << endl;  
  36.     range = col1.equal_range(5);  
  37.     cout << "equal_range(5):" << *range.first << " " << *range.second<< endl;  
  38.     cout << "elements withvalue(5): ";  
  39.     for (pos = range.first; pos !=range.second; ++pos)  
  40.     {  
  41.         cout << *pos<< " ";  
  42.     }  
  43.     cout << endl;  
  44. }  
  45. 执行结果如下：  
  46. col1: 1 2 4 5 5 6   
  47.    
  48. lower_bound(3): 4  
  49. upper_bound(3): 4  
  50. equal_range(3): 4 4  
  51. elements with value(3):   
  52.    
  53. lower_bound(5): 5  
  54. upper_bound(5): 6  
  55. equal_range(5): 5 6  
  56. elements with value(5): 5 5   

Assignment
set和multiset容器只提供最基本的赋值操作：

[cpp] view plaincopy
  1. c1 = c2: 把c2的所有元素复制到c1中，同时c1原有的元素被销毁。  
  2. c1.swap(c2): 交换c1和c2的元素。  
  3. swap(c1, c2): 同上，只不过这是一个通用算法。  

需要注意的是两个容器的类型要一致（包括元素类型和排序法则类型）。

Inserting and Removing Elements
set和multiset容器的插入和删除元素接口跟其他容器也非常类似，但在细节上却存在差别。

[cpp] view plaincopy
  1. c.insert(elem): 在容器中插入元素elem的一份拷贝，并返回新元素的iterator位置；如果是set容器，同时还返回是否插入成功的标志。  
  2. c.insert(pos, elem): 在容器中插入元素elem的一份拷贝，并返回新元素的iterator位置；因为set和multiset容器的元素是自动排序的，所以pos位置只是插入位置的一                          个提 示，设置恰当的话，可以提高插入元素的效率。  
  3. c.insert(beg, end): 在容器中插入[beg, end)范围中所有元素的拷贝，没有返回值。  
  4. c.erase(val): 删除容器中所有值为val的元素，返回删除元素的数目。  
  5. c.erase(pos): 删除容器中位置pos处的元素，没有返回值。  
  6. c.erase(beg, end): 删除容器中[ben, end)范围内所有的元素，没有返回值。  
  7. c.clear(): 删除容器中所有元素，使容器成为空容器。  

其中我们重点说一下c.insert(elem)接口。

对于set容器，它的定义如下：

pair<iterator, bool> insert(const TYPE& val);

而对于multiset容器，它的定义如下：

iterator insert(const TYPE& val);

它 们的不同就是set容器的insert接口返回的是一个pair<iterator,bool>，而multiset容器的insert接口直接返回一个iterator。这是因为set容器中不允许有重复的元素，如果容器中已经存在一个跟插入值相同的元素，那么插入操作就会失败，而pair中的bool值就是标识插入是否成功的。而multiset不存在这个问题。

3 set和multiset容器的异常处理

因为set和multiset容器的独特内部结构，当发生异常时，也可以把影响减到最小。也就是说，跟list容器一样，set和multiset容器的操作要么成功，要么对原有容器没有影响。

4 运行时指定排序法则

通常情况下，我们是在定义容器时指定排序法则，就像下面形式：

std::set<int, greater<int> > col1;

或者

std::set<int> col1;    //use defaultsorting criterion less<>

 

然而，如果你需要在运行时动态指定容器的排序法则，或者你希望对于相同的容器类型却有着不同的排序法则，那么就要做一些特殊处理。下面我们看一个例子：

[cpp] view plaincopy
  1. #include <iostream>  
  2. #include <set>  
  3. #include "print.hpp"  
  4. using namespace std;  
  5.    
  6. template <typename T>  
  7. class RuntimeCmp   
  8. {  
  9.     public:  
  10.         enum cmp_mode {normal,reverse};  
  11.     private:  
  12.         cmp_mode mode;  
  13.     public:  
  14.         RuntimeCmp(cmp_mode m =normal) : mode(m) {}  
  15.    
  16.         bool operator() (constT& t1, const T& t2)  
  17.         {  
  18.             returnmode == normal ? t1 < t2 : t1 > t2;  
  19.         }  
  20.    
  21.         bool operator== (constT& rhv)   
  22.         {  
  23.             returnmode == rhv.mode;  
  24.         }  
  25. };  
  26.    
  27. typedef set<int, RuntimeCmp<int> > IntSet;  
  28.    
  29. //pre-declare  
  30. void fill(IntSet& col1);  
  31.    
  32. int main()  
  33. {  
  34.     IntSet col1;  
  35.     fill(col1);  
  36.     PRINT_ELEMENTS(col1, "col1:");  
  37.    
  38.     RuntimeCmp<int>reverse_cmp(RuntimeCmp<int>::reverse);  
  39.     IntSet col2(reverse_cmp);  
  40.     fill(col2);  
  41.     PRINT_ELEMENTS(col2, "col2:");  
  42.    
  43.     if (col1 == col2)   
  44.     {  
  45.         cout << "col1and col2 is equal" <<endl;  
  46.     }  
  47.     else  
  48.     {  
  49.         if (col1 <col2)   
  50.         {  
  51.             cout<< "col1 is less than col2" << endl;  
  52.         }  
  53.         else   
  54.         {  
  55.             cout<< "col1 is greater than col2" << endl;  
  56.         }  
  57.     }  
  58.     return 0;  
  59. }  
  60.    
  61. void fill(IntSet& col1)   
  62. {  
  63.     col1.insert(2);  
  64.     col1.insert(3);  
  65.     col1.insert(6);  
  66.     col1.insert(5);  
  67.     col1.insert(1);  
  68.     col1.insert(4);  
  69. }  
  70. 运行结果如下：  
  71. col1 1 2 3 4 5 6   
  72. col2 6 5 4 3 2 1   
  73. col1 is less than col2  

这里例子中，col1和col2有着相同的类型：set<int,RuntimeCmp<int> >，但是它们的排序法则却不相同，一个升序，一个降序。这都是通过自定义的函数对象来实现的，所以函数对象比普通函数有着更加灵活与强大的控制，可以满足一些特殊的需求。




参考文章：

《map的详细用法》 http://blog.csdn.net/sunshinewave/article/details/8067862

《set和multiset容器》http://blog.csdn.net/sunshinewave/article/details/8068181

《聊聊map和vector的迭代器失效问题（某公司招聘笔试试题）》

http://blog.csdn.net/stpeace/article/details/46507451

0 0
中山淘宝电商培训机构 中山淘宝电商培训机构
原创粉丝点击
热门IT博客
python基础教程pdfpython基础教程pdf
行知职高宿舍样子行知职高宿舍样子
stereonet软件百度云
全球地区数据库
2016年达内java百度云
制图软件学习
nba2k13捏脸详细数据
校招mysql面试题及答案
mac怎么退出qq
仿有赞前端源码
屠龙大陆翅膀进阶数据
文化部网络直播黑名单
规模以上 知乎
淘宝网笔袋图片
php变量的作用域
网络包的分析
mac os qq截图
斯巴鲁 森林人 知乎
java 生成json格式嵌套
港灿 知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 感冒了消化不好怎么办 宝宝咳嗽口气重怎么办 1岁宝宝口臭怎么办 脚被压了有淤血怎么办 脚挤肿了怎么办小妙招 口苦怎么办如何治疗 口苦口干口臭怎么办 最近口里有异味怎么办 胃不好有口气怎么办 嗓子有痰口臭怎么办 挤了黑头之后怎么办 手挤黑头后怎么办 泰国去黑头凝固怎么办 鼻子挤完黑头怎么办 鼻子上很多洞洞怎么办 挤黑头鼻子红肿怎么办 早上口苦口臭怎么办 最近口气特别重怎么办 小孩口臭怎么办吃什么 口臭十几年了怎么办 从小就有口臭怎么办 脸上突然长斑怎么办 未成年脸上长斑怎么办 脸上的暗斑怎么办 脸上的斑多怎么办 vv云商输了三万怎么办 孩子动作太慢怎么办 手机屏划不动怎么办 电脑不显示桌面怎么办 百度推广注册了怎么办 ipad总是闪退怎么办 ipad老是闪退怎么办 只有拇指有月牙怎么办 想念逝去的孩子怎么办 官员家属干坏事怎么办 贷款卡丢了怎么办 信用卡还不了钱怎么办 还款卡丢了怎么办 信用卡没有还上怎么办 我的信用卡逾期怎么办 老人死在家里怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里