STL map使用方法
STL中map用法详解说明：如果你具备一定的C++ template知识，即使你没有接触过STL，这个文章你也应该可能较轻易的看懂。
本人水平有限，不当之处，望大家辅正。
一．Map概述Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。
这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，后边我们会见识到有序的好处。
下面举例说明什么是一对一的数据映射。
比如一个班级中，每个学生的学号跟他的姓名就存在着一一映射的关系，这个模型用map可能轻易描述，很明显学号用int描述，姓名用字符串描述(本篇文章中不用char *来描述字符串，而是采用STL中string来描述),下面给出map描述代码：Map<int, string> mapStudent;map的构造函数map共提供了6个构造函数，这块涉及到内存分配器这些东西，略过不表，在下面我们将接触到一些map的构造方法，这里要说下的就是，我们通常用如下方法构造一个map：Map<int, string> mapStudent;数据的插入在构造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;}}map的大小在往map里面插入了数据，我们怎么知道当前已经插入了多少数据呢，可以用size函数，用法如下：Int nSize = mapStudent.size();数据的遍历这里也提供三种方法，对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”));mapStud ent.insert(pair<int, string>(3, “student_three”));int nSize = mapStudent.size()for(int nIndex = 0; nIndex < nSize; nIndex++){Cout<<mapStudent[nIndex]<<end;}}数据的查找（包括判定这个关键字是否在map中出现）在这里我们将体会，map在数据插入时保证有序的好处。
C++ STL----map
C++ STLBy Li-Bangzhu●map解释map（映射）——经过排序了的二元组的集合，map中的每个元素都是由两个值组成，其中的key（键值，一个map中的键值必须是唯一的）是在排序或搜索时使用，它的值可以在容器中重新获取；而另一个值是该元素关联的数值。
比如，除了可以ar[43] ="overripe"这样找到一个数据，map还可以通过ar["banana"] ="overripe"这样的方法找到一个数据。
如果你想获得其中的元素信息，通过输入元素的全名就可以轻松实现。
map一对一的映射的结合，key不能重复。
●map的使用//代码可直接运行，运行环境系统：centos 6.5//此段代码演示了几种不同方法的插入元素，遍历元素，查找，删除元素#include<iostream>#include<map>#include<string>using namespace std;int main(){map<int ,int> mymap; //此map的key和value 都是int 型的map<int ,int>::iterator it; //定义一个迭代子it = mymap.begin();//用数组的方式插入数据for(int i= 0;i<10;i++){mymap[i]= (i+3);}for(it = mymap.begin();it !=mymap.end();it++) //遍历所有元素{cout<<it->first<<" "<<it->second<<endl;}cout<<endl<<endl;//用insert 的方式插入数据for(int j=10;j<20;j++){mymap.insert(pair<int,int>(j,j+10));}for(it= mymap.begin();it != mymap.end();){cout<<it->first<<" "<<it->second<<endl; //遍历所有元素++it;}cout<<endl<<endl;//insert的另外一中方式插入元素for(int k =20; k<30 ;k++){mymap.insert(map<int,int>::value_type(k,k+100));}for(it = mymap.begin();it!=mymap.end();){cout<<it->first<<" "<<it->second<<endl;//遍历所有元素++it;}cout<<"this size of map"<<mymap.size()<<endl;for(int index =0;index<mymap.size();index++){cout<<mymap[index]<<" "; //遍历所有元素}cout<<endl;cout<<mymap[0]<<endl;cout<<mymap[27]<<endl; //随机读取//findit = mymap.find(27);if(it != mymap.end()){cout<<"find,this value"<<endl;//deletemymap.erase(it);}for(int index =0;index<mymap.size();index++){cout<<mymap[index]<<" ";}cout<<endl;//clearmymap.clear();cout<<"the size of mymap"<<mymap.size()<<endl; }更多详情请浏览个人文库：/p/helpylee3Q。
c++中的map的用法
c++中的map的用法Map是一种关联容器，它提供了一种映射的方式，将一个值（value）与一个键（key）相对应。
在C++ STL（Standard Template Library）中，Map是一个非常常用的容器类型，它具有很高的效率和灵活性。
Map内部使用红黑树（一种自平衡的二叉搜索树）来进行高效的查找和插入操作，它的不同之处在于，它的每个节点都包含了一个键值对，其中键是唯一的。
使用Map之前需要引入头文件<map>，其使用方法是：```c++#include <map>map<key_type, value_type> my_map;```key_type表示键的类型，value_type表示值的类型。
Map的常用操作包括：1. 插入Map的插入可以使用insert()函数，例如：```c++//插入键值对//使用数组下标插入my_map["Jerry"] = 20;```2. 查找Map的查找可以使用find()函数，例如：```c++//查找键为"Tom"的值map<string, int>::iterator it = my_map.find("Tom");if (it != my_map.end()) { //如果找到了cout << "Tom's age is " << it->second << endl; //输出Tom的年龄}```3. 删除Map的删除可以使用erase()函数。
例如：```c++//删除键为"Tom"的值my_map.erase("Tom");```4. 遍历Map的遍历可以使用迭代器，例如：```c++//遍历map中的所有键值对for (auto it = my_map.begin(); it != my_map.end(); it++) {cout << "key is " << it->first << " , value is " << it->second << endl;}```需要注意的是，Map中的元素是按照键的大小进行排序的，如果需要按照值的大小进行排序，可以使用multimap容器。
stl使用手册
stl使用手册STL（标准模板库）是C++标准库的一个部分，提供了一套通用算法和数据结构的模板类。
下面是一个简单的STL使用手册，包括常用的容器、算法和迭代器的使用方法示例：1. 容器（Containers）：- vector（向量）：动态数组，可以通过索引访问元素。
- 声明和初始化：`vector<int> myVector;` 或 `vector<int> myVector = {1, 2, 3};`- 插入元素：`myVector.push_back(4);`- 访问元素：`int element = myVector[0];`- 遍历元素：`for (int element : myVector) { cout << element << " "; }`- list（链表）：双向链表，可以在任意位置插入、删除元素。
- 声明和初始化：`list<int> myList;` 或 `list<int> myList = {1, 2, 3};`- 插入元素：`myList.push_back(4);` 或 `myList.push_front(0);` - 删除元素：`myList.pop_back();` 或 `myList.pop_front();`- 遍历元素：`for (int element : myList) { cout << element << " "; }`- map（映射表）：键值对组成的有序集合，可以通过键访问值。
- 声明和初始化：`map<string, int> myMap;` 或 `map<string, int> myMap = {{"A", 1}, {"B", 2}};`- 插入元素：`myMap["C"] = 3;`- 访问元素：`int value = myMap["A"];`- 遍历元素：`for (pair<string, int> element : myMap) { cout << element.first << ":" << element.second << " "; }`- set（集合）：不重复元素的有序集合。
C++ STL模板和Map使用大全
C++ STL模板和Map使用大全C++map的基本操作和使用(2009-09-23 14:58:21)分类：nguages标签：cmap编程基本操作livehaiitMap是c++的一个标准容器，她提供了很好一对一的关系，在一些程序中建立一个map可以起到事半功倍的效果，总结了一些map基本简单实用的操作！1. map最基本的构造函数；map<string , int >mapstring; map<int ,string >mapint;map<sring, char>mapstring; map< char ,string>mapchar;map<char ,int>mapchar; map<int ,char >mapint；2. map添加数据；map<int ,string> maplive;1.maplive.insert(pair<int,string>(102,"aclive"));2.maplive.insert(map<int,string>::value_type(321,"hai"));3, maplive[112]="April";//map中最简单最常用的插入添加！3，map中元素的查找：find()函数返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器。
map<int ,string >::iterator l_it;;l_it=maplive.find(112);if(l_it==maplive.end())cout<<"we do not find 112"<<endl;else cout<<"wo find 112"<<endl;4,map中元素的删除：如果删除112；map<int ,string >::iterator l_it;;l_it=maplive.find(112);if(l_it==maplive.end())cout<<"we do not find 112"<<endl;else maplive.erase(l_it); //delete 112;5,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 << "The original map m1 is:";for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )cout << " " << m1_Iter->second;cout << "." << endl;// This is the member function version of swap//m2 is said to be the argument map; m1 the target mapm1.swap( m2 );cout << "After swapping with m2, map m1 is:";for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )cout << " " << m1_Iter -> second;cout << "." << endl;cout << "After swapping with m2, map m2 is:";for ( m1_Iter = m2.begin( ); m1_Iter != m2.end( ); m1_Iter++ )cout << " " << m1_Iter -> second;cout << "." << endl;// This is the specialized template version of swapswap( m1, m3 );cout << "After swapping with m3, map m1 is:";for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )cout << " " << m1_Iter -> second;cout << "." << endl;}6.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 << "The original 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 202 503 604 406 407 30请按任意键继续. . .7， map的基本操作函数：C++ Maps是一种关联式容器，包含“关键字/值”对begin() 返回指向map头部的迭代器clear(）删除所有元素count() 返回指定元素出现的次数empty() 如果map为空则返回trueend() 返回指向map末尾的迭代器equal_range() 返回特殊条目的迭代器对erase() 删除一个元素find() 查找一个元素get_allocator() 返回map的配置器insert() 插入元素key_comp() 返回比较元素key的函数lower_bound() 返回键值>=给定元素的第一个位置max_size() 返回可以容纳的最大元素个数rbegin() 返回一个指向map尾部的逆向迭代器rend() 返回一个指向map头部的逆向迭代器size() 返回map中元素的个数swap() 交换两个mapupper_bound() 返回键值>给定元素的第一个位置value_comp() 返回比较元素value的函数C++map的基本操作和使用(2009-09-23 14:58:21)分类：nguages标签：cmap编程基本操作livehaiitMap是c++的一个标准容器，她提供了很好一对一的关系，在一些程序中建立一个map可以起到事半功倍的效果，总结了一些map基本简单实用的操作！1. map最基本的构造函数；map<string , int >mapstring; map<int ,string >mapint;map<sring, char>mapstring; map< char ,string>mapchar;map<char ,int>mapchar; map<int ,char >mapint；2. map添加数据；map<int ,string> maplive;1.maplive.insert(pair<int,string>(102,"aclive"));2.maplive.insert(map<int,string>::value_type(321,"hai"));3, maplive[112]="April";//map中最简单最常用的插入添加！3，map中元素的查找：find()函数返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器。
C++ STL中Map的按Key排序和按Value排序
C++ STL中Map的按Key排序和按Value排序 map是用来存放<key, value>键值对的数据结构，可以很方便快速的根据key查到相应的value。
假如存储学生和其成绩（假定不存在重名，当然可以对重名加以区分），我们用map 来进行存储就是个不错的选择。
我们这样定义，map<string, int>，其中学生姓名用string 类型，作为Key；该学生的成绩用int类型，作为value。
这样一来，我们可以根据学生姓名快速的查找到他的成绩。
但是，我们除了希望能够查询某个学生的成绩，或许还想看看整体的情况。
我们想把所有同学和他相应的成绩都输出来，并且按照我们想要的顺序进行输出：比如按照学生姓名的顺序进行输出，或者按照学生成绩的高低进行输出。
换句话说，我们希望能够对map 进行按Key排序或按Value排序，然后按序输出其键值对的内容。
一、C++ STL中Map的按Key排序其实，为了实现快速查找，map内部本身就是按序存储的（比如红黑树）。
在我们插入<key, value>键值对时，就会按照key的大小顺序进行存储。
这也是作为key的类型必须能够进行<运算比较的原因。
现在我们用string类型作为key，因此，我们的存储就是按学生姓名的字典排序储存的。
【参考代码】1.#include<map>2.#include<string>3.#include<iostream>ing namespace std;5.6.typedef pair<string, int> PAIR;7.8.ostream& operator<<(ostream& out, const PAIR& p) {9.return out << p.first << "\t" << p.second;10.}11.12.int main() {13. map<string, int> name_score_map;14. name_score_map["LiMin"] = 90;15. name_score_map["ZiLinMi"] = 79;16. name_score_map["BoB"] = 92;17. name_score_map.insert(make_pair("Bing",99));18. name_score_map.insert(make_pair("Albert",86));19.for (map<string, int>::iterator iter = name_score_map.begin();20. iter != name_score_map.end();21. ++iter) {22. cout << *iter << endl;23. }24.return 0;25. }【运行结果】大家都知道map是stl里面的一个模板类，现在我们来看下map的定义：1.template < class Key, class T, class Compare = less<Key>,2.class Allocator = allocator<pair<const Key,T> > > class map;它有四个参数，其中我们比较熟悉的有两个: Key 和Value。
map容器的insert用法总结
map容器的insert用法总结map容器是C++ STL库中的一种关联容器，它以键值对（key-value pair）的形式存储数据，并且按照键的顺序进行自动排序。
插入操作是map容器中的一项重要操作，本文将详细介绍map容器的insert用法。
1.插入单个键值对可以使用insert函数将一个键值对插入到map容器中。
插入操作的时间复杂度为O(log n)，其中n为map容器中的元素个数。
具体用法如下：````cppstd::map<Key, Value> myMap;myMap.insert(std::pair<Key, Value>(key, value));```或者使用C++11新特性的初始化列表：````cppstd::map<Key, Value> myMap;myMap.insert({key, value});```2.插入键值对序列可以使用insert函数将一个键值对序列插入到map容器中。
插入操作的时间复杂度为O(k log n)，其中k为插入序列的元素个数，n为map 容器中的元素个数。
具体用法如下：````cppstd::map<Key, Value> myMap;myMap.insert(std::make_pair(key1, value1));myMap.insert(std::make_pair(key2, value2));myMap.insert(std::make_pair(key3, value3));//...```或者使用C++11新特性的初始化列表：````cppstd::map<Key, Value> myMap;myMap.insert({key1, value1});myMap.insert({key2, value2});myMap.insert({key3, value3});//...```3. 插入另一个map容器中的键值对可以使用insert函数将另一个map容器中的键值对插入到当前map 容器中。
stl：：map遍历并删除元素的几种方法
stl：：map遍历并删除元素的⼏种⽅法第⼀种 for循环：#include<map>#include<string>#include<iostream>using namespace std;int main(){map<int,string*> m;m[1]= new string("1111111111111111");m[2]= new string("2222222222222222");m[3]= new string("3333333333333333");m[4]= new string("4444444444444444");m[0]= new string("5555555555555555");map<int,string*>::iterator it;for(it=m.begin();it!=m.end();++it){cout<<"key: "<<it->first <<" value: "<<*it->second<<endl;delete it->second;m.erase(it);}return0;}结果如下：key: 0 value: 5555555555555555key: 1 value: 1111111111111111key: 2 value: 2222222222222222key: 3 value: 3333333333333333key: 4 value: 4444444444444444第⼆种while循环的遍历：#include <map>#include <string>#include <iostream>#include <cstring>using namespace std;struct ltstr{bool operator()(const char* s1, const char* s2) const{return strcmp(s1, s2) < 0;}};int main(){map<const char*, int, ltstr> ages;ages["Homer"] = 38;ages["Marge"] = 37;ages["Lisa"] = 8;ages["Maggie"] = 1;ages["Bart"] = 11;while( !ages.empty() ) {cout << "Erasing: " << (*ages.begin()).first << ", " << (*ages.begin()).second << endl;ages.erase( ages.begin() );}}运⾏结果：Erasing: Bart, 11Erasing: Homer, 38Erasing: Lisa, 8Erasing: Maggie, 1Erasing: Marge, 37更安全的for 循环遍历：#include<map>#include<string>#include<iostream>using namespace std;int main(){map<int,string*> m;m[1]= new string("1111111111111111");m[2]= new string("2222222222222222");m[3]= new string("3333333333333333");m[4]= new string("4444444444444444");m[0]= new string("5555555555555555");map<int,string*>::iterator it;for(it=m.begin();it!=m.end();){cout<<"key: "<<it->first <<" value: "<<*it->second<<endl;delete it->second;m.erase(it++);}return0;}运⾏结果与第⼀种⽅式相同，不过这种删除⽅式也是STL源码⼀书中推荐的⽅式，分析 m.erase(it++)语句，map中在删除iter的时候，先将iter做缓存，然后执⾏iter++使之指向下⼀个结点，再进⼊erase函数体中执⾏删除操作，删除时使⽤的iter就是缓存下来的iter(也就是当前iter(做了加操作之后的iter)所指向结点的上⼀个结点)。
STL之map与pair与unordered_map常用函数详解
STL 之map 与pair 与unordered_map 常⽤函数详解STL 之map 与pair 与unordered_map 常⽤函数详解⼀、map 的概述map 是STL 的⼀个关联容器，它提供⼀对⼀（其中第⼀个可以称为关键字，每个关键字只能在map 中出现⼀次，第⼆个可能称为该关键字的值）的数据处理能⼒，由于这个特性，它完成有可能在我们处理⼀对⼀数据的时候，在编程上提供快速通道。
这⾥说下map 内部数据的组织，map 内部⾃建⼀颗红⿊树(⼀种⾮严格意义上的平衡⼆叉树)，这颗树具有对数据的功能，所以在map 内部所有的数据都是有序的，后边我们会见识到有序的好处。
众所周知，在定义数组的时候⽐如（int array[10]) ，array[0]=25,array[1]=10,其实就是⼀个映射，将0—>25,1—>10,就是将0映射到25，将1映射到10，这种⼀⼀对应的关系就是映射，就数组来说，他的下标和其下标所对应的值就是⼀种映射关系，但是这⼀种关系⽐较死板，于是就有map ，这⼀种容器，。
⼆、map 的定义与初始化（插⼊）单独定义⼀个map ：typename1是键值的数据类型typename2是值的数据类型如果是字符串映射到整型数组，键值必须使⽤string 类型，⽽不能使⽤char 数组。
这是因为char 作为数组，不能作为键值。
map 的键和值可以是STL 的容器，我们将set 映射到⼀个字符串三、map 的元素的访问map 中的容器值可以通过：下标和迭代器进⾏访问。
下标访问map 键值是唯⼀的通过迭代器访问map 的迭代器与其他STL 容器相同下⾯来看⼀个⽰例：⾃动排序下⾯举例说明：map 可以建⽴将任何基本类型（包括STL 容器）映射到任何基本数据类型（包括STL 容器）// 引⼊⼀个头⽂件#include <map>map<typename1,typename2> mp;map<set<int>,string> mp;#include <iostream>#include <map>#include <string>using namespace std;int main(){ map<char,int> mp;mp['c']=20;mp['c']=30; // 由于键值唯⼀，第⼀个他的值将会被覆盖cout<<mp['c']<<endl;return 0;}// 输出30map<typename1,typename2>::iterator it;// 由于⼀个it 对应两个值，我们使⽤ it->first 访问键 it->second 访问值PS ：下⾯我以3种不同的⽅式进⾏插⼊不懂得可以参照这⼀篇⽂章：// 以类似数组的的表达⽅式来进⾏#include <iostream>#include <map>#include <string>using namespace std;int main(){map<char,int> mp;char key;int val;int t=5;while(t--){cin>>key>>val;mp[key]=val;}// 通过迭代器来访问for(map<char,int>::iterator it=mp.begin();it!=mp.end();it++){cout<<it->first<<" "<<it->second<<endl;}return 0;}a 5s 8z 6p 3t 7a 5p 3s 8t 7z 6其实细⼼的⼩伙伴已经发现，其输出结果是按照键值进⾏升序排序的。
stl map的用法
stl map的用法STL（Standard Template Library）是C++的标准库之一，包含了许多常用的数据结构和算法。
其中，STL map是一种关联容器，用于存储键值对（key-value pair）。
在使用STL map时，可以采取以下步骤：1. 包含头文件：`#include <map>`。
2. 声明map对象：`std::map<Key, Value> myMap;`，其中Key和Value分别是键和值的类型。
3. 插入键值对：可以使用`myMap.insert(std::make_pair(key, value));`或者`myMap[key] = value;`来插入键值对。
注意，如果插入的键已经存在，则后续的插入操作不会生效。
4. 访问键值对：使用`myMap[key]`可以访问到指定键对应的值。
如果键不存在，则会自动插入一个新的键值对，值初始化为默认值。
5. 查找键值对：可以使用`myMap.find(key)`来查找指定键对应的值。
如果找到了指定键，则返回一个指向该键值对的迭代器，否则返回一个指向末尾的迭代器。
6. 删除键值对：可以使用`myMap.erase(key)`来删除指定键对应的键值对。
7. 遍历键值对：可以使用迭代器来遍历map中的所有键值对。
比如：```cppfor(auto it = myMap.begin(); it != myMap.end(); ++it){std::cout << it->first << " => " << it->second << std::endl;}```除了上述基本用法，STL map还提供了许多其他的成员函数和操作符，可以进行排序、比较、合并等操作。
需要根据具体需求进行选择和使用。
stl中map的四种插入方法总结
stl中map的四种插⼊⽅法总结⽅法⼀：pair例：map<int, string> mp;mp.insert(pair<int,string>(1,"aaaaa"));⽅法⼆：make_pair例：map<int, string> mp;mp.insert(make_pair<int,string>(2,"bbbbb"));⽅法三：value_type例：map<int, string> mp;mp.insert(map<int, string>::value_type(3,"ccccc"));⽅法四：[]例：map<int, string> mp;mp[4] = "ddddd";四种⽅法异同：前三种⽅法当出现重复键时，编译器会报错，⽽第四种⽅法，当键重复时，会覆盖掉之前的键值对。
综合测试：#include<iostream>#include<map>using namespace std;int main(){map<int, string> mp;//map的插⼊⽅法有4种//insert返回值为pair 原型：typedef pair<iterator, bool> _Pairib//⽅法1.pair 在插⼊重复键的情况下前三种⽅法类似，这⾥只测试第⼀种pair<map<int,string>::iterator, bool> pair1 = mp.insert(pair<int,string>(1,"aaaaa11111"));if (pair1.second == true){cout<< "插⼊成功" <<endl;}else{cout<< "插⼊失败" <<endl;}pair<map<int,string>::iterator, bool> pair2 = mp.insert(pair<int,string>(1,"aaaaa22222"));if (pair2.second == true){cout<< "插⼊成功" <<endl;}else{cout<< "插⼊失败" <<endl;}//⽅法2.make_pairmp.insert(make_pair<int,string>(3,"bbbbb33333"));mp.insert(make_pair<int,string>(4,"bbbbb44444"));//⽅法3.value_typemp.insert(map<int, string>::value_type(5,"ccccc55555"));mp.insert(map<int, string>::value_type(6,"ccccc66666"));//⽅法4.[]mp[7] = "ddddd77777";mp[7] = "ddddd88888";for (map<int,string>::iterator it = mp.begin(); it != mp.end(); it++){cout<< it->first << "\t" << it->second <<endl;}cout<< "--------------------------------" <<endl;//删除while(!mp.empty()){map<int,string>::iterator it = mp.begin();cout<< it->first << "\t" << it->second <<endl; mp.erase(it);}return0;}。