c++中的关联容器

转载 2015年11月20日 00:21:21

c++中的关联容器主要是map、set,已经multimap、multiset。

为了讲map,得先将pair类型:pair就是一个两个类型的组合,比如一个人的学号就可以是pair<int,string>,其中的int是学号,string是名字。

map就是一个容器,里面装的就是若干个pair。每个pair的第一个元素,称为键(注意键的类型必须支持小于(<)操作!),第二个元素,称为值。对于普通的map,每个键都对应一个值。这样的看起来,键类似于数组的下标,而值类似于数组的值。map类定义了3种类型,分别为key_type、mapped_type、以及vaule_type。他们分别表示了键的类型、值的类型,以及一个pair类型,pair的第一个元素是键,第二个元素是值。

首先讲讲如何给imap添加元素:有两种的方法,使用键(下标)或者使用insert

使用下标这种方法与vector等类型的容器相矛盾。如果是一个空的vector,则不能使用下标直接访问,必须pusn_back进元素才行,直接访问会报错。而对于map如果没有这个键(下标),则会自动的向map中添加这个键,值为0。下标操作的返回值,就是这个键关联的值。利用这个性质,我们可以很方便的完成统计的功能,举个例子:

  1. int main()  
  2. {  
  3.     string str;  
  4.     map<string,int> wordCount;  
  5.     while(cin>>str)  
  6.     {  
  7.         ++wordCount[str];  
  8.     }  
  9.       
  10.     map<string,int>::iterator it_map = wordCount.begin();  
  11.     cout<<"word"<<"\t\t"<<"count"<<endl;  
  12.     for(;it_map != wordCount.end();++it_map)  
  13.         cout<<it_map->first<<"\t\t"<<it_map->second<<endl;  
  14.     return 0;  
  15.   
  16. }  


 

使用时如果键不存在,则赋值为0,然后对其自增。即变成了1。

insert方法有多个重载函数,表明你插入的是一个pair,还是一对迭代器指明的若干个pair,还是插入一个pair到指定的位置,但通常使用的插入一个pair,这个函数最关键是它的返回值。这个返回值也是一个pair,pair的第一个元素是指向该map类型的迭代器,另一个是bool类型的变量,表明插入成功与否。可以用insert重写上面的程序:

 

  1. int main()  
  2. {  
  3.     string str;  
  4.     map<string,int> wordCount;  
  5.     while(cin>>str)  
  6.     {  
  7.         //对于每个单词,都尝试去插入它  
  8.         pair<map<string,int>::iterator,bool>ret = wordCount.insert(make_pair(str,1));  
  9.         //通过检测返回值来判断插入是否成功  
  10.         if(!ret.second)  
  11.             //插入失败表明map中有这个单词,只需要把对应键的值自增即可  
  12.             ++ret.first->second;  
  13.     }  
  14.       
  15.   
  16.     map<string,int>::iterator it_map = wordCount.begin();  
  17.     cout<<"word"<<"\t\t"<<"count"<<endl;  
  18.     for(;it_map != wordCount.end();++it_map)  
  19.         cout<<it_map->first<<"\t\t"<<it_map->second<<endl;  
  20.     return 0;  
  21.   
  22. }  


那么如何读取map的元素呢?虽然我们也可以使用键来读取,但是潜在的问题是如果该键不存在,就会自动创建,这个特点并不是我们所希望的。我们可以通过count或者find函数来查找某个键是否存在。这两个函数的区别在于count返回的是出现的次数(对于map只能为0或者1),而find则返回的是指向该键的迭代器(如果没有找到,返回超末端迭代器:.end())。这意味着如果你是为为了统计是否存在,使用count就可以了,如果你找到某个元素并且还想使用它,那么find会比较合适。

删除元素使用使用erase操作,这与顺序容器差别不大。但是要注意的是,关联容器的顺序是按照“键”排列的。

下面通过一个小程序来说明:

  1. #include <iostream>  
  2. #include <map>  
  3. #include <string>  
  4. #include <vector>  
  5. using namespace std;  
  6.   
  7. int main()  
  8. {  
  9.     string str;  
  10.     map<string,int> wordCount;  
  11.     while(cin>>str)  
  12.     {  
  13.         //对于每个单词,都尝试去插入它  
  14.         pair<map<string,int>::iterator,bool>ret = wordCount.insert(make_pair(str,1));  
  15.         //通过检测返回值来判断插入是否成功  
  16.         if(!ret.second)  
  17.             //插入失败表明map中有这个单词,只需要把对应键的值自增即可  
  18.             ++ret.first->second;  
  19.     }  
  20.       
  21.   
  22.     map<string,int>::iterator it_map = wordCount.begin();  
  23.     cout<<"word"<<"\t\t"<<"count"<<endl;  
  24.     for(;it_map != wordCount.end();++it_map)  
  25.         cout<<it_map->first<<"\t\t"<<it_map->second<<endl;  
  26.   
  27.     //count方法:对于map,返回1或者0  
  28.     int cnt = 0;  
  29.     cnt = wordCount.count("bird");  
  30.     cout<<"cnt"<<cnt<<endl;  
  31.   
  32.     //find方法:返回的是指向键的迭代器  
  33.     int occurs = 0;  
  34.     map<string,int>::iterator it = wordCount.find("bird");  
  35.     if(it != wordCount.end())  
  36.         occurs = it->second;  
  37.     cout<<"occurs = "<<occurs<<endl;  
  38.   
  39.   
  40.     //删除元素  
  41.     int del;  
  42.     string s1 = "hate";  
  43.     //使用值删除  
  44.     del = wordCount.erase(s1);  
  45.     if(del)  
  46.         cout<<s1<<" has been removed! "<<endl;  
  47.     else  
  48.         cout<<"can't find the word! "<<endl;  
  49.   
  50.     //使用迭代器删除  
  51.     map<string,int>::iterator iter = wordCount.begin();  
  52.     wordCount.erase(iter);  
  53.   
  54.   
  55.     return 0;  
  56.   
  57. }  


 

说完了map,我们在看看set。set只有键,没有值,所以他的vaule_type不是pair类型,而是key_type类型。同样的,它也支持insert、find、count操作。map比较适合于储存键值对应的情况,而set适合于储存键,判断键在不在这个集合中,比如黑名单之类的。

前面两种关联容器的特点是,键与值的对应关系是唯一的。而multimap或者multiset则支持一对多的关系。而且对于相同的键,总是连续的存储。由于这种一对多关系,所以multimap和multiset支持一些map和set没有的操作。比如lower_bound、upper_bound以及equal_range.它们分别返回的是指向某个键的第一个元素,最后一个元素的下一个元素以及这连个元素组成的范围。看一个综合例子:

  1. #include <iostream>  
  2. #include <map>  
  3. #include <string>  
  4.   
  5. using namespace std;  
  6.   
  7. int main()  
  8. {  
  9.     multimap<string,string> authors;  
  10.     string author,work,searchItem;  
  11.   
  12.     //建立作者及其作品的容器  
  13.     do  
  14.     {  
  15.         cout<<"enter authors name"<<endl;  
  16.         cin>>author;  
  17.         if(!cin)  
  18.             break;  
  19.         cout<<"enter authors works"<<endl;  
  20.         while(cin>>work)  
  21.             authors.insert(make_pair(author,work));  
  22.         cin.clear();  
  23.     }while(cin);  
  24.   
  25.     cin.clear();  
  26.     //删除元素  
  27.   
  28.     cout<<"who is the author that you want erase:"<<endl;  
  29.     cin>>searchItem;  
  30.     /* 
  31.     //使用erase删除:输出对应键的所有值 
  32.     multimap<string,string>::iterator iter = authors.find(searchItem); 
  33.     if(iter != authors.end()) 
  34.         authors.erase(searchItem); 
  35.     else 
  36.         cout<<"cannot find the author!"<<endl; 
  37.     */  
  38.   
  39.     //使用equal_range或得迭代器删除  
  40.     typedef multimap<string,string>::iterator itType;  
  41.     pair<itType,itType> pos = authors.equal_range(searchItem);  
  42.     if(pos.first != pos.second)  
  43.         authors.erase(pos.first,pos.second);  
  44.     else  
  45.         cout<<"can not find this author!"<<endl;  
  46.   
  47.   
  48.     //输出删除结果  
  49.     cout<<"author\t\twork:"<<endl;  
  50.     multimap<string,string>::iterator itbegin = authors.begin();  
  51.     for(;itbegin != authors.end();++itbegin)  
  52.         cout<<itbegin->first<<"\t\t"<<itbegin->second<<endl;  
  53.   
  54.     return 0;  
  55. }  

FROM:  http://blog.csdn.net/thefutureisour/article/details/7683656



C++学习笔记--关联容器

C++标准库提供8个关联容器:map、multimap、unordered_map、unordered_multimap、set、multiset、unordered_set、unordered_mu...
  • du_qi
  • du_qi
  • 2016年08月15日 17:42
  • 551

C++关联容器 map用法

原创作品 转载请注明出处 http://blog.csdn.net/always2015/article/details/44980187关联容器关联容器和顺序容器有着根本的不同:关联容器中...
  • Always2015
  • Always2015
  • 2015年04月10日 15:21
  • 1435

c++关联容器总结

关联容器和顺序容器有着根本的不同:关联容器中的元素是按关键字来保存和访问的。与之相对,顺序容器中的元素是按它们在容器中的位置来顺序保存和访问的。 关联容器支持高效的关键字查找与访问。两个主要的关联容...
  • fengxinlinux
  • fengxinlinux
  • 2017年06月25日 16:49
  • 1657

无序关联容器(C++11)

2012-11-27 15:22 张海龙/袁国忠 译 人民邮电出版社 字号:T| T 《C++Primer Plus(第6版)(中文版)》附录G标准模板库方法和函数:本附录总结了STL容器方法...
  • mind_king
  • mind_king
  • 2014年07月31日 17:57
  • 699

c++ 关联容器

c++ 第十一章:关联容器 2:在c++中,顺序容器和关联容器之间本质的区别在于:关键字,关联容器中的元素是按照关键字来保存的,顺序容器中的元素是按照它们在容器中的位置来保存的。3:我们可以按照关键...
  • yangbodong22011
  • yangbodong22011
  • 2016年02月25日 19:10
  • 523

C++容器(二):关联容器简介

关联容器(associative container)与顺序容器的本质区别在于:关联容器通过键(Key)存储和读取元素,而顺序容器则通过元素在容器中的位置顺序存储和访问元素。虽然,关联容器的大部分行为...
  • YhL_Leo
  • YhL_Leo
  • 2015年10月01日 21:06
  • 3245

[C++]高效使用关联容器的一些建议

关联容器 本文介绍在关联容器中常见的一些的问题以及提升使用关联容器的建议。 1. 理解相等(equality)和等价(equivalence)的区别。 相等是以operator==为基础的。等...
  • stary_yan
  • stary_yan
  • 2016年07月16日 17:57
  • 1311

C++学习笔记-关联容器

关联容器的类型 是map还是set,关键字可不可以重复,是顺序保存元素,还是无序保存元素,组合出来8种关联容器。 map类型是元素是关键字和值对,set是关键字的简单集合 关联容器不支持顺序...
  • jo_lan
  • jo_lan
  • 2015年12月23日 16:17
  • 479

《C++primer(第五版)》学习之路-第十一章:关联容器

【 声明:版权所有,转载请标明出处,请勿用于商业用途。  联系信箱:libin493073668@sina.com】 11.1 使用关联容器 1. 关联容器类型 按关键字有序保...
  • libin1105
  • libin1105
  • 2015年09月26日 12:28
  • 1487

顺序容器和关联容器的比较

1、关于什么是容器,以及容器的分类,下面这两篇博客讲得比较清楚,可以参考一下: (1) C++顺序性容器、关联性容器与容器适配器 (2) C++容器:顺序容器,关联容器 2、关于顺序容器和关联容器...
  • JIEJINQUANIL
  • JIEJINQUANIL
  • 2016年04月17日 21:55
  • 1514
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:c++中的关联容器
举报原因:
原因补充:

(最多只允许输入30个字)