map容器

map 映照容器的数据结构也是采用红黑树来实现的，插入元素的键值不允许重复，比  较函数只对元素的键值进行比较，元素的各项数据可通过键值检索出来。

头文件：#include <map>

map 创建、元素插入和遍历访问

//定义map 对象，当前没有任何元素

map<string,float> m;

//插入元素，按键值的由小到大放入黑白树中

m["Jack"]=98.5;

m["Bomi"]=96.0;

m["Kate"]=97.5;

//前向遍历元素

map<string,float>::iterator it;

for(it=m.begin();it!=m.end();it++)

{

//输出键值与映照数据

cout<<(*it).first<<" : "<<(*it).second<<endl;

}

运行结果：

Bomi : 96

Jack : 98.5

Kate : 97.5

注意：程序编译时，会产生代号为“warning C4786”的警告，“4786”是标记符超长警告的

代号。可以在程序的头文件包含代码的前面使用“#pragma warning(disable:4786)”宏语句，

强制编译器忽略该警告。4786 号警告对程序的正确性和运行并无影响。

map元素的删除：

map 映照容器的erase()删除元素函数，可以删除某个迭代器位置上  的元素、等于某个键值的元素、一个迭代器区间上的所有元素。

也可使用clear()方  法清空map 映照容器。

map<int,char> m;

//插入元素，按键值的由小到大放入黑白树中

m[25]='m';

m[28]='k';

m[10]='x';

m[30]='a';

//删除键值为28 的元素

m.erase(28);

//前向遍历元素

map<int,char>::iterator it;

for(it=m.begin();it!=m.end();it++)

{

//输出键值与映照数据

cout<<(*it).first<<" : "<<(*it).second<<endl;

}

return 0;

}

运行结果：

10 : x

25 : m

30 : a

元素反向遍历：

map<int,char>::reverse_iterator rit;

for(rit=m.rbegin();rit!=m.rend();rit++)

{

//输出键值与映照数据 ，输出时键值从大到小排列

cout<<(*rit).first<<" : "<<(*rit).second<<endl;

}

元素的搜索：

使用 find()方法来搜索某个键值，如果搜索到了，则返回该键值所在的迭代器位置，

否则，返回end()迭代器位置。由于map 采用黑白树数据结构来实现，所以搜索速度是极  快的。

map<int,char>::iterator it;

it=m.find(28);

if(it!=m.end())//搜索到该键值

{

cout<<(*it).first<<" : "<<(*it).second<<endl;                   //这里输出的是28对应的值

}

else

{

cout<<"not found it"<<endl;

}

自定义比较函数：

（默认是按照键值的从小到大插入数据的）

（1）如果元素不是结构体，那么，可以编写比较函数。

//自定义比较函数myComp ，按照键值从大到小插入元素

struct myComp

{

bool operator()(const int &a,const int &b)

{

if(a!=b)return a>b;

else

return a>b;

}

};

map<int,char,myComp> m;

map<int,char,myComp>::iterator it;

for(it=m.begin();it!=m.end();it++)

{

cout<<(*it).first<<" : "<<(*it).second<<endl;

}

（2）如果元素是结构体，那么，可以直接把比较函数写在结构体内。

struct Info

{

string name;

float score;

//重载“<”操作符，自定义排序规则

bool operator < (const Info &a) const

{

//按score 由大到小排列。如果要由小到大排列，使用“>”号即可

return a.score<score;

}

};

int main(int argc, char* argv[])

{

//定义map 对象，当前没有任何元素

map<Info,int> m;

//定义Info 结构体变量

Info info;

//插入元素，按键值的由小到大放入黑白树中

info.name="Jack";

info.score=60;

m[info]=25;

info.name="Bomi";

info.score=80;

m[info]=10;

info.name="Peti";

info.score=66.5;

m[info]=30;

//使用前向迭代器中序遍历map

map<Info,int>::iterator it;

for(it=m.begin();it!=m.end();it++)

{

cout<<(*it).second<<" : ";

cout<<((*it).first).name<<" "<<((*it).first).score<<endl;

}

return 0;

}

运行结果：

10 : Bomi 80

30 : Peti 66.5

25 : Jack 60

用map 实现数字分离：

//定义map 对象，当前没有任何元素

map<char,int> m;

//赋值:字符映射数字

m['0']=0;

m['1']=1;

m['2']=2;

m['3']=3;

m['4']=4;

m['5']=5;

m['6']=6;

m['7']=7;

m['8']=8;

m['9']=9;

/*上面的10 条赋值语句可采用下面这个循环来简化代码编写

for(int j=0;j<10;j++)

{

m['0'+j]=j;

}

*/

string sa,sb;

sa="6234";

int i;

int sum=0;

for(i=0;i<sa.length();i++)

{

sum+=m[sa[i]];

}

cout<<"sum = "<<sum<<endl;           //求出的是各个位数相加之和

return 0;

}

运行结果：

sum = 15

数字映照字符的map 写法：

map<int,char> m;

//赋值:字符映射数字

m[0]='0';

m[1]='1';

m[2]='2';

m[3]='3';

m[4]='4';

m[5]='5';

m[6]='6';

m[7]='7';

m[8]='8';

m[9]='9';

/*上面的10 条赋值语句可采用下面这个循环来简化代码编写

for(int j=0;j<10;j++)

{

m[j]='0'+j;

}

*/

int n=7;

string s="The number is ";

cout<<s + m[n]<<endl;

运行结果：

The number is 7