STL中map用法详解
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容器。
c++ stl unordered_map与hashmap 实现原理
C++ STL 中的 `std::unordered_map` 是一个使用哈希表(hash table)实现的关联容器,提供了快速的查找、插入和删除操作。
在C++中,`std::unordered_map` 的实现原理主要是基于哈希表,而哈希表本身是一种通过计算键的哈希值来快速定位存储位置的数据结构。
下面简要介绍一下 `std::unordered_map` 和哈希表的实现原理:### std::unordered_map`std::unordered_map` 是 C++ 标准库中用于存储键值对的容器。
它以键为索引,可以快速地通过键查找对应的值。
在 `std::unordered_map` 中,每个键值对是一个元素,其中键是唯一的,不允许重复。
### 哈希表实现原理哈希表是基于哈希函数的一种数据结构,它通过将键映射到索引的方式来实现高效的查找操作。
哈希表一般包括以下几个关键组成部分:1. 哈希函数:将键映射到哈希表中的索引位置的函数。
这个函数需要具有良好的分布特性,能够将不同的键均匀地映射到不同的索引位置上。
2. 数组:用于存储实际的键值对数据。
哈希表内部通常使用数组来作为存储结构,每个元素存储一个链表或者红黑树,用于解决哈希冲突问题。
3. 冲突处理:由于哈希函数的映射不是一一对应的,可能会出现不同的键映射到相同的索引位置,这就是哈希冲突。
常见的处理方法包括链地址法(Chaining)、开放定址法(Open Addressing)和再哈希等。
在 `std::unordered_map` 中,哈希表一般采用拉链法(Chaining)来处理冲突,即使用数组存储链表,当多个键映射到同一索引位置时,将它们放入同一个索引位置对应的链表中。
当链表过长时,可以转换为红黑树,以提高查找效率。
总的来说,`std::unordered_map` 使用哈希表作为底层数据结构,通过哈希函数将键映射到对应的索引位置,并采用链表或红黑树来处理哈希冲突,从而实现快速的插入、删除和查找操作。
c++hashmap stl方法
C++中的hashmap是一种非常强大的数据结构,它提供了快速查找、插入和删除元素的功能。
在STL(标准模板库)中,我们可以使用hashmap来实现这些功能,从而提高程序的性能和效率。
本文将详细介绍C++中hashmap的STL方法,包括其基本原理、使用方法及一些实际应用。
一、hashmap的基本原理hashmap是一种将键和值相关联的数据结构,它通过哈希函数将键映射到存储值的位置。
这样可以实现快速的查找、插入和删除操作,时间复杂度为O(1)。
在C++中,STL提供了unordered_map模板类用来实现hashmap。
unordered_map使用哈希表来存储数据,每个元素都包括一个键和一个值。
它使用哈希函数将键映射到桶(bucket)中,桶是存储元素的基本单元。
当我们需要查找、插入或删除元素时,只需计算键的哈希值并将其映射到对应的桶中,然后在桶中进行操作。
二、unordered_map的使用方法在C++中,使用unordered_map非常简单,首先需要包含<unordered_map>头文件,然后可以定义一个unordered_map对象并开始使用。
下面是一个简单的示例:```cpp#include <iostream>#include <unordered_map>int m本人n() {std::unordered_map<int, std::string> umap;// 插入操作umap[1] = "one";umap[2] = "two";umap[3] = "three";// 查找操作std::cout << umap[2] << std::endl; // 输出:two// 删除操作umap.erase(3);return 0;}```在上面的示例中,我们首先定义了一个unordered_map对象umap,其键的类型为int,值的类型为std::string。
map函数简介
map函数简介简简单单讲map(一)map函数map BLOCK LISTmap EXPR, LISTmap函数对LIST里的每个元素按BLOCK或EXPR进行计算,遍历LIST时,临时将LIST里的每个元素赋值给$_变量。
map对每次的计算返回一个结果列表,它在列表上下文里计算BLOCK或EXPR。
每个LIST元素可能在输出列表里产生0个,1个,或多个元素。
(仙子注:上文是说遍历每个LIST元素时产生一个结果列表,而不是说总的map结果是个列表,不要搞混了哦。
)在标量上下文里,map返回结果列表的元素数量。
在HASH上下文里,输出列表(a,b,c,d...)会变成这样的形式: ( a =>; b, c =>; d, ... )。
假如输出列表的元素数量非对称,那么最后的hash元素的值就是undef了。
避免在BLOCK或EXPR里修改$_,因为这会修改LIST里的元素。
另外,避免使用map返回的的列表作为左值,因为这也会修改LIST里的元素。
(所谓左值,就是在某个表达式左边的变量。
)(二)Map vs. grep vs. foreachmap跟grep一样,从数组里选择元素。
下列2句是一样的:@selected = grep EXPR, @input;@selected = map { if (EXPR) { $_ } } @input;另外,map也是foreach陈述的特殊形式。
假如@transformed 数组当前未定义或为空,那么下列2句亦相等:foreach (@input) { push @transformed, EXPR; }@transformed = map EXPR, @input;通常,用grep来从数组里选择元素,用map来从数组里转换元素。
当然,数组处理也能使用标准的循环语句来完成(foreach, for, while, until, do while, do until, redo)。
std::map用法
std::map⽤法STL是标准C++系统的⼀组模板类,使⽤STL模板类最⼤的好处就是在各种C++编译器上都通⽤。
在STL模板类中,⽤于线性数据存储管理的类主要有vector, list, map 等等。
本⽂主要针对map对象,结合⾃⼰学习该对象的过程,讲解⼀下具体⽤法。
本⼈初学,⽔平有限,讲解差错之处,请⼤家多多批评指正。
map对象所实现的功能跟MFC得CMap相似,但是根据⼀些⽂章的介绍和论述,MFC CMap在个⽅⾯都与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类,我们对模板类进⾏⼀下类型定义,这样⽤的⽅便,当然,不定义也可以,代码如下:typedef std: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()⽅法:int nSize = enumMap.size();查找map中是否包含某个关键字条⽬⽤find⽅法,传⼊的参数是要查找的key,在我们的例⼦⾥,是⼀个int数据,map中的条⽬数据是顺序存储的,被称作为⼀个sequence,在这⾥需要提到的是begin()和end()两个成员,分别代表map对象中第⼀个条⽬和最后⼀个条⽬,这两个数据的类型是iterator,iterator被定义为map中条⽬的类型,查找是否包含某个条⽬的代码如下:int nFindKey = 2; //要查找的KeyUDT_MAP_INT_CSTRING::iterator it; //定义⼀个条⽬变量(实际是指针)it = enumMap.find(nFindKey);if(it == enumMap.end()) {//没找到}else {//找到}//find的时候注意key的数据类型,最好⽤CString之类的能消除数据类型差异的key,否则可能会出现强制转换后仍找不到的情况。
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++使用:C++中map的基本操作和用法
C++使⽤:C++中map的基本操作和⽤法在阅读SSD代码中发现作者使⽤了C++中的map⽅法,因此搜索该关联式容器的使⽤⽅法,在这⾥⼀并总结。
⼀、Map 簡介Map是STL的⼀個容器,它提供⼀對⼀的hash。
第⼀個可以稱為關鍵字(key),每個關鍵字只能在map中出現⼀次,第⼆個可能稱為該關鍵字的值(value)Map以模板(泛型)⽅式實現,可以儲存任意類型的變數,包括使⽤者⾃定義的資料型態。
Map主要⽤於資料⼀對⼀映射(one-to-one)的情況,map內部的實現⾃建⼀顆紅⿊樹,這顆樹具有對數據⾃動排序的功能。
⽐如⼀個班級中,每個學⽣的學號跟他的姓名就存在著⼀對⼀映射的關係。
⼆、成員函式概觀與常⽤程式寫法1. 变量声明map<string, string> mapStudent;2. 插⼊元素//⽤insert函數插⼊pairmapStudent.insert(pair<string, string>("r000", "student_zero"));//⽤"array"⽅式插⼊mapStudent["r123"] = "student_first";mapStudent["r456"] = "student_second";3. 查找出現時,它返回資料所在位置,如果沒有,返回iter與end函數返回相同iter = mapStudent.find("r123");if(iter != mapStudent.end())cout<<"Find, the value is"<<iter->second<<endl;elsecout<<"Do not Find"<<endl;4. 刪除與清空清空map中的數據可以⽤clear()函數,判定map中是否有數據可以⽤empty()函數,它返回true則說明是空map,⽽資料的刪除要⽤到erase函數,它有三個overload的函數。
[STL]map按value值查找——find_if的使用
[STL]map按value值查找——find_if的使⽤最近是经常使⽤stl中的map,于是就想记⼀些关于map的东西。
这⼀篇中会讲到map按照value值查找的⽅法,就是find_if函数。
⼤家都知道在map中,排序是按照key值排的,map⾃带的find⽅法也是按着key值查找的,这在某些情况下可能会遇到⼀些⿇烦。
譬如,map<int, char*> m_str中,传⼊⼀个char*需要查找在m_str中是否存在这个字符串,当然你⼤可以使⽤iterator遍历⼀些map,如果你坚持这么做,那就可以直接关闭⽹页了。
1.先来看看find_if的原型:template <class InputIterator, class Predicate>InputIterator find_if(InputIterator first, InputIterator last,Predicate pred){while (first != last && !pred(*first)) ++first;return first;}find_if是⼀个模板函数,接受两个数据类型:InputItearator迭代器,Predicate⽤于⽐较数值的函数或者函数对象(仿函数)。
find_if对迭代器要求很低,只需要它⽀持⾃增操作即可。
当前遍历到的记录符合条件与否,判断标准就是使得pred()为真。
⾄此可能还有些不是很明了,下⾯举⼏个例⼦实际操练下的它的⽤法。
注意观察第三个参数pred。
2.find_if在std::map查找时的应⽤假如我们有个map对象是这么声明的:std::map<int, std::string> mymap;mymap.insert(std::make_pair(20, "USA"));mymap.insert(std::make_pair(10, "CHINA"));mymap.insert(std::make_pair(30, "English"));mymap.insert(std::make_pair(40, "Hongkong"));插⼊值后我们想得到值为”english”的这条记录,要怎样写程序呢?下⾯是个范例参考下:#include <map>#include <string>#include <algorithm>class map_value_finder{public:map_value_finder(const std::string &cmp_string):m_s_cmp_string(cmp_string){}bool operator ()(const std::map<int, std::string>::value_type &pair){return pair.second == m_s_cmp_string;}private:const std::string &m_s_cmp_string;};int main(){std::map<int, std::string> my_map;my_map.insert(std::make_pair(10, "china"));my_map.insert(std::make_pair(20, "usa"));my_map.insert(std::make_pair(30, "english"));my_map.insert(std::make_pair(40, "hongkong"));std::map<int, std::string>::iterator it = my_map.end();it = std::find_if(my_map.begin(), my_map.end(), map_value_finder("English"));if (it == my_map.end())printf("not found\n");elseprintf("found key:%d value:%s\n", it->first, it->second.c_str());return0;}class map_finder即⽤于⽐较的函数对象,它的核⼼就是重载的()运算符。
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;}。
stl容器set,map,vector之erase用法与返回值详细解析
stl容器set,map,vector之erase⽤法与返回值详细解析总结本⼈在⼯作中经验教训。
在使⽤ list、set 或 map遍历删除某些元素时可以这样使⽤:复制代码代码如下:std::list< int> List;std::list< int>::iterator itList;for( itList = List.begin(); itList != List.end(); ){if( WillDelete( *itList) ){itList = List.erase( itList);}elseitList++;}复制代码代码如下:std::list< int> List;std::list< int>::iterator itList;for( itList = List.begin(); itList != List.end(); ){if( WillDelete( *itList) ){List.erase(itList++);}elseitList++;}复制代码代码如下:std::list< int> List;std::list< int>::iterator it, next;for( it = List.begin(), next = it, next ++; it != List.end(); it = next, ++next){if( WillDelete( *it) ){List.erase(it);}}注:⽅法三更为巧妙,但需注意⽅法三是⽤前需要判断容器是否为空,否则迭代器会出问题。
我测试得出,set.erase 不返回迭代器,list返回。
vector 删除操作复制代码代码如下:std::vector <PACK_PRINT>::iterator It ;for(It=printItems.begin();It!=printItems.end();){//我是说这⾥怎么判断printItems printItems ⾥PACK_PRINT.bh =0if( It.bh ==0) //是这样吗?{//删除It=printItems.erase(It);}else{//不删除++It;}}复制代码代码如下:std::vector <PACK_PRINT> printItems;int i = 0;while(i < printItems.size()){if(printItems[i].bh == 0) //这⾥⽐如我想把 printItems 时PACK_PRINT.bh =0 的删除如何写哟。
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、set的数据结构及底层实现
STL中map、set的数据结构及底层实现摘要:本文列出几个基本的STL map和STL set的问题,通过解答这些问题讲解了STL关联容器内部的数据结构,最后提出了关于UNIX/LINUX自带平衡二叉树库函数和map, set 选择问题,并分析了map, set的优势之处。
对于希望深入学习STL和希望了解STL map 等关联容器底层数据结构的朋友来说,有一定的参考价值。
vector(向量)——STL中标准而安全的数组。
只能在vector 的“前面”增加数据。
deque(双端队列double-ended queue)——在功能上和vector相似,但是可以在前后两端向其中添加数据。
list(列表)——游标一次只可以移动一步。
如果你对链表已经很熟悉,那么STL中的list 则是一个双向链表(每个节点有指向前驱和指向后继的两个指针)。
set(集合)——包含了经过排序了的数据,这些数据的值(value)必须是唯一的。
map (映射)——经过排序了的二元组的集合,map中的每个元素都是由两个值组成,其中的key(键值,一个map中的键值必须是唯一的)是在排序或搜索时使用,它的值可以在容器中重新获取;而另一个值是该元素关联的数值。
比如,除了可以ar[43] = "overripe"这样找到一个数据,map还可以通过ar["banana"] = "overripe"这样的方法找到一个数据。
如果你想获得其中的元素信息,通过输入元素的全名就可以轻松实现。
multiset(多重集)——和集合(set)相似,然而其中的值不要求必须是唯一的(即可以有重复)。
multimap(多重映射)——和映射(map)相似,然而其中的键值不要求必须是唯一的(即可以有重复)。
STL map和set的使用虽不复杂,但也有一些不易理解的地方,如:# 为何map和set的插入删除效率比用其他序列容器高?# 为何每次insert之后,以前保存的iterator不会失效?# 为何map和set不能像vector一样有个reserve函数来预分配数据?# 当数据元素增多时(10000到20000个比较),map和set的插入和搜索速度变化如何?或许有得人能回答出来大概原因,但要彻底明白,还需要了解STL的底层数据结构。
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其实细⼼的⼩伙伴已经发现,其输出结果是按照键值进⾏升序排序的。
map遍历方法
map遍历方法map是C++ STL中的一种关联式容器,表示一种映射关系,它提供了一种将键值和实值关联起来的方法。
对于map的遍历,常常有以下几种方法:方法一:使用迭代器遍历map使用迭代器遍历map是一种常见的方法,它可以使用STL内部定义的迭代器遍历整个map容器,代码如下:```// 定义一个包含整数键和字符串实值的mapstd::map<int, std::string> myMap;.... // 添加一些数据到map中// 定义一个指向map的迭代器std::map<int, std::string>::iterator it;// 遍历整个map并输出键值对for (it = myMap.begin(); it != myMap.end(); ++it) {std::cout << "Key: " << it->first << " Value: " << it->second << std::endl;}```在上面的代码中,我们使用了begin()和end()方法来返回map的起始和终止迭代器。
当迭代器指向map的结尾时,循环结束。
方法二:使用auto关键字遍历map自C++ 11起,引入了关键字auto,它可以根据右侧变量的类型推断出一个变量的类型。
我们可以使用auto关键字来简化上面的代码,代码如下:```// 定义一个包含整数键和字符串实值的mapstd::map<int, std::string> myMap;.... // 添加一些数据到map中// 遍历整个map并输出键值对for (auto it = myMap.begin(); it != myMap.end(); ++it) {std::cout << "Key: " << it->first << " Value: " << it->second << std::endl;}```在上面的代码中,我们使用auto关键字来创建一个迭代器,编译器会自动推断出迭代器的类型。
c++数据结构map的使用详解
c++数据结构map的使⽤详解⽬录map的常⽤⽤法1. 头⽂件2. 定义3. map 容器内元素的访问(1)通过下标访问(2)通过迭代器访问(3)通过逆向迭代器访问4. map 元素的插⼊5. map 常⽤函数实例解析(1)find()(2)erase()(3)size()(4)count()(5)clear()(6)empty()(7)lower_bound() 、upper_bound()map的常⽤⽤法map 表⽰映射,可以将任何基本类型(包括 STL 容器)映射到任何基本类型(包括 STL 容器),例如可以建⽴如 int 到double,string 到 int 的映射等。
map 提供⼀对⼀的 hash,该功能类似 Python 的字典:第⼀个称为键( key ),每个关键字只能在 map 中出现⼀次;第⼆个称为该键的值( value );1. 头⽂件<bits/stdc++.h> 头⽂件已经包括了该头⽂件。
2. 定义定义 map 如下,参数的第⼀个为 key 的类型,第⼆个为 value 的类型。
map<typename1, typename2> mp;【注意】如果是字符串到整型的映射,必须使⽤ string ⽽不能⽤ char 数组。
map 的键和值也可以是 STL 容器,例如可以将⼀个 set 容器映射到⼀个字符串:map<set<int>, string> mp;3. map 容器内元素的访问(1)通过下标访问注意:map 的键是唯⼀的。
#include <iostream>#include <map>using namespace std;int main(){map<char, int> mp;mp['c'] = 30;cout << mp['c'] << endl;return 0;}30(2)通过迭代器访问定义迭代器:map<typename1, typename2>::iterator it;这样可以得到迭代器 it,map 可以使⽤ it->first来访问键,使⽤ it->second 来访问值。
C++中STL中的map用法详解
STL中map用法详解说明:如果你具备一定的C++ template知识,即使你没有接触过STL,这个文章你也应该可能较轻易的看懂。
本人水平有限,不当之处,望大家辅正。
一.Map概述Map是STL的一个关联容器,它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据处理能力,由于这个特性,它完成有可能在我们处理一对一数据的时候,在编程上提供快速通道。
这里说下map内部数据的组织,map内部自建一颗红黑树(一种非严格意义上的平衡二叉树),这颗树具有对数据自动排序的功能,所以在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;mapSt udent.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。
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。
STL中Map的erase函数
STL中Map的erase函数STL的map表⾥有⼀个erase⽅法⽤来从⼀个map中删除掉指令的节点eg1:#include <map>using namespace std;map<string,string> mapTest;typedef map<string,string>::iterator ITER;ITER iter=mapTest.find(key);mapTest.erase(iter);像上⾯这样只是删除单个节点,map的形为不会出现任务问题,但是当在⼀个循环⾥⽤的时候,往往会被误⽤,那是因为使⽤者没有正确理解iterator的概念.像下⾯这样的⼀个例⼦就是错误的写法,eg2: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();){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);}3.当想删除部分元素时,如下操作:#include<map>using namespace std;for(ITER iter=mapTest.begin();iter!=mapTest.end();){if(NeedErase(iter))iter=mapTest.erase(iter);elseiter++;}这种⽅法对所有的容器类型都适⽤!。
37、STL中unordered_map和map的区别和应用场景
37、 STL中 unordered_map和 map的区别和应用场景
map支持键值的自动排序,底层机制是红黑树,红黑树的查询和维护时间复杂度均为$O(logn)$,但是空间占用比较大,因为每个节点要保 持父节点、孩子节点及颜色的信息
unordered_map是C++ 11新添加的容器,底层机制是哈希表,通过hash函数计算元素位置,其查询时间复杂度为O(1),维护时间与bucket 桶所维护的list长度有关,但是建立hash表耗时较大
从两者的底层机制和特点可以看出:map适用于有序数据的应用场景,unordered_map适用于高效查询的应用场景
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还提供了许多其他的成员函数和操作符,可以进行排序、比较、合并等操作。
需要根据具体需求进行选择和使用。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
//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中没有要查找的数 据,它返回的迭代器等于函数返回的迭代器,程序说明 #include <map> #include <string> #include <iostream> Using namespace std; Int main()
#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;
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>
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,
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++)
{ 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; } }
“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
在往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;