C++ STL map的使用

1、map简介

map是一类关联式容器。它的特点是增加和删除节点对迭代器的影响很小，除了那个操

作节点，对其他的节点都没有什么影响。对于迭代器来说，可以修改实值，而不能修改key。

2、map的功能

自动建立Key － value的对应。key 和 value可以是任意你需要的类型。
根据key值快速查找记录，查找的复杂度基本是Log(N)，如果有1000个记录，最
多查找10次，1,000,000个记录，最多查找20次。
快速插入Key - Value 记录。
快速删除记录
根据Key 修改value记录。
遍历所有记录。

3、使用map

使用map得包含map类所在的头文件

#include <map> //注意，STL头文件没有扩展名.h

map对象是模板类，需要关键字和存储对象两个模板参数：

std:map<int, string> personnel;

这样就定义了一个用int作为索引,并拥有相关联的指向string的指针.

为了使用方便，可以对模板类进行一下类型定义，

typedef map<int, CString> UDT_MAP_INT_CSTRING;

UDT_MAP_INT_CSTRING enumMap;

4、在map中插入元素

改变map中的条目非常简单，因为map类已经对[]操作符进行了重载

enumMap[1] = "One";

enumMap[2] = "Two";

.....

这样非常直观，但存在一个性能的问题。插入2时,先在enumMap中查找主键为2的项，没

发现，然后将一个新的对象插入enumMap，键是2，值是一个空字符串，插入完成后，

将字符串赋为"Two"; 该方法会将每个值都赋为缺省值，然后再赋为显示的值，如果元素

是类对象，则开销比较大。我们可以用以下方法来避免开销：

enumMap.insert(map<int, CString> :: value_type(2, "Two"))

5、查找并获取map中的元素

下标操作符给出了获得一个值的最简单方法：

CString tmp = enumMap[2];

但是,只有当map中有这个键的实例时才对，否则会自动插入一个实例，值为初始化值。

我们可以使用Find()和Count()方法来发现一个键是否存在。

查找map中是否包含某个关键字条目用find()方法，传入的参数是要查找的key，在这里

需要提到的是begin()和end()两个成员，分别代表map对象中第一个条目和最后一个条

目，这两个数据的类型是iterator.

int nFindKey = 2; //要查找的Key

//定义一个条目变量(实际是指针)

UDT_MAP_INT_CSTRING::iterator it= enumMap.find(nFindKey);

if(it == enumMap.end()) {

//没找到

}

else {

//找到

}

通过map对象的方法获取的iterator数据类型是一个std::pair对象，包括两个数据

iterator->first

和 iterator->second 分别代表关键字和存储的数据

6、从map中删除元素

移除某个map中某个条目用erase()

该成员方法的定义如下

iterator erase(iterator it); //通过一个条目对象删除
iterator erase(iterator first, iterator last); //删除一个范围
size_type erase(const Key& key); //通过关键字删除

clear()就相当于 enumMap.erase(enumMap.begin(), enumMap.end());

C++ STL map的使用

以下是对C++中STL map的插入，查找，遍历及删除的例子：
#include <map>

#include <string>

#include <iostream>

using namespace std;

void map_insert(map < string, string > *mapStudent, string index, string x)

{

mapStudent->insert(map < string, string >::value_type(index, x));

}

int main(int argc, char **argv)

{

char tmp[32] = "";

map < string, string > mapS;

//insert element

map_insert(&mapS, "192.168.0.128", "xiong");

map_insert(&mapS, "192.168.200.3", "feng");

map_insert(&mapS, "192.168.200.33", "xiongfeng");

map < string, string >::iterator iter;

cout << "We Have Third Element:" << endl;

cout << "-----------------------------" << endl;

//find element

iter = mapS.find("192.168.0.33");

if (iter != mapS.end()) {

cout << "find the elememt" << endl;

cout << "It is:" << iter->second << endl;

} else {

cout << "not find the element" << endl;

}

//see element

for (iter = mapS.begin(); iter != mapS.end(); iter ) {

cout << "| " << iter->first << " | " << iter->

second << " |" << endl;

}

cout << "-----------------------------" << endl;

map_insert(&mapS, "192.168.30.23", "xf");

cout << "After We Insert One Element:" << endl;

cout << "-----------------------------" << endl;

for (iter = mapS.begin(); iter != mapS.end(); iter ) {

cout << "| " << iter->first << " | " << iter->

second << " |" << endl;

}

cout << "-----------------------------" << endl;

//delete element

iter = mapS.find("192.168.200.33");

if (iter != mapS.end()) {

cout << "find the element:" << iter->first << endl;

cout << "delete element:" << iter->first << endl;

cout << "=================================" << endl;

mapS.erase(iter);

} else {

cout << "not find the element" << endl;

}

for (iter = mapS.begin(); iter != mapS.end(); iter ) {

cout << "| " << iter->first << " | " << iter->

second << " |" << endl;

}

cout << "=================================" << endl;

return 0;

}

std::map中插入对象(复合Key)的实现方法

前提说明

难道插入map还有什么讲究吗？我们且看map在STL中的定义方法：

template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>

第一个参数Key是关键字类型

第二个参数T是值类型

第三个参数Compare是比较函数（仿函数）

第四个参数是内存配置对象

map内部存储机制实际是以红黑树为基础，红黑树在插入节点时，必须依照大小比对之后在一个合适的位置上执行插入动作。所以作为关键字，起码必须有“<”这个比较操作符。我们知道，int，float，enum，size_t等等简单关键字，都有内置的比较函数，与map搭配无论是插入还是查找，都没什么问题。但是作为复杂数据类型，如果没有明确定义“<”比较操作符，就不能与map直接搭配使用，除非我们自己定义第三个参数。

在选择map的关键字时，注意以下两点，同时这两点也是改错的方法：

a） 关键字明确定义“<”比较操作符

b） 没有“<”比较操作符，自定义仿函数替代第三个参数Compare，该仿函数实现“()”操作符，提供比较功能。插入时各节点顺序以该仿函数为纲。

以std::pair为关键字掺入map

下面我们先写一个有错误的函数，在分析错误原因之后，逐步进行修正。

#include <map>

int main()

{

std::map<std::pair<int, int>, int> res;

res.insert(std::make_pair(12,33), 33);

}

这个程序一定失败，如果非要如此使用，上述a方法显然不适合，std::pair是已定义好的结构体不可修改。只能使用b方法了，定义一个比较类改造如下：

#include <map>

struct comp

{

typedef std::pair<int, int> value_type;

bool operator () (const value_type & ls, const value_type &rs)

{

return ls.first < rs.first || (ls.first == rs.first && ls.second < rs.second);

}

};

int main()

{

std::map<std::pair<int, int>, int, comp> res;

res.insert(std::make_pair(std::make_pair(12,33), 33));

res.insert(std::make_pair(std::make_pair(121,331), 331));

res.insert(std::make_pair(std::make_pair(122,332), 332));

std::map<std::pair<int, int>, int, comp>::iterator it = res.find(std::make_pair(121,331));

if (it != res.end())

printf("%d %d %d "n", it->first.first, it->first.second, it->second);

return 0;

}

以结构体或类为关键字插入map

#include <map>

struct st

{

int a, b;

st():a(0), b(0)

{

}

st(int x, int y):a(x), b(y)

{

}

};

int main()

{

std::map<struct st, int> res;

res.insert(std::make_pair(st(1,2), 12));

res.insert(std::make_pair(st(30,4), 34));

res.insert(std::make_pair(st(5,6), 56));

std::map<struct st, int>::iterator it = res.find(st(30,4));

if (it != res.end())

printf("first:%d second:%d %d"n", it->first.a, it->first.b, it->second);

return 0;

}

编译这个程序也是错误的，错误意思大概也是没有定义“<”比较函数。因为struct st是我们自己定义的结构体，所以修改这个程序可以使用上面a、b两种方法。我们先谈第一种，第一次修改时我也搞错了，我是这样定义比较函数的。

struct st

{

int a, b;

st():a(0), b(0)

{

}

st(int x, int y):a(x), b(y)

{

}

bool operator < (const struct st &rs) const

{

return (this->a < rs.a || (this->a == rs.a && this->b < rs.b));

}

};

经过操作符"<"重载后，以上程序就通过编译，可以远行了!

当然用友元函数方式也可以，如下：

struct st

{

int a, b;

st():a(0), b(0)

{

}

st(int x, int y):a(x), b(y)

{

}

friend bool operator < (const struct st &ls, const struct st &rs);

};

inline bool operator < (const struct st &ls, const struct st &rs)

{return (ls.a < rs.a || (ls.a == rs.a && ls.b < rs.b));}

以友联函数代替函数内部定义的比较操作符，STL内部也多是以这种方式定义的。如果我非要以内部定义的方式呢？可以使用b方法，我们自定义一个比较仿函数，替代默认的less。

插入函数返回值

在map容器中插入数据有很多函数可用，这里只讨论最普通的insert操作，在STL中它是这样定义的。

pair<iterator, bool> insert(const value_type& x);

map容器不允许键值重复，在执行插入操作后，可以凭借该返回值获取操作结果。返回值是一个迭代器和布尔值的键值对，迭代器指向map中具有该值的元素，布尔值表示是否插入成功。如果布尔值为true，表示插入成功，则迭代器为新插入值在map中的位置；布尔值为false，表示插入失败（已经存在该值），迭代器为原有值在map中的位置。

std::map中erase的正确用法

STL的map表里有一个erase方法用来从一个map中删除掉指令的节点

eg:

map<string,string> mapTest;

typedef map<string,string>::iterator ITER;

ITER iter=mapTest.find(key);

mapTest.erase(iter);

像上面这样只是删除单个节点,map的形为不会出现任务问题,

但是当在一个循环里用的时候,往往会被误用,那是因为使用者没有正确理解iterator的概念.

像下面这样的一个例子就是错误的写法,

eg.

for(ITER iter=mapTest.begin();iter!=mapTest.end();++iter)

{

cout<<iter->first<<":"<<iter->second<<endl;

mapTest.erase(iter);

}

这是一种错误的写法,会导致程序行为不可知.究其原因是map 是关联容器,对于关联容器来说，如果某一个元素已经被删除，那么其对应的迭代器就失效了，不应该再被使用；否则会导致程序无定义的行为。

可以用以下方法解决这问题:

正确的写法

1.使用删除之前的迭代器定位下一个元素。STL建议的使用方式

for(ITER iter=mapTest.begin();iter!=mapTest.end();) //注意此处不能再写iter++

{

cout<<iter->first<<":"<<iter->second<<endl;

mapTest.erase(iter++);

}

2. erase() 成员函数返回下一个元素的迭代器

for(ITER iter=mapTest.begin();iter!=mapTest.end();)

{

cout<<iter->first<<":"<<iter->second<<endl;

iter=mapTest.erase(iter);

}