映射和多重映射基于某一类型Key的键集的存在,提供对T类型的数据进行快速和高效的检索。对map而言,键只是指存储在容器中的某一成员。Map不支持副本键,multimap支持副本键。Map和multimap对象包涵了键和各个键有关的值,键和值的数据类型是不相同的,这与set不同。set中的key和value是Key类型的,而map中的key和value是一个pair结构中的两个分量。
使用map得包含map类所在的头文件:
#include <map> //注意,STL头文件没有扩展名.h
1.1 map的构造
Template<class T1,class T2>
map(); // 默认构造函数
map(const map& m) // 拷贝构造函数
map(iterator begin,iterator end ); //区间构造函数
map(iterator begin,iterator end, const traits& _compare) //带比较谓词的构造函数
map(iterator begin,iterator end, const traits& _compare, const allocator& all) //带分配器
1.2 map定义
1.2.1map的基本定义
map对象是模板类,需要关键字和存储对象两个模板参数:
std:map<int,string> personnel;
这样就定义了一个用int作为索引,并拥有相关联的指向string的指针.
为了使用方便,可以对模板类进行一下类型定义:
typedef map<int,CString> UDT_MAP_INT_CSTRING;
UDT_MAP_INT_CSTRING enumMap; //后面会依此例说明
1.2.2 map的嵌套定义
map<sring,map<string,long>> //注意:最后两个>之间有个空格
map支持下标运算符operator[],用访问普通数组的方式来访问map;不过下标为map的键,在multimap中一个键可以对应多个不同的值。
2.1 在map中插入元素
三种插入方式:
2.1.1用insert方法插入pair对象:
enumMap.insert(pair<int,Cstring>(1, “One”));
2.1.2 用insert方法插入value_type对象:
enumMap.insert(map<int,Cstring>::value_type (1, “One”));
2.1.3 用数组方式插入值:
enumMap[1] ="One";
enumMap[2] ="Two";
......
这样非常直观,但存在一个性能的问题。插入2时,先在enumMap中查找主键为2的项,没发现,然后将一个新的对象插入enumMap,键是2,值是一个空字符串,插入完成后,将字符串赋为"Two";该方法会将每个值都赋为缺省值,然后再赋为显示的值,如果元素是类对象,则开销比较大。用前两种方法可以避免开销。
2.2 查找并获取map中元素
2.2.1下标操作符给出了获得一个值的最简单方法:
CString tmp = enumMap[2];
但是,只有当map中有这个键的实例时才对,否则会自动插入一个实例,值为初始化值。
2.2.2我们可以使用find()和count()方法来发现一个键是否存在
查找map中是否包含某个关键字条目用find()方法,传入的参数是要查找的key,在这里需要提到的是begin()和end()两个成员,分别代表map对象中第一个条目和最后一个条目,这两个数据的类型是iterator.
int nFindKey = 2; //要查找的Key
//定义一个条目变量(实际是指针)
UDT_MAP_INT_CSTRING::iteratorit= enumMap.find(nFindKey);
if(it == enumMap.end()) {
cout<<"没找到"<<endl;
}
else {
cout<<"找到了"<<endl;
}
通过map对象的方法获取的iterator数据类型是一个std::pair对象,包括两个数据。
iterator->first 关键字(key)
iterator->second 存储的数据(value)
2.3 从map中删除元素
2.3.1移除某个map中某个条目用erase()
该成员方法的定义如下:
1.iterator erase(iteratorit); //通过一个条目对象删除
2.iterator erase(iteratorfirst, iterator last); //删除一个范围
3.size_type erase(constKey& key); //通过关键字删除
2.3.2清除所有的元素clear()
clear()就相当于enumMap.erase(enumMap.begin(), enumMap.end());
2.4 map中swap的用法
map中的swap不是一个容器中的元素交换,而是两个容器交换;
For example:
#include <map>
#include <iostream>
using namespace std;
int main( )
{
map <int, int> m1,m2, m3;
map <int,int>::iterator m1_Iter;
m1.insert ( pair <int,int> ( 1, 10 ) );
m1.insert ( pair <int,int> ( 2, 20 ) );
m1.insert ( pair <int,int> ( 3, 30 ) );
m2.insert ( pair <int,int> ( 10, 100 ) );
m2.insert ( pair <int,int> ( 20, 200 ) );
m3.insert ( pair <int,int> ( 30, 300 ) );
cout << "Theoriginal map m1 is:";
for ( m1_Iter = m1.begin(); m1_Iter != m1.end( ); m1_Iter++ )
cout << "" << m1_Iter->second;
cout <<"." << endl;
// This is the memberfunction version of swap
//m2 is said to be theargument map; m1 the target map
m1.swap( m2 );
cout << "Afterswapping with m2, map m1 is:";
for ( m1_Iter = m1.begin(); m1_Iter != m1.end( ); m1_Iter++ )
cout << "" << m1_Iter -> second;
cout <<"." << endl;
cout << "Afterswapping with m2, map m2 is:";
for ( m1_Iter = m2.begin(); m1_Iter != m2.end( ); m1_Iter++ )
cout << "" << m1_Iter -> second;
cout <<"." << endl;
// This is thespecialized template version of swap
swap( m1, m3 );
cout << "Afterswapping with m3, map m1 is:";
for ( m1_Iter = m1.begin(); m1_Iter != m1.end( ); m1_Iter++ )
cout << "" << m1_Iter -> second;
cout <<"." << endl;
}
2.5 map的sort问题
Map中的元素是自动按key升序排序,所以不能对map用sort函数:
For example:
#include <map>
#include <iostream>
using namespace std;
int main( )
{
map <int, int> m1;
map <int,int>::iterator m1_Iter;
m1.insert ( pair <int,int> ( 1, 20 ) );
m1.insert ( pair <int,int> ( 4, 40 ) );
m1.insert ( pair <int,int> ( 3, 60 ) );
m1.insert ( pair <int,int> ( 2, 50 ) );
m1.insert ( pair <int,int> ( 6, 40 ) );
m1.insert ( pair <int,int> ( 7, 30 ) );
cout << "Theoriginal map m1 is:"<<endl;
for ( m1_Iter = m1.begin(); m1_Iter != m1.end( ); m1_Iter++ )
cout <<m1_Iter->first<<" "<<m1_Iter->second<<endl;
}
The original map m1 is:
1 20
2 50
3 60
4 40
6 40
7 30
请按任意键继续. . .
2.6 map的基本操作函数
C++ Maps是一种关联式容器,包含“关键字/值”对
begin() 返回指向map头部的迭代器
clear() 删除所有元素
count() 返回指定元素出现的次数
empty() 如果map为空则返回true
end() 返回指向map末尾的迭代器
equal_range() 返回特殊条目的迭代器对
erase() 删除一个元素
find() 查找一个元素
get_allocator() 返回map的配置器
insert() 插入元素
key_comp() 返回比较元素key的函数
lower_bound() 返回键值>=给定元素的第一个位置
max_size() 返回可以容纳的最大元素个数
rbegin() 返回一个指向map尾部的逆向迭代器
rend() 返回一个指向map头部的逆向迭代器
size() 返回map中元素的个数
swap() 交换两个map
upper_bound() 返回键值>给定元素的第一个位置
value_comp() 返回比较元素value的函数
#include <iostream>
#include <map>
using namespace std;
int main(void)
{
map<char,int,less<char>> map1;
map<char,int,less<char>>::iterator mapIter;
//char 是键的类型,int是值的类型
//下面是初始化,与数组类似
//也可以用map1.insert(map<char,int,less<char>>::value_type('c',3));
map1['c']=3;
map1['d']=4;
map1['a']=1;
map1['b']=2;
for(mapIter=map1.begin();mapIter!=map1.end();++mapIter)
cout<<""<<(*mapIter).first<<": "<<(*mapIter).second;
//first对应定义中的char键,second对应定义中的int值
//检索对应于d键的值是这样做的:
map<char,int,less<char>>::const_iterator ptr;
ptr=map1.find('d');
cout<<''\n''<<""<<(*ptr).first<<" 键对应于值:"<<(*ptr).second;
cin.get();
return 0;
}
从以上例程中,我们可以看到map对象的行为和一般数组的行为类似。Map允许两个或多个值使用比较操作符。下面我们再看看multimap:
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main(void)
{
multimap<string,string,less<string>>mulmap;
multimap<string,string,less<string>>::iterator p;
//初始化多重映射mulmap:
typedefmultimap<string,string,less<string> >::value_type vt;
typedef string s;
mulmap.insert(vt(s("Tom"),s("is a student")));
mulmap.insert(vt(s("Tom"),s("is a boy")));
mulmap.insert(vt(s("Tom"),s("is a bad boy of blue!")));
mulmap.insert(vt(s("Jerry"),s("is a student")));
mulmap.insert(vt(s("Jerry"),s("is a beatutiful girl")));
mulmap.insert(vt(s("DJ"),s("is a student")));
//输出初始化以后的多重映射mulmap:
for(p=mulmap.begin();p!=mulmap.end();++p)
cout<<(*p).first<<(*p).second<<endl;
//检索并输出Jerry键所对应的所有的值
cout<<"findJerry :"<<endl;
p=mulmap.find(s("Jerry"));
while((*p).first=="Jerry")
{
cout<<(*p).first<<(*p).second<<endl;
++p;
}
cin.get();
return 0;
}
在map中是不允许一个键对应多个值的,在multimap中,不支持operator[],也就是说不支持map中允许的下标操作。
std::map 再学习
1. map中的元素其实就是一个pair。
2. map的键一般不能是指针,比如int*,char*之类的,会出错。常用的就用string了,int也行。
3. map是个无序的容器,而vector之类是有序的。所谓有序无序是指放入的元素并不是按一定顺序放进去的,而是乱序,随机存放的(被映射后近似随机存放)。所以遍历的时候有些效率差别。
4. 判断有没有找到该键的内容可以这样:
//-----------------------------------------------------------------------------------------------
std::map<std::string,Record>::const_iterator cIter;
cIter= stdfile.m_map.find(s);
if(cIter == stdfile.m_map.end()) //没找到就是指向END了
{
m_vecMoreFile.push_back(s);
}
//-----------------------------------------------------------------------------------------------
如果键的内容是指针的话, 应该用NULL指针也可以判断了.
5. 遍历:
//-----------------------------------------------------------------------------------------------
std::map<std::string,Record>::iteratoriter;
for(iter = m_map.begin(); iter != m_map.end(); iter++)
{
std::string s = iter->second.filename;
}
//-----------------------------------------------------------------------------------------------
由于map内容可以相当一个PAIR,那就简单了,用iter->second就可以取得值了。
std::map是一个很常用的标准容器,采用红黑树或者平衡二叉树来储存节点内容,具有对数复杂度的插入时间和查找时间。这里简单说下它的一些值得注意的关注点。
1. 插入:
//-----------------------------------------------------------------------------------------------
std::map<int,std::string> str_map;
str_map.insert( std::pair<const int, std::string>(2, "bb") ); //没有转型操作
str_map.insert( std::pair<int, std::string>(2, "bb") ); //需要转型成std::pair<constint, std::string>再进行插入
str_map.insert( std::make_pair(3, "cc") ); //同上,需要转型
str_map.insert( std::map<int, std::string>::value_type ( 4 , "dd" ) ); //没有转型操作
//-----------------------------------------------------------------------------------------------
还有一种方法是通过索引器[]去直接插入,这种方法在下边再讨论。
2. 删除:
一种很常见的错误是:
//-----------------------------------------------------------------------------------------------
for( map<int, string>::iterator it = str_map.begin(); it!=str_map.end();it++ )
{
if ( some_condition )str_map.erase(it);
}
//-----------------------------------------------------------------------------------------------
删除操作会使it乱掉,再使用it++就出错了。
正确的做法是:
//-----------------------------------------------------------------------------------------------
for( map<int, string>::iterator it = str_map.begin();it!=str_map.end(); )
{
if ( some_condition ) {
str_map.erase(it++);
} else {
it++;
}
}
//-----------------------------------------------------------------------------------------------
3. 索引:
str_map[5]= "ee";
这条语句实际上是分两个步骤执行的:先在str_map[5]的地方构造一个空string,然后通过str_map[5]返回这个string的reference;然后调用这个空string的assignment运算符,把"ee"赋给它。因此,这样写要比直接insert效率低些。
索引还有一个问题是需要注意的:
//-----------------------------------------------------------------------------------------------
map<int,string> m;
cout<<m.size()<<endl;// output: 0
if( m[4] == "aa" ) some_operation();
cout<<m.size()<<endl;//output: 1
//-----------------------------------------------------------------------------------------------
这里m[4]已经指向了一个构造好了的空string
4. functionobject:
在std::mem_fun的帮助下,vector等容器可以很容易地使用find_if等泛型算法,比如:
classX {
public:
bool condition();
};
vector<X>vx;
....
vector<X>::iteratorit = std::find_if ( vx.begin(), vx.end(), std::mem_fun(&X::condition) );
由于map::iterator指向的是std::pair,所以要使用这些算法大部分时候就只好自己手写相应的functionobject了。
但借助boostlambda库的帮助,我们就可以省去自己写function object的麻烦了:
#include<boost/lambda/bind.hpp>
#include<boost/lambda/lambda.hpp>
usingboost::lambda::bind;
std::map<int,X> mx;
....
std::map<int,X>::iterator it = find_if ( mx.begin(), mx.end(),
bind ( &X::condition, bind(&std::map<int,X>::value_type::second, _1) ) );
std map是STL的一个关联容器,它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据处理能力,由于这个特性,它完成有可能在我们处理一对一数据的时候,在编程上提供快速通道。这里说下std map内部数据的组织,std map内部自建一颗红黑树(一种非严格意义上的平衡二叉树),这颗树具有对数据自动排序的功能,所以在std map内部所有的数据都是有序的,后边我们会见识到有序的好处。
下面举例说明什么是一对一的数据映射。比如一个班级中,每个学生的学号跟他的姓名就存在着一一映射的关系,这个模型用map可能轻易描述,很明显学号用int描述,姓名用字符串描述(本篇文章中不用char *来描述字符串,而是采用STL中string来描述),下面给出map描述代码:
Map<int, string> mapStudent;
1. map的构造函数
map共提供了6个构造函数,这块涉及到内存分配器这些东西,略过不表,在下面我们将接触到一些map的构造方法,这里要说下的就是,我们通常用如下方法构造一个map:
Map<int, string> mapStudent;
2. 数据的插入
在构造map容器后,我们就可以往里面插入数据了。这里讲三种插入数据的方法:
第一种:用insert函数插入pair数据,下面举例说明(以下代码虽然是随手写的,应该可以在VC和GCC下编译通过,大家可以运行下看什么效果,在VC下请加入这条语句,屏蔽4786警告#pragma warning (disable:4786) )
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
Map<int, string> mapStudent;
mapStudent.insert(pair<int, string>(1, “student_one”));
mapStudent.insert(pair<int, string>(2, “student_two”));
mapStudent.insert(pair<int, string>(3, “student_three”));
map<int, string>::iterator iter;
for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
{
Cout<<iter->first<<” ”<<iter->second<<end;
}
}
第二种:用insert函数插入value_type数据,下面举例说明
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
Map<int, string> mapStudent;
mapStudent.insert(map<int, string>::value_type (1, “student_one”));
mapStudent.insert(map<int, string>::value_type (2, “student_two”));
mapStudent.insert(map<int, string>::value_type (3, “student_three”));
map<int, string>::iterator iter;
for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
{
Cout<<iter->first<<” ”<<iter->second<<end;
}
}
第三种:用数组方式插入数据,下面举例说明
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
Map<int, string> mapStudent;
mapStudent[1] = “student_one”;
mapStudent[2] = “student_two”;
mapStudent[3] = “student_three”;
map<int, string>::iterator iter;
for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
{
Cout<<iter->first<<” ”<<iter->second<<end;
}
}
以上三种用法,虽然都可以实现数据的插入,但是它们是有区别的,当然了第一种和第二种在效果上是完成一样的,用insert函数插入数据,在数据的插入上涉及到集合的唯一性这个概念,即当map中有这个关键字时,insert操作是插入数据不了的,但是用数组方式就不同了,它可以覆盖以前该关键字对应的值,用程序说明
mapStudent.insert(map<int, string>::value_type (1, “student_one”));
mapStudent.insert(map<int, string>::value_type (1, “student_two”));
上面这两条语句执行后,map中1这个关键字对应的值是“student_one”,第二条语句并没有生效,那么这就涉及到我们怎么知道insert语句是否插入成功的问题了,可以用pair来获得是否插入成功,程序如下
Pair<map<int, string>::iterator, bool> Insert_Pair;
Insert_Pair = mapStudent.insert(map<int, string>::value_type (1,“student_one”));
我们通过pair的第二个变量来知道是否插入成功,它的第一个变量返回的是一个map的迭代器,如果插入成功的话Insert_Pair.second应该是true的,否则为false。
下面给出完成代码,演示插入成功与否问题
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
Map<int, string> mapStudent;
Pair<map<int, string>::iterator, bool> Insert_Pair;
Insert_Pair =mapStudent.insert(pair<int, string>(1, “student_one”));
If(Insert_Pair.second == true)
{
Cout<<”Insert Successfully”<<endl;
}
Else
{
Cout<<”Insert Failure”<<endl;
}
Insert_Pair =mapStudent.insert(pair<int, string>(1, “student_two”));
If(Insert_Pair.second == true)
{
Cout<<”Insert Successfully”<<endl;
}
Else
{
Cout<<”Insert Failure”<<endl;
}
map<int, string>::iterator iter;
for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
{
Cout<<iter->first<<” ”<<iter->second<<end;
}
}
大家可以用如下程序,看下用数组插入在数据覆盖上的效果
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
Map<int, string> mapStudent;
mapStudent[1] = “student_one”;
mapStudent[1] = “student_two”;
mapStudent[2] = “student_three”;
map<int, string>::iterator iter;
for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
{
Cout<<iter->first<<” ”<<iter->second<<end;
}
}
3. map的大小
在往map里面插入了数据,我们怎么知道当前已经插入了多少数据呢,可以用size函数,用法如下:
Int nSize = mapStudent.size();
4. 数据的遍历
这里也提供三种方法,对map进行遍历
第一种:应用前向迭代器,上面举例程序中到处都是了,略过不表
第二种:应用反相迭代器,下面举例说明,要体会效果,请自个动手运行程序
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
Map<int, string> mapStudent;
mapStudent.insert(pair<int, string>(1, “student_one”));
mapStudent.insert(pair<int, string>(2, “student_two”));
mapStudent.insert(pair<int, string>(3, “student_three”));
map<int, string>::reverse_iterator iter;
for(iter = mapStudent.rbegin(); iter != mapStudent.rend(); iter++)
{
Cout<<iter->first<<” ”<<iter->second<<end;
}
}
第三种:用数组方式,程序说明如下
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
Map<int, string> mapStudent;
mapStudent.insert(pair<int, string>(1, “student_one”));
mapStudent.insert(pair<int, string>(2, “student_two”));
mapStudent.insert(pair<int, string>(3, “student_three”));
int nSize = mapStudent.size()
//此处有误,应该是 for(int nIndex = 1; nIndex <= nSize;nIndex++)
//by rainfish
for(int nIndex = 0; nIndex < nSize; nIndex++)
{
Cout<<mapStudent[nIndex]<<end;
}
}
5. 数据的查找(包括判定这个关键字是否在map中出现)
在这里我们将体会,map在数据插入时保证有序的好处。
要判定一个数据(关键字)是否在map中出现的方法比较多,这里标题虽然是数据的查找,在这里将穿插着大量的map基本用法。
这里给出三种数据查找方法
第一种:用count函数来判定关键字是否出现,其缺点是无法定位数据出现位置,由于map的特性,一对一的映射关系,就决定了count函数的返回值只有两个,要么是0,要么是1,出现的情况,当然是返回1了
第二种:用find函数来定位数据出现位置,它返回的一个迭代器,当数据出现时,它返回数据所在位置的迭代器,如果map中没有要查找的数据,它返回的迭代器等于end函数返回的迭代器,程序说明
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
Map<int, string> mapStudent;
mapStudent.insert(pair<int, string>(1, “student_one”));
mapStudent.insert(pair<int, string>(2, “student_two”));
mapStudent.insert(pair<int, string>(3, “student_three”));
map<int, string>::iterator iter;
iter = mapStudent.find(1);
if(iter != mapStudent.end())
{
Cout<<”Find, the value is ”<<iter->second<<endl;
}
Else
{
Cout<<”Do not Find”<<endl;
}
}
第三种:这个方法用来判定数据是否出现,是显得笨了点,但是,我打算在这里讲解
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中不出现这个关键字,程序说明
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
Map<int, string> mapStudent;
mapStudent[1] = “student_one”;
mapStudent[3] = “student_three”;
mapStudent[5] = “student_five”;
map<int, string>::iterator iter;
iter = mapStudent.lower_bound(2);
{
//返回的是下界3的迭代器
Cout<<iter->second<<endl;
}
iter = mapStudent.lower_bound(3);
{
//返回的是下界3的迭代器
Cout<<iter->second<<endl;
}
iter = mapStudent.upper_bound(2);
{
//返回的是上界3的迭代器
Cout<<iter->second<<endl;
}
iter = mapStudent.upper_bound(3);
{
//返回的是上界5的迭代器
Cout<<iter->second<<endl;
}
Pair<map<int, string>::iterator, map<int, string>::iterator>mapPair;
mapPair = mapStudent.equal_range(2);
if(mapPair.first == mapPair.second)
{
cout<<”Do not Find”<<endl;
}
Else
{
Cout<<”Find”<<endl;
}
mapPair = mapStudent.equal_range(3);
if(mapPair.first == mapPair.second)
{
cout<<”Do not Find”<<endl;
}
Else
{
Cout<<”Find”<<endl;
}
}
6. 数据的清空与判空
清空map中的数据可以用clear()函数,判定map中是否有数据可以用empty()函数,它返回true则说明是空map
7. 数据的删除
这里要用到erase函数,它有三个重载了的函数,下面在例子中详细说明它们的用法
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
Map<int, string> mapStudent;
mapStudent.insert(pair<int, string>(1, “student_one”));
mapStudent.insert(pair<int, string>(2, “student_two”));
mapStudent.insert(pair<int, string>(3, “student_three”));
//如果你要演示输出效果,请选择以下的一种,你看到的效果会比较好
//如果要删除1,用迭代器删除
map<int, string>::iterator iter;
iter = mapStudent.find(1);
mapStudent.erase(iter);
//如果要删除1,用关键字删除
Int n = mapStudent.erase(1);//如果删除了会返回1,否则返回0
//用迭代器,成片的删除
//一下代码把整个map清空
mapStudent.earse(mapStudent.begin(), mapStudent.end());
//成片删除要注意的是,也是STL的特性,删除区间是一个前闭后开的集合
//自个加上遍历代码,打印输出吧
}
8. 其他一些函数用法
这里有swap,key_comp,value_comp,get_allocator等函数,感觉到这些函数在编程用的不是很多,略过不表,有兴趣的话可以自个研究
9. 排序
这里要讲的是一点比较高深的用法了,排序问题,STL中默认是采用小于号来排序的,以上代码在排序上是不存在任何问题的,因为上面的关键字是int型,它本身支持小于号运算,在一些特殊情况,比如关键字是一个结构体,涉及到排序就会出现问题,因为它没有小于号操作,insert等函数在编译的时候过不去,下面给出两个方法解决这个问题
第一种:小于号重载,程序举例
#include <map>
#include <string>
Using namespace std;
Typedef struct tagStudentInfo
{
Int nID;
String strName;
}StudentInfo, *PStudentInfo; //学生信息
Int main()
{
int nSize;
//用学生信息映射分数
map<StudentInfo, int>mapStudent;
map<StudentInfo, int>::iterator iter;
StudentInfo studentInfo;
studentInfo.nID = 1;
studentInfo.strName = “student_one”;
mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));
studentInfo.nID = 2;
studentInfo.strName = “student_two”;
mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));
for (iter=mapStudent.begin(); iter!=mapStudent.end(); iter++)
cout<<iter->first.nID<<endl<<iter->first.strName<<endl<<iter->second<<endl;
}
以上程序是无法编译通过的,只要重载小于号,就OK了,如下:
Typedef struct tagStudentInfo
{
Int nID;
String strName;
Bool operator < (tagStudentInfo const& _A) const
{
//这个函数指定排序策略,按nID排序,如果nID相等的话,按strName排序
If(nID < _A.nID) return true;
If(nID == _A.nID) return strName.compare(_A.strName) < 0;
Return false;
}
}StudentInfo, *PStudentInfo; //学生信息
第二种:仿函数的应用,这个时候结构体中没有直接的小于号重载,程序说明
#include <map>
#include <string>
Using namespace std;
Typedef struct tagStudentInfo
{
Int nID;
String strName;
}StudentInfo, *PStudentInfo; //学生信息
Classs sort
{
Public:
Bool operator() (StudentInfo const &_A, StudentInfo const &_B) const
{
If(_A.nID < _B.nID) return true;
If(_A.nID == _B.nID) return _A.strName.compare(_B.strName) < 0;
Return false;
}
};
Int main()
{
//用学生信息映射分数
Map<StudentInfo, int, sort>mapStudent;
StudentInfo studentInfo;
studentInfo.nID = 1;
studentInfo.strName = “student_one”;
mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));
studentInfo.nID = 2;
studentInfo.strName = “student_two”;
mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));
}
10. 另外
由于STL是一个统一的整体,map的很多用法都和STL中其它的东西结合在一起,比如在排序上,这里默认用的是小于号,即less<>,如果要从大到小排序呢,这里涉及到的东西很多,在此无法一一加以说明。
还要说明的是,map中由于它内部有序,由红黑树保证,因此很多函数执行的时间复杂度都是log2N的,如果用map函数可以实现的功能,而STLAlgorithm也可以完成该功能,建议用map自带函数,效率高一些。
下面说下,map在空间上的特性,否则,估计你用起来会有时候表现的比较郁闷,由于map的每个数据对应红黑树上的一个节点,这个节点在不保存你的数据时,是占用16个字节的,一个父节点指针,左右孩子指针,还有一个枚举值(标示红黑的,相当于平衡二叉树中的平衡因子),我想大家应该知道,这些地方很费内存了吧,不说了……
std::map用法
STL是标准C++系统的一组模板类,使用STL模板类最大的好处就是在各种C++编译器上都通用。
在STL模板类中,用于线性数据存储管理的类主要有vector, list, map等等。本文主要针对map对象,结合自己学习该对象的过程,讲解一下具体用法。本人初学,水平有限,讲解差错之处,请大家多多批评指正。
map对象所实现的功能跟MFC得CMap相似,但是根据一些文章的介绍和论述,MFCCMap在个方面都与STL map有一定的差距,例如不是C++标准,不支持赋值构造,对象化概念不清晰等等。
使用map对象首先要包括头文件,包含语句中必须加入如下包含声明
#include<map>
注意,STL头文件没有扩展名.h
包括头文件后就可以定义和使用map对象了,map对象是模板类,需要关键字和存储对象两个模板参数,例如:
std:map<int,CString> enumMap;
这样就定义了一个用int作为关键字检索CString条目的map对象,std表示命名空间,map对象在std名字空间中,为了方便,在这里我仍然使用了CString类,其实应该使用标准C++的std::string类,我们对模板类进行一下类型定义,这样用的方便,当然,不定义也可以,代码如下:
typedefstd:map<int, CString> UDT_MAP_INT_CSTRING;
UDT_MAP_INT_CSTRING enumMap;
如此map对象就定义好了,增加,改变map中的条目非常简单,因为map类已经对[]操作符进行了重载,代码如下:
enumMap[1]= "One";
enumMap[2] = "Two";
.....
enumMap[1] = "One Edit";
或者insert方法
enumMap.insert(make_pair(1,"One"));
返回map中目前存储条目的总数用size()方法:
intnSize = enumMap.size();
查找map中是否包含某个关键字条目用find方法,传入的参数是要查找的key,在我们的例子里,是一个int数据,map中的条目数据是顺序存储的,被称作为一个sequence,在这里需要提到的是begin()和end()两个成员,分别代表map对象中第一个条目和最后一个条目,这两个数据的类型是iterator,iterator被定义为map中条目的类型,查找是否包含某个条目的代码如下:
intnFindKey = 2; //要查找的Key
UDT_MAP_INT_CSTRING::iterator it; //定义一个条目变量(实际是指针)
it = enumMap.find(nFindKey);
if(it == enumMap.end()) {
//没找到
}
else {
//找到
}
//find的时候注意key的数据类型,最好用CString之类的能消除数据类型差异的key,否则可能会出现强制转换后仍找不到的情况。
需要说明的是iterator, begin(), end()是STL模板类的一个通用概念,操作方法也大同小异
通过map对象的方法获取的iterator数据类型是一个std::pair对象,包括两个数据 iterator.first 和 iterator.second分别代表关键字和存储的数据
移除某个条目用erase()该成员方法的定义如下
iteratorerase(iterator it);
iterator erase(iterator first, iterator last);
size_type erase(const Key& key);
分析一下这三个重载方法定义,大家不用说也能看明白一点点了吧,第一个通过一个条目对象删除,这个对象可以从find之类的方法获得,第二个定义删除一个范围,需要一个起始条目和一个终止条目,第三个通过关键字删除,这个与我们的想法和习惯最接近,代码例子如下:
enumMap.erase(1); //删掉关键字“1”对应的条目
enumMap.erase(enumMap.begin()); //删掉第一个条目
enumMap.erase(enumMap.begin(), enumMap.begin() + 1); //删掉起始的两个条目
呵呵,增删改查都说完了,相信读过本文,map对象也应该会使用了,这些是我1个多星期来钻研的结果,拿出来与大家分享。
最后,还有一个empty(),不用问,全删的时候就不要一个一个erase了,empty()就相当于enumMap.erase(enumMap.begin(),enumMap.end());
map的遍历:
#include<map>
#include<string>
#include<iostream>
using namespace std;
int main()
{
map<string,int> m;
m["a"]=1;
m["b"]=2;
m["c"]=3;
map<string,int>::iterator it;
for(it=m.begin();it!=m.end();++it)
cout<<"key:"<<it->first <<" value:"<<it->second<<endl;
return 0;
}
map<string,int>::iteratorit; 定义一个迭代指针it。
it->first为索引键值,it->second为值。
在对象中应用时,最好在析构函数中要调用它的clear方法,
例如class a{
map<int,int> m;
~a(){
m.clear();
}
}