map

map映照容器

    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。

 

 1 #pragma warning(disable:4786) 2 #include <map> 3 #include <iostream> 4 using namespace std; 5 int main() 6 { 7     // 创建 map 容器对象 m 8     map<const char*, float>  m; 9     // 插入元素（水果名，单价），水果名位键值，单价为映照数据10     m["apple"] = 3.6f;11     m["orange"] = 3.2f;12     m["banana"] = 1.8f;13     m["pear"] = 2.3f;14     m["lichee"] = 6.3f;15     m.insert(pair<const char*, float>("何亮",100.001f) );16     // 打印元素17     cout << "苹果价格：" << m["apple"] << "元/斤 \n"; 18     cout << "桔子价格：" << m["orange"] << "元/斤 \n"; 19     cout << "香蕉价格：" << m["banana"] << "元/斤 \n"; 20     cout << "雪梨价格：" << m["pear"] << "元/斤 \n"; 21     cout << "荔枝价格：" << m["lichee"] << "元/斤 \n"; 22     cout << "pair插入  " << m["何亮"] << "元/斤\n";23 24     return 0;25 }

 

元素的删除    与 set 集合容器一样，map 映照容器的删除函数，可删除某个迭代器位置上的元素、等于某键值的元素、一个迭代器区间上的元素和容器中的所有元素。1.    void  erase(iterator position)    删除 position 所指的元素2.    size_type  erase(const key_type& k)    删除键值为 K 的元素。对 map 容器来说，此函数总是返回值 1，因为 map 容器不会出现键值重复的元素值。3.    void  erase(iterator first, iterator last)    删除 map 迭代器区间 [first, last) 上的所有元素4.    void clear()     删除 map 容器的所有元素    例如，下面的代码将上一例子 map 对象 m 中，"lichee, 6.3" 的元素数据删除    m.erase("lichee");

 

 

 

 1      2 /*    除了利用键值的数组方式来访问元素外，更一般可使用 map 容器的迭代器进行访问，通常需要用 begin 和 end 函数找出遍历开始的首元素和结束元素，然后通过迭代器的“++” 和“*” 操作，读取容器元素。 3  4     下面的示例程序，将一批学生记录（学号为键值）插入到 map 容器对象 m 中，然后，利用前向迭代器打印出来。由于 map 容器的元素是通过转换为 pair 对象插入到容器的，因此，学生记录结构体中各个变量域，需要通过 pair 对象的 first 和 second 变量 指出来。（关于 pair ，可参考之前的讨论 set 容器的文章） 5 */     6  7 -------------------------------------------------------- 遍历 map 容器元素 8 #pragma warning(disable:4786) 9 #include <map>10 #include <iostream>11 using namespace std;12 13 // 学生信息结构体14 struct StudentInfo15 {16     char* name;17     int year;18     char* addr;19 };20 21 // 学生记录结构体22 struct StudentRecord  23 {24     int id;  // 学号，作键值25     StudentInfo sf;  // 学生信息，作映照数据26 };27 28 int main()29 {30     // 3个学生的记录31     StudentRecord srArray[] = {32         {1, "何亮",21,"武汉"},33         {2, "何小亮",20,"上海"},34         {3, "何大亮",22,"北京"}35     };36     // 创建 map 容器对象 m ，管理学生记录37     map<int, StudentInfo> m;38     // 装入 3 笔学生记录39     for (int j=0; j<3; j++)40         m[srArray[j].id] = srArray[j].sf;41     // 迭代器遍历元素42     map<int, StudentInfo>::iterator i, iend;43     iend = m.end();44     cout << "学号    " << "姓名    " << "年龄    " << "地址    " << endl;45     for (i=m.begin(); i!=iend; ++i)46         cout << (*i).first << '    ' << (*i).second.name << '    ' << (*i).second.year << '    ' << (*i).second.addr << endl;47     cout << endl;48 49     return 0;50 }

 

 

 

  1 /*    利用 map 容器提供的 find 函数，可搜索出具有某一键值的元素。map 容器的元素键值是唯一的。find 函数返回的迭代器值为搜索到的元素位置，如果该元素不存在，则返回一个 end 结束元素位置。  2   3     下面的示例程序重写了 StudentRecord 结构体，以适于使用返回 pair 对象的 insert 函数将学生记录插入到 map 容器。 返回的 pair 对象的第二变量 second 中，判断是否插入成功（键值重复插入将失败）。然后，调用 find 函数，对学号为 2 的键值进行搜索，并将该学生的记录打印出来。  4 */  5 -------------------------------------------------------- map 容器元素的搜索  6 #pragma warning(disable:4786)  7 #include <map>  8 #include <iostream>  9 using namespace std; 10 // 学生记录结构体 11 struct StudentRecord 12 { 13     struct StudentInfo 14     { 15         char* name; 16         int year; 17         char* addr; 18     }; 19     StudentRecord(int id_, char* name_, int year_, char* addr_) 20     { 21         id = id_; 22         sf.name = name_; 23         sf.year = year_; 24         sf.addr = addr_; 25     } 26     int id;   // 学号，作键值 27     StudentInfo sf;  // 其他信息 28 }; 29  30 int main() 31 { 32     // 创建 map 容器对象 m 33     typedef map<int, StudentRecord::StudentInfo>  studentmap; 34     studentmap m; 35     pair<studentmap::iterator, bool>  p; 36  37     // 插入第一条学生记录 38     StudentRecord student1 = StudentRecord(1, "何亮1号", 21, "武汉"); 39     pair<int, StudentRecord::StudentInfo>  pairStudent1(student1.id, student1.sf); 40     p = m.insert(pairStudent1); 41     if (!p.second) 42         cout << "插入学生记录失败:\n"  43         << student1.id << '    '  44         << student1.sf.name << '    ' 45         << student1.sf.year << '    ' 46         << student1.sf.addr << '    ' 47         << endl << endl; 48  49     // 插入第二条学生记录 50     StudentRecord student2 = StudentRecord(2, "何亮2号", 22, "北京"); 51     pair<int, StudentRecord::StudentInfo>  pairStudent2(student2.id, student2.sf); 52     p = m.insert(pairStudent2); 53     if (!p.second) 54         cout << "插入学生记录失败:\n"  55         << student2.id << '    '  56         << student2.sf.name << '    ' 57         << student2.sf.year << '    ' 58         << student2.sf.addr << '    ' 59         << endl << endl; 60  61     // 插入第三条学生记录 62     StudentRecord student3 = StudentRecord(3, "何亮3号", 23, "上海"); 63     pair<int, StudentRecord::StudentInfo>  pairStudent3(student3.id, student3.sf); 64     p = m.insert(pairStudent3); 65     if (!p.second) 66         cout << "插入学生记录失败:\n"  67         << student3.id << '    '  68         << student3.sf.name << '    ' 69         << student3.sf.year << '    ' 70         << student3.sf.addr << '    ' 71         << endl << endl; 72  73     // 插入键值重复的学生记录， 插入失败  74     StudentRecord student4 = StudentRecord(3, "何亮4号", 24, "广州"); 75     pair<int, StudentRecord::StudentInfo>  pairStudent4(student4.id, student4.sf); 76     p = m.insert(pairStudent4); 77     if (!p.second) 78         cout << "插入学生记录失败:\n"  79         << student4.id << '    '  80         << student4.sf.name << '    ' 81         << student4.sf.year << '    ' 82         << student4.sf.addr << '    ' 83         << endl << endl; 84  85     // 记录搜索 86     studentmap::iterator  i = m.find(2); 87     cout << "搜索出学号为2的记录：\n" 88         << (*i).first << '    ' 89         << (*i).second.name << '    ' 90         << (*i).second.year << '    ' 91         << (*i).second.addr << '    ' 92         << endl << endl; 93  94     // 统计 map 容器 m 所有学生的个数 95     if (m.empty()) 96         cout << "map 容器为空" << endl; 97     else 98         cout << "map 容器元素个数为：" << m.size() << endl << endl; 99 100     return 0;101 }

 

 

 

 

------------------------------- map 小结
    直观来说，map 容器区别于 set 容器的一个主要特性在于，map 是处理带有键值的记录型元素数据的快速插入、删除 和检索，而 set 则可看成是对单一数据的处理。map 将一个元素划分出键值部分，并按这个局部的键值指定整个元素的函数比较规则，来建立容器的数据分布。map 的元素键值是唯一的，不允许重复的元素键值插入。 set 和 map 都是泛型库对二叉树的一个泛化。
    
    map 缺点：map是比较高级的用法了，适合用 list , vector 就能完成的操作，就不需要用到 map 。
    map 优点：相比 set ，map 可处理带有键值的记录型数据的快速插入、删除和检索。检索的速度也是非常快的。

 

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