STL学习笔记-- map

[b]map映照容器[/b]

map映照容器所处理的元素数据，与数据库表的具有键值的记录非常相似，由一个键值和其他若干数据（映照数组）组成，键值和映照数据之间，可建立一个数学上的映照关系，由此而得映照容器的名称。容器的数据结构同样是采用红黑树进行管理，插入的元素键值不允许重复，所使用的节点元素的比较函数，只对元素的键值进行比较，元素的各项数据可通过键值检索出来。
map 映照容器是一种关联容器，实现了 Sorted Associative Container 、Sorted Associative Container 、 Unique Associative Container 概念的接口规范
map 容器的 C++ 标准头文件为 map ，先要用宏语句 "#include <map>" ，将红黑树和 map 的头文件包含进来，才可对使用 map 的程序进行编译

创建 map 对象
为了操作 map 的数据，先要用 map 的构造函数，创建一个 map 对象。
1. map()
利用默认的 less<T> 函数对象和内存分配器，创建一个没有任何数元素的 map 对象。
例如，下面的代码创建了一个空的 map 对象 m ，元素的键值类型为 char ，元素的映照数据类型为 int ，键值的比较函数对象为 greater<char>
map<char, int, greater<char> > m; // 两个 ">" 、">" 符号不要写在一起了，记得要空格

2. map(const key_compare& comp)
指定一个比较函数对象 comp 来创建 map 对象，内存分配器为默认值。
map<T1,T2,less<T1> > mapA; //该容器是按键的升序方式排列元素。未指定函数对象，默认采用less<T1>函数对象。
map<T1,T2,greater<T1>> mapB; //该容器是按键的降序方式排列元素。
less<T1>与greater<T1> 可以替换成其它的函数对象functor。
可编写自定义函数对象以进行自定义类型的比较，使用方法与set构造时所用的函数对象一样。
例如，下面的代码使用自定义的函数对象 strLess ，创建一个 map 容器对象 m 。该容器的键值类型为 const char* ，映照容器数据类型为 int 。
// 定义字符串比较函数对象 strLess
struct strLess
{
bool operator() (const char* s1, const char* s2) const
{
return strcmp(s1, s2) < 0 ;
}
};
// 创建 map 容器对象 m
map<const char*, int > m(strLess());

3. map(const map&)
拷贝构造函数，用一个 map 容器的元素和比较函数，拷贝生成一个新的 map 容器对象。
例如，下面代码利用 map 容器对象 m1 ，创建另一个容器对象 m2 .
// map <int , char*> m1;
map<int, char*> m2(m1); // 使用默认的键值比较函数 less<int>

4. map(InputIterator first, InputIterator last)
用迭代器区间 [first, last) 所指的数据，作为 map 容器的元素（包括键值和映照数据），创建一个 map 容器对象。
例如，下面代码使用数组 pairArray 的 5 个 pair 对象，创建 map 容器对象 m 。
pair<const int, char> p1(1, 'a');
pair<const int, char> p1(2, 'b');
pair<const int, char> p1(3, 'c');
pair<const int, char> p1(4, 'd');
pair<const int, char> p1(5, 'e');
pair<const int, char> pairArray[] = {p1, p2, p3, p4, p5};
// 创建 map 容器对象 m
map<const int, char> m(pairArray, pairArray + 5);

5. map(InputIterator first, InputIterator last, const key_compare& comp)
用迭代器区间 [first, last)所指的数据和 comp 函数对象，创建一个 map 对象。
例如，下面代码使用 greater<int> 函数对象，取代默认的 less<int> ，创建一个 map 对象 m 。
map<const int, char, greater<const int> > m(pairArray, pairArray+5, greater<const int>());

元素的插入
map 容器对象创建出来后，下一步就是元素数据（包括键值和映照数据）的二叉树装入。
除可使用如下的 insert 函数，将整个元素数据进行性插入外，常用 map 容器的数组操作 "[]" ，显示地为不同键值赋予内容（映照数据），不过这个数组方法，不能检测是否插入 成功。

假设 map<int, string> mapStu;

1. 通过pair的方式插入对象 //往容器插入元素，返回pair<iterator,bool>
pair<iteraotr, bool> insert(const value_type& v)
将元素 v（包括键值和映照数据）插入 map 容器，重复的 V 值不被插入。返回一个 pair 配对对象。提供所插入元素的迭代器位置和 true/false 插入成功标志
例如，下面代码是 pair 方式的插入
mapStu.insert( pair<int,string>(3,"小张") );

2. 通过value_type的方式插入对象
mapStu.insert( map<int,string>::value_type(1,"小李") );

3. 通过数组的方式插入值
mapStu[3] = “小刘";
mapStu[5] = “小王"；
......

第三种方法非常直观，但存在一个性能的问题。插入3时，先在mapStu中查找主键为3的项，若没发现，则将一个键为3，值为初始化值的对组插入到mapStu中，然后再将值修改成“小刘”。若发现已存在3这个键，则修改这个键对应的value。
string strName = mapStu[2]; //取操作或插入操作
只有当mapStu存在2这个键时才是正确的取操作，【否则会自动插入一个实例，键为2，值为初始化值】。

前两种方法，采用的是insert()方法，该方法返回值为pair<iterator,bool>
pair< map<int,string>::iterator, bool> pairResult = mapStu.insert( pair<int,string>(3,"小张") );
如果插入成功，(pairResult.first)->first==3, (pairResult.first)->second=="小张" pairResult.second==true。

map 容器元素的搜索

/*    利用 map 容器提供的 find 函数，可搜索出具有某一键值的元素。map 容器的元素键值是唯一的。find 函数返回的迭代器值为搜索到的元素位置，如果该元素不存在，则返回一个 end 结束元素位置。

下面的示例程序重写了 StudentRecord 结构体，以适于使用返回 pair 对象的 insert 函数将学生记录插入到 map 容器。 返回的 pair 对象的第二变量 second 中，判断是否插入成功（键值重复插入将失败）。然后，调用 find 函数，对学号为 2 的键值进行搜索，并将该学生的记录打印出来。
*/
-------------------------------------------------------- map 容器元素的搜索
#pragma warning(disable:4786)
#include <map>
#include <iostream>
using namespace std;
// 学生记录结构体
struct StudentRecord
{
struct StudentInfo
{
char* name;
int year;
char* addr;
};
StudentRecord(int id_, char* name_, int year_, char* addr_)
{
id = id_;
sf.name = name_;
sf.year = year_;
sf.addr = addr_;
}
int id;   // 学号，作键值
StudentInfo sf;  // 其他信息
};

int main()
{
// 创建 map 容器对象 m
typedef map<int, StudentRecord::StudentInfo>  studentmap;
studentmap m;
pair<studentmap::iterator, bool>  p;

// 插入第一条学生记录
StudentRecord student1 = StudentRecord(1, "何亮1号", 21, "武汉");
pair<int, StudentRecord::StudentInfo>  pairStudent1(student1.id, student1.sf);
p = m.insert(pairStudent1);
if (!p.second)
cout << "插入学生记录失败:\n"
<< student1.id << '    '
<< student1.sf.name << '    '
<< student1.sf.year << '    '
<< student1.sf.addr << '    '
<< endl << endl;

// 插入第二条学生记录
StudentRecord student2 = StudentRecord(2, "何亮2号", 22, "北京");
pair<int, StudentRecord::StudentInfo>  pairStudent2(student2.id, student2.sf);
p = m.insert(pairStudent2);
if (!p.second)
cout << "插入学生记录失败:\n"
<< student2.id << '    '
<< student2.sf.name << '    '
<< student2.sf.year << '    '
<< student2.sf.addr << '    '
<< endl << endl;

// 插入第三条学生记录
StudentRecord student3 = StudentRecord(3, "何亮3号", 23, "上海");
pair<int, StudentRecord::StudentInfo>  pairStudent3(student3.id, student3.sf);
p = m.insert(pairStudent3);
if (!p.second)
cout << "插入学生记录失败:\n"
<< student3.id << '    '
<< student3.sf.name << '    '
<< student3.sf.year << '    '
<< student3.sf.addr << '    '
<< endl << endl;

// 插入键值重复的学生记录， 插入失败
StudentRecord student4 = StudentRecord(3, "何亮4号", 24, "广州");
pair<int, StudentRecord::StudentInfo>  pairStudent4(student4.id, student4.sf);
p = m.insert(pairStudent4);
if (!p.second)
cout << "插入学生记录失败:\n"
<< student4.id << '    '
<< student4.sf.name << '    '
<< student4.sf.year << '    '
<< student4.sf.addr << '    '
<< endl << endl;

// 记录搜索
studentmap::iterator  i = m.find(2);
cout << "搜索出学号为2的记录：\n"
<< (*i).first << '    '
<< (*i).second.name << '    '
<< (*i).second.year << '    '
<< (*i).second.addr << '    '
<< endl << endl;

// 统计 map 容器 m 所有学生的个数
if (m.empty())
cout << "map 容器为空" << endl;
else
cout << "map 容器元素个数为：" << m.size() << endl << endl;

return 0;
}

------------------------------- map 小结
直观来说，map 容器区别于 set 容器的一个主要特性在于，map 是处理带有键值的记录型元素数据的快速插入、删除 和检索，而 set 则可看成是对单一数据的处理。map 将一个元素划分出键值部分，并按这个局部的键值指定整个元素的函数比较规则，来建立容器的数据分布。map 的元素键值是唯一的，不允许重复的元素键值插入。 set 和 map 都是泛型库对二叉树的一个泛化。

map 缺点：map是比较高级的用法了，适合用 list , vector 就能完成的操作，就不需要用到 map 。
map 优点：相比 set ，map 可处理带有键值的记录型数据的快速插入、删除和检索。检索的速度也是非常快的。

------------- 讨论到 map 这里的时候，应该说，有些地方理解起来，就有些难度了。可以网上搜一些相关的代码看看，理顺逻辑，弄清结构，孰能生巧。