精华内容
下载资源
问答
  • 大家都知道map容器是C++ STL中的重要一员,平时会遇到删除map容器中value为指定元素的问题,例如删除所有字符串为”123″或者能整除3的元素。 一、map容器下的方法说明 由于map容器下的方法较多,这里只列举代码中用...
  • 本文实例讲述了JavaScript实现Java中Map容器的方法。分享给大家供大家参考,具体如下: 声明一下,JavaScript和Java的区别就像雷锋和雷峰塔的区别. 在Java中,Map是一种集合,用来存储Key-Value键值对的容器.根据键得到...
  • map 容器的说明和使用技巧

    千次阅读 多人点赞 2018-07-27 16:17:02
    Map是STL的一个关联容器,它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据 处理能力,由于这个特性,它完成有可能在我们处理一对一数据的时候,在...

     

    Map是STL的一个关联容器,它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据 处理能力,由于这个特性,它完成有可能在我们处理一对一数据的时候,在编程上提供快速通道。这里说下map内部数据的组织,map内部自建一颗红黑树(一 种非严格意义上的平衡二叉树),这颗树具有对数据自动排序的功能,所以在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共提供了6个构造函数,

    以下是其中几个

    std::map<std::string, int> default_map;    //默认构造
    std::map<std::string, int> copied_map(default_map);    //拷贝构造
    std::map<std::string, int> iter_map(default_map.find("abc"), default_map.end());    //Range constructor
    
    //C++11 初始值列构造
    std::map<std::string, int> init_map {
        {"this", 100},
        {"can", 100},
        {"be", 100},
        {"const", 100},
      };

     

     

     

     

    5、     数据的插入

     

    在构造map容器后,我们就可以往里面插入数据了。这里讲三种插入数据的方法:

     

    第一种:用insert函数插入pair数据,下面举例说明(以下代码虽然是随手写的,应该可以在VC和GCC下编译通过,大家可以运行下看什么效果,在VC下请加入这条语句,屏蔽4786警告 #pragma warning (disable:4786) )

    //数据的插入--第一种:用insert函数插入pair数据
    #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<<endl;
     
    }

     

    第二种:用insert函数插入value_type数据,下面举例说明

    //第二种:用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<<endl;
     
    }

    第三种:用数组方式插入数据,下面举例说明

    //第三种:用数组方式插入数据,下面举例说明
     
    #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<<endl;
     
    }

    以上三种用法,虽然都可以实现数据的插入,但是它们是有区别的,当然了第一种和第二种在效果上是完成一样的,用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<<endl;
     
    }

    大家可以用如下程序,看下用数组插入在数据覆盖上的效果

    //验证数组形式插入数据的效果
     
    #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<<endl;
    }

    6、      map的大小

     

    在往map里面插入了数据,我们怎么知道当前已经插入了多少数据呢,可以用size函数,用法如下:

     

    Int nSize = mapStudent.size();

     

     

    7、     数据的遍历

     

    这里也提供三种方法,对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<<endl;
     
    }

    第三种,用数组的形式,程序说明如下:

    //第三种:用数组方式,程序说明如下
     
    #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++)
    //而不是 for(int nindex = 0; nindex < nSize; nindex++)
     
        for(int nindex = 1; nindex <= nSize; nindex++)
     
            cout<<mapStudent[nindex]<<endl;
     
    }

    8、    查找并获取map中的元素(包括判定这个关键字是否在map中出现)

     

     

    在这里我们将体会,map在数据插入时保证有序的好处。

     

    要判定一个数据(关键字)是否在map中出现的方法比较多,这里标题虽然是数据的查找,在这里将穿插着大量的map基本用法。

     

    这里给出三种数据查找方法

     

    第一种:用count函数来判定关键字是否出现,其缺点是无法定位数据出现位置,由于map的特性,一对一的映射关系,就决定了count函数的返回值只有两个,要么是0,要么是1,出现的情况,当然是返回1了

     

    第二种:用find函数来定位数据出现位置,它返回的一个迭代器,当数据出现时,它返回数据所在位置的迭代器,如果map中没有要查找的数据,它返回的迭代器等于end函数返回的迭代器。

    查找map中是否包含某个关键字条目用find()方法,传入的参数是要查找的key,在这里需要提到的是begin()和end()两个成员,

    分别代表map对象中第一个条目和最后一个条目,这两个数据的类型是iterator.

     

    程序说明

    #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;
     
        iter = mapStudent.find(1);
     
        if(iter != mapStudent.end())
     
           cout<<"Find, the value is "<<iter->second<<endl;
     
        else
     
           cout<<"Do not Find"<<endl;
        
        return 0;
    }

    通过map对象的方法获取的iterator数据类型是一个std::pair对象,包括两个数据 iterator->first和 iterator->second分别代表关键字和存储的数据。

     

     

     

    第三种:这个方法用来判定数据是否出现,是显得笨了点,但是,我打算在这里讲解

     

    lower_bound函数用法,这个函数用来返回要查找关键字的下界(是一个迭代器)

     

    upper_bound函数用法,这个函数用来返回要查找关键字的上界(是一个迭代器)

     

    例如:map中已经插入了1,2,3,4的话,如果lower_bound(2)的话,返回的2,而upper-bound(2)的话,返回的就是3

     

    Equal_range函数返回一个pair,pair里面第一个变量是Lower_bound返回的迭代器,pair里面第二个迭代器是Upper_bound返回的迭代器,如果这两个迭代器相等的话,则说明map中不出现这个关键字,

    程序说明

    #include <map>
     
    #include <string>
     
    #include <iostream>
     
    using namespace std;
     
    int main()
     
    {
     
        map<int, string> mapStudent;
     
        mapStudent[1] = "student_one";
     
        mapStudent[3] = "student_three";
     
        mapStudent[5] = "student_five";
     
        map<int, string>::iterator iter;
     
        iter = mapStudent.lower_bound(1);
     
        //返回的是下界1的迭代器
     
            cout<<iter->second<<endl;
     
        iter = mapStudent.lower_bound(2);
     
        //返回的是下界3的迭代器
     
            cout<<iter->second<<endl;
     
        iter = mapStudent.lower_bound(3);
     
        //返回的是下界3的迭代器
     
            cout<<iter->second<<endl;
     
        iter = mapStudent.upper_bound(2);
     
        //返回的是上界3的迭代器
     
            cout<<iter->second<<endl;
     
        iter = mapStudent.upper_bound(3);
     
        //返回的是上界5的迭代器
     
            cout<<iter->second<<endl;
     
        pair<map<int, string>::iterator, map<int, string>::iterator> mappair;
     
        mappair = mapStudent.equal_range(2);
     
        if(mappair.first == mappair.second)
     
            cout<<"Do not Find"<<endl;
     
        else
     
            cout<<"Find"<<endl;
     
        mappair = mapStudent.equal_range(3);
     
        if(mappair.first == mappair.second)
     
            cout<<"Do not Find"<<endl;
     
        else
     
            cout<<"Find"<<endl;
     
        return 0;
    }

    9、    从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());

     

    这里要用到erase函数,它有三个重载了的函数,下面在例子中详细说明它们的用法

    #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"));
     
            //如果你要演示输出效果,请选择以下的一种,你看到的效果会比较好
     
           //如果要删除1,用迭代器删除
     
           map<int, string>::iterator iter;
     
           iter = mapStudent.find(1);
     
           mapStudent.erase(iter);
     
           //如果要删除1,用关键字删除
     
           int n = mapStudent.erase(1);//如果删除了会返回1,否则返回0
     
           //用迭代器,成片的删除
     
           //一下代码把整个map清空
     
           mapStudent.erase( mapStudent.begin(), mapStudent.end() );
     
           //成片删除要注意的是,也是STL的特性,删除区间是一个前闭后开的集合
     
           //自个加上遍历代码,打印输出吧
     
    }

    10、    map中的swap用法

     

    map中的swap不是一个容器中的元素交换,而是两个容器所有元素的交换。

     

    11、     排序 ·  map中的sort问题

    map中的元素是自动按Key升序排序,所以不能对map用sort函数;

    这里要讲的是一点比较高深的用法了,排序问题,STL中默认是采用小于号来排序的,以上代码在排序上是不存在任何问题的,因为上面的关键字是int 型,它本身支持小于号运算,在一些特殊情况,比如关键字是一个结构体,涉及到排序就会出现问题,因为它没有小于号操作,insert等函数在编译的时候过 不去,下面给出两个方法解决这个问题。

     

    第一种:小于号重载,程序举例。

    #include <iostream>
    #include <string>
    #include <map>
    using namespace std;
     
    typedef struct tagStudentinfo
     
    {
     
           int      niD;
     
           string   strName;
     
           bool operator < (tagStudentinfo const& _A) const
     
           {     //这个函数指定排序策略,按niD排序,如果niD相等的话,按strName排序
     
                if(niD < _A.niD) return true;
     
                if(niD == _A.niD)
     
                    return strName.compare(_A.strName) < 0;
     
            return false;
     
           }
     
    }Studentinfo, *PStudentinfo; //学生信息
     
    int main()
     
    {
     
        int nSize;   //用学生信息映射分数
     
        map<Studentinfo, int>mapStudent;
     
        map<Studentinfo, int>::iterator iter;
     
        Studentinfo studentinfo;
     
        studentinfo.niD = 1;
     
        studentinfo.strName = "student_one";
     
        mapStudent.insert(pair<Studentinfo, int>(studentinfo, 90));
     
        studentinfo.niD = 2;
     
        studentinfo.strName = "student_two";
     
        mapStudent.insert(pair<Studentinfo, int>(studentinfo, 80));
     
        for (iter=mapStudent.begin(); iter!=mapStudent.end(); iter++)
     
            cout<<iter->first.niD<<' '<<iter->first.strName<<' '<<iter->second<<endl;
     
        return 0;
    }

    第二种:仿函数的应用,这个时候结构体中没有直接的小于号重载,程序说明

     
    //第二种:仿函数的应用,这个时候结构体中没有直接的小于号重载,程序说明
     
    #include <iostream>
     
    #include <map>
     
    #include <string>
     
    using namespace std;
     
    typedef struct tagStudentinfo
     
    {
     
           int      niD;
     
           string   strName;
     
    }Studentinfo, *PStudentinfo; //学生信息
     
    class sort
     
    {
     
    public:
     
        bool operator() (Studentinfo const &_A, Studentinfo const &_B) const
     
        {
     
            if(_A.niD < _B.niD)
     
                return true;
     
            if(_A.niD == _B.niD)
     
                return _A.strName.compare(_B.strName) < 0;
     
        return false;
     
        }
    };
     
    int main()
     
    {   //用学生信息映射分数
     
        map<Studentinfo, int, sort>mapStudent;
     
        map<Studentinfo, int>::iterator iter;
     
        Studentinfo studentinfo;
     
        studentinfo.niD = 1;
     
        studentinfo.strName = "student_one";
     
        mapStudent.insert(pair<Studentinfo, int>(studentinfo, 90));
     
        studentinfo.niD = 2;
     
        studentinfo.strName = "student_two";
     
        mapStudent.insert(pair<Studentinfo, int>(studentinfo, 80));
     
        for (iter=mapStudent.begin(); iter!=mapStudent.end(); iter++)
     
            cout<<iter->first.niD<<' '<<iter->first.strName<<' '<<iter->second<<endl;
    }

    由于STL是一个统一的整体,map的很多用法都和STL中其它的东西结合在一起,比如在排序上,这里默认用的是小于号,即less<>,如果要从大到小排序呢,这里涉及到的东西很多,在此无法一一加以说明。

     

    还要说明的是,map中由于它内部有序,由红黑树保证,因此很多函数执行的时间复杂度都是log2N的,如果用map函数可以实现的功能,而STL Algorithm也可以完成该功能,建议用map自带函数,效率高一些。

     

    下面说下,map在空间上的特性,否则,估计你用起来会有时候表现的比较郁闷,由于map的每个数据对应红黑树上的一个节点,这个节点在不保存你的 数据时,是占用16个字节的,一个父节点指针,左右孩子指针,还有一个枚举值(标示红黑的,相当于平衡二叉树中的平衡因子),我想大家应该知道,这些地方 很费内存了吧,不说了……

     

    12、   

          map的基本操作函数:

         C++ maps是一种关联式容器,包含“关键字/值”对

         begin()         返回指向map头部的迭代器

         clear()        删除所有元素

         count()         返回指定元素出现的次数

         empty()         如果map为空则返回true

         end()           返回指向map末尾的迭代器

         equal_range()   返回特殊条目的迭代器对

         erase()         删除一个元素

         find()          查找一个元素

         get_allocator() 返回map的配置器

         insert()        插入元素

         key_comp()      返回比较元素key的函数

         lower_bound()   返回键值>=给定元素的第一个位置

         max_size()      返回可以容纳的最大元素个数

         rbegin()        返回一个指向map尾部的逆向迭代器

         rend()          返回一个指向map头部的逆向迭代器

         size()          返回map中元素的个数

         swap()           交换两个map

         upper_bound()    返回键值>给定元素的第一个位置

         value_comp()     返回比较元素value的函数

    参考网站:https://en.cppreference.com/w/cpp/container/map

    感谢大佬:https://blog.csdn.net/shawn_hou/article/details/38035577#

    展开全文
  • C++ map容器-57-对组和map构造/赋值

    千次阅读 2020-08-12 22:42:33
    这篇开始学习C++中的Map容器,也叫字典,字典中的元素是键值对形式存在的。在学习map容器之前,我们先学习C++中的一个对组的小知识点。然后学习map容器的构造和赋值相关API。 1.对组 概念:成对出现的数据,利用...

    这篇开始学习C++中的Map容器,也叫字典,字典中的元素是键值对形式存在的。在学习map容器之前,我们先学习C++中的一个对组的小知识点。然后学习map容器的构造和赋值相关API。

     

    1.对组

    概念:成对出现的数据,利用对组可以返回两个数据。这个特点有点类似python中的元组。

    对组的两种创建方式

    下面写简单的练习代码,练习对组的两种创建方式,和如何获取对组中两组数据的方法。

    #include <iostream>
    #include <string>
    using namespace std;
    
    void test01()
    {
        // 对组创建方式1,有点像默认无参构造
        pair<string, int> p("Anthony", 23);
    
        // 对组创建方法2
        pair<string, int> p2 = make_pair("Tom", 18);
    
        // 如何访问对组中值
        cout << "Name: " << p.first << " Age: " << p.second << endl;
        cout << "Name: " << p2.first << " Age: " << p2.second << endl;
    }
    
    int main()
    {
        test01();
        system("pause");
        return 0;
    }

    运行结果

     

    2.map的构造和赋值

    上面有了对组的理解,然后从对组概念过度到字典容器中键值对。

    概念:

    • map中所有的元素都是pair
    • pair中第一个元素为key(键值),起到索引作用,第二个元素为value(实值)
    • 所有元素都会根据元素的键值自动排序

    本质
    map/multimap属于关联式容器,底层结构是用二叉树实现。

    优点:
    可以根据Key值快速找到value值

    map和multimap的区别

    • map不允许容器中有重复的key值元素
    • multimap允许容器中有重复的key值元素

    下面看看Map容器的构造相关API

    构造和赋值相关函数原型

    一个默认构造和拷贝构造,形式和前面其他容器一样。

    #include <iostream>
    #include <string>
    #include <map>
    using namespace std;
    
    void printMap(map<string, int>& m)
    {
        for(map<string, int> ::iterator it = m.begin(); it != m.end(); it++)
        {
            cout << "Key= " << (*it).first << " ,Value= " << (*it).second << endl;
        }
    }
    
    void test01()
    {
        // map容器的构造
        map<string, int> m;
    
        // map容器添加元素
        m.insert(pair<string, int>("Tom", 18));
        m.insert(pair<string, int>("Anthony", 23));
        m.insert(pair<string, int>("Bob", 24));
        m.insert(pair<string, int>("Sunny", 19));
        printMap(m);
    
        // map容器赋值操作
        cout << "========================" << endl;
        map<string, int> m2 = m;
        printMap(m);
    
    }
    
    int main()
    {
        test01();
        system("pause");
        return 0;
    }

    运行结果

    上面学习了:

    • 如何遍历map容器
    • map容器的插入操作,插入函数的参数是一个对组
    • map的构造和赋值操作

     

    展开全文
  • C++STL之map容器

    万次阅读 多人点赞 2018-08-08 21:12:08
    map容器的数据结构也采用红黑树来实现的,插入元素的键值不允许重复,比较函数只对元素的键值进行 比较,元素的各项数据可通过键值检索出来。由于map与set采用的都是红黑树的结构,所以,用法基本相似。  ...

    STL新手点击:STL新手入门向

    map

    map映射容器的元素数据是由一个键值和一个映射数据组成的,键值与映照数据之间具有一一映照的关系。

    map容器的数据结构也采用红黑树来实现的,插入元素的键值不允许重复,比较函数只对元素的键值进行

    比较,元素的各项数据可通过键值检索出来。由于map与set采用的都是红黑树的结构,所以,用法基本相似。

                                              

    map用法

    头文件

    #include<map>

    基本操作

    begin() 返回指向 map 头部的迭代器
    clear() 删除所有元素
    count() 返回指定元素出现的次数
    empty() 如果 map 为空则返回 true
    end() 返回指向 map 末尾的迭代器
    erase() 删除一个元素
    find() 查找一个元素
    insert() 插入元素
    key_comp() 返回比较元素 key 的函数
    lower_bound() 返回键值>=给定元素的第一个位置
    max_size() 返回可以容纳的最大元素个数
    rbegin() 返回一个指向 map 尾部的逆向迭代器
    rend() 返回一个指向 map 头部的逆向迭代器
    size() 返回 map 中元素的个数
    swap() 交换两个 map
    upper_bound() 返回键值>给定元素的第一个位置
    value_comp() 返回比较元素 value 的函数

     

    创建map对象

    #include<iostream>
    #include<map>
    using namespace std;
    map<int,char>mp;//定义map容器 

     插入

    	//数组方式插入 
    	mp[1]='a';
    	mp[1]='b';//key不允许重复,再次插入相当于修改value的值 
    	mp[2]='a'; 
    	mp[3]='b';
    	mp[4]='c';
    
        //insert()方式插入
    	mp.insert(map<int,char>::value_type(5,'d')); 

    删除

    //通过关键字key删除元素 
    	mp.erase('b');

    容器的size

    //输出容器大小 
    int s=mp.size();

    元素的遍历,清空

    //遍历输出map中的元素 
    	map<int,char>::iterator it=mp.begin();
    	while(it!=mp.end())
    	{
    		cout<<"key:"<<it->first<<" "; 
    		cout<<"value:"<<it->second<<endl;;
    		it++;
    	}
    
    mp.clear();//清空容器 

    元素的查找

    it=mp.find(1);//搜索键值为1的元素 
    	/*若该键值存在,则返回该键值所在的
    	  迭代器位置,不存在则返回end()迭代器位置 
    	*/
    	if(it!=mp.end())
    	{
    	    cout<<"存在键值为1的元素"<<endl;
    	}

    实例

    #include<iostream>
    #include<map>
    using namespace std;
    map<int,char>mp;//定义map容器 
    int main()
    {
    	//数组方式插入 
    	mp[1]='a';
    	mp[1]='b';//key不允许重复,再次插入相当于修改value的值 
    	mp[2]='a'; 
    	mp[3]='b';
    	mp[4]='c';
    	cout<<"根据key值输出对应的value值"<<mp[1]<<endl;
    	cout<<"无法根据value输出key值"<<mp['b']<<endl;
    	
    	//通过关键字key删除元素 
    	mp.erase('b');
    	
    	//insert()方式插入
    	mp.insert(map<int,char>::value_type(5,'d')); 
    	
    	//输出容器大小 
    	int s=mp.size();
    	cout<<s<<endl;
    	
    	//遍历输出map中的元素 
    	map<int,char>::iterator it=mp.begin();
    	while(it!=mp.end())
    	{
    		cout<<"key:"<<it->first<<" "; 
    		cout<<"value:"<<it->second<<endl;;
    		it++;
    	}
    	it=mp.find(1);//搜索键值为1的元素 
    	/*若该键值存在,则返回该键值所在的
    	  迭代器位置,不存在则返回end()迭代器位置 
    	*/
    	if(it!=mp.end())
    	{
    	    cout<<"存在键值为1的元素"<<endl;
    	}
    	//cout<<it->first<<it->second<<endl;	
    	mp.clear();//清空容器 
    	cout<<mp.size()<<endl;
    }

    map排序:

    map本身默认按照key值升序排序 

    //默认按照key值升序排序 
    #include<iostream>
    #include<map>
    using namespace std;
    map<int,char>mp;
    int main()
    {
    	map<int,char>::iterator it;
        mp[1]='c';
        mp[3]='b';
        mp[2]='d';
        mp[4]='a'; 
        for(it=mp.begin();it!=mp.end();it++)
        {
        	cout<<it->first<<" "<<it->second<<endl;
    	}
    	cout<<"可以看到map容器默认按照key值升序排列"<<endl; 
    }

    重载()自定义排序

    //重载()自定义排序 
    #include<iostream>
    #include<map>
    using namespace std;
    struct cmp{
    	bool operator()(const int x,const int y)
    	{
    		return x>y;//按照key值降序排列 
    	}
    };
    map<int,char,cmp>mp;
    int main()
    {
    	map<int,char>::iterator it;
        mp[1]='c';
        mp[3]='b';
        mp[2]='d';
        mp[4]='a'; 
        for(it=mp.begin();it!=mp.end();it++)
        {
        	cout<<it->first<<" "<<it->second<<endl;
    	}
    }

    按value自定义排序 

    //按value自定义排序 
    #include <iostream>  
    #include <map>  
    #include <vector>  
    #include <algorithm>  
    #include <utility>//pair的头文件 C++为什么pair不使用utility
    //也可以运行可能是其他头文件中包含了utility头文件。比如map头文件 
    using namespace std;
    typedef pair<string, int> PAIR;  
      
    bool cmp_by_value(const PAIR &x, const PAIR &y) {  
       return x.second>y.second;//按value降序排列 
       //return x.second<y.second;//按value升序排列 
    }  
    int main() {  
      map<string, int>mp;  
      mp["a"] = 7;  
      mp["c"] = 9;  
      mp["e"] = 2;  
      mp.insert(make_pair("d",10));  
      mp.insert(make_pair("b",8));  
     //把map中元素转存到vector中   
      vector<PAIR> v(mp.begin(),mp.end());   
      sort(v.begin(), v.end(), cmp_by_value);  
      for (vector<pair<string,int> >::iterator it=v.begin();it!=v.end();++it)  
       {  
        cout<<it->first<<'\t'<<it->second<<endl;  
       }
      return 0;  
    }
    /*可以简单的理解为如下:map可以当做一个容器(装载具有一定格式的数据);
    pair可以理解为元素(放入到容器的的一个个个体),
    发现pair并没有单独行动的典型用法,
    正常都是配合map来使用(即把pair这个元素插入到map这个容器里面)
    
    STL的<utility>头文件中描述了一个非常简单的模板类pair,
    用来表示一个二元组或元素对,并提供了大小比较的比较运算符模板函数。
    pair模板类需要两个参数:首元素的数据类型和尾元素的数据类型。
    pair模板类对象有两个成员:first和second,分别表示首元素和尾元素。*/

    当元素为结构体时自定义排序 

    //当元素为结构体时自定义排序 
    #include <iostream>  
    #include <map>     
    #include <utility> 
    using namespace std; 
    struct Info 
    { 
     string name; 
     float score; 
     //重载"<"操作符,自定义排序规则 
     bool operator < (const Info &a) const 
     { 
     if(score==a.score)
     return name>a.name;
     return score>a.score; 
     } 
    }; 
    int main(int argc, char* argv[]) 
    { 
     
     map<Info,int> m; 
     Info info; 
     info.name="Jack"; 
     info.score=60; 
     m[info]=25; 
     info.name="Tom";
     info.score=60;
     m[info]=30;
     info.name="Bomi"; 
     info.score=80; 
     m[info]=10; 
     info.name="Peti"; 
     info.score=66.5; 
     m[info]=30;  
     map<Info,int>::iterator it; 
     for(it=m.begin();it!=m.end();it++) 
     { 
     cout<<(*it).second<<" : "; 
     cout<<((*it).first).name<<" "<<((*it).first).score<<endl; 
     } 
     return 0; 
    } 

     

    展开全文
  • C++ map容器用法

    万次阅读 2018-09-22 20:09:01
    C++ map容器用法   介绍 Map是键-值对的集合,map中的所有元素都是pair,可以使用键作为下标来获取一个值。Map中所有元素都会根据元素的值自动被排序,同时拥有实值value和键值key,pair的第一元素被视为键值,...

    C++ map容器用法

     

    介绍

    Map是键-值对的集合,map中的所有元素都是pair,可以使用键作为下标来获取一个值。Map中所有元素都会根据元素的值自动被排序,同时拥有实值value和键值key,pair的第一元素被视为键值,第二元素被视为实值,同时map不允许两个元素有相同的键值。

    用法

    头文件

    #include<map>

    声明及其初始化

    map<key, value> m;//创建一个名为m的空map对象,其键和值的类型分别为key和value。
    
    map<key, value> m(m2);//创建m2的副本m,m与m2必须有相同的键类型和值类型。
    
    map<key, value> m(b,e);//创建map类型的对象m,存储迭代器b和e标记的范围内所有元素的副本,元素的类型必须能转换为pair
       
    map<key, value, comp> mp;//comp可选,为键值对存放策略,即键的比较函数,默认标准库使用键类型定义的 < 操作符来实现键的比较。所用的比较函数必须在键类型上定义严格的弱排序,可将其理解为键类型数据上的“小于”关系。在实际应用中,键类型必须能定义 < 操作符。对于键类型,其唯一的约束就是必须支持 < 操作符。

    基本操作

    给map容器添加元素可通过两种方式实现:

    1. 通过insert成员函数实现。
    2. 通过下标操作符获取元素,然后给获取的元素赋值。 map对象的访问可通过下标和迭代器两种方式实现:
    3. map的下标是键,返回的是特定键所关联的值。
    4. 使用迭代器访问,iter->first指向元素的键,iter->second指向键对应的值。 使用下标访问map容器与使用下标访问vector的行为截然不同:用下标访问map中不存在的元素将导致在map容器中添加一个新的元素,这个元素的键即为该下标值,键所对应的值为空。

    map容器和哈希表

    对于map容器,使用其下标行为一次访问一系列的相同类型的元素,则可以将这个过程理解为构造了这些元素的一个哈希表,以统计输入单词的出现次数为例:

    map<string, int> word_count;
    string word;
    while(cin>>word)
        ++word_count[word];  // 相当于生成了一个哈希表word_count

    在单词的第一次出现时,会在word_count中创建并插入一个以该单词为索引的新元素,同时将它的值初始化为0。然后其值立即加1,所以每次在map中添加新元素时,所统计的次数正好从1开始。需要注意的是,使用map创建的哈希表已经按键值进行了排序,所以序列的顺序已经不再是原始的输入顺序了。

    map成员函数

    不修改map对象的查询操作:

    m.count(k);  // 返回m中键值等于k的元素的个数。
    m.find(k);  // 如果m中存在按k索引的元素,则返回指向该元素的迭代器。如果不存在,则返回结束游标end()。

    对于map对象,由于map中不存在相同的两个或者多个键,所以count成员的返回值只能是0或者1,用于检查map对象中某键是否存在。find成员返回的是指向元素的迭代器,如果元素不存在,则返回end迭代器,用于读取元素而又不插入元素。

    从map对象中删除元素

    m.erase(k);  // 删除m中键为k的元素,返回size_type类型的值,表示删除元素的个数。
    m.erase(p);  // 从m中删除迭代器p所指向的元素,p必须指向m中确实存在的元素,而且不能等于m.end(),返回void类型。
    m.erase(iterator first, iterator last);  // 删除一个范围,返回void类型。

    map容器提供的insert操作

    m.insert(e) ;
    

    e是一个用在m上的value_type类型的值。如果键e.first不在m中,则插入一个值为e.second的新元素;如果该键在m中已存在,那么不进行任何操作。该函数返回一个pair类型对象,包含指向键为e.first的元素的map迭代器,以及一个bool类型的对象,表示是否插入了该元素。

    m.insert(beg, end);
    

    beg和end是标记元素范围的迭代器,对于该范围内的所有元素,如果它的键在m中不存在,则将该键及其关联的值插入到m。 返回void类型。

    m.insert(iter, e);
    

    e是value_type类型的值,如果e.first不在m中,则创建新元素,并以迭代器iter为起点搜索新元素存储的位置,返回一个迭代器,指向m中具有给定键的元素。 在添加新的map元素时,使用insert成员可避免使用下标操作符带来的副作用:不必要的初始化。

    展开全文
  • C++STL中map容器详解

    千次阅读 2018-08-23 14:26:48
    Map是STL的一个关联容器,它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据 处理能力,由于这个特性,它完成有可能在我们处理一对一数据的时候,在...
  • 使用C++标准库中的MAP容器实现词频统计与排序
  • // 定义map对象来存储数据,主线程中定时向该对象插入数据,每次插入两个连续的数据插入后显示出当前map大小。 //第二个线程定时删除map中的数据,每次删除一个最前面的数据,删除后显示当前的map大小。 //当主线程...
  • C++ STL map容器迭代器遍历 标准库为 map 容器配备的是双向迭代器(bidirectional iterator)。这意味着,map 容器迭代器只能进行 ++p、p++、–p、p–、*p 操作,并且迭代器之间只能使用 == 或者 != 运算符进行比较...
  • Java-通过工厂、Map容器创建对象

    千次阅读 多人点赞 2021-03-28 10:28:30
    本文通过两种方式去创建对象,1.工厂+反射+配置文件:单例模式,... 第二种对一做了一个优化,当类加载时,对象就已经构造好,之后每次使用从map中获取就行。其实Spring IOC做的就是这件事情,只是它封装的更好而已。
  • matlab map容器类型

    千次阅读 2021-01-18 17:16:25
    matlab map容器类型 map容器类型以及map类概述 map是将一个量映射到另一个量上,此是前面的量就是map的键(key),后面的量就是map的数据(value)。map的键和对应的数据都储存在map中。一个map条目包括唯一的键和...
  • map是STL的一个容器,和set一样,map也是一种关联式容器。它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据处理能力,由于这个特性,有助于我们处理一...
  • map容器插入元素

    千次阅读 2019-04-06 13:10:49
    //插入元素 //四种插入方法比较void display(){ map<int,string> m; pair<map<int,string>::iterator,bool> pair1 ,pair2,pair3; //1.方法 pair1 = m.insert(pair<int,string>(1,...
  • C++map容器,优势:查找

    2019-03-20 16:55:50
    #include<...map> #include<cstdlib> #include<ctime> #include<algorithm> using namespace std; const int n=100000; class Map//优势:排序 { private: map<int...
  • map容器的insert用法总结

    万次阅读 2018-01-25 20:02:07
    如果试图插入的元素所对应的键已经在容器中,则insert 将不做任何操作。 通常来说,下标操作符返回左值。它返回的左值是特定键所关联的值。 有别于vector或string类型,map下标操作符返回的类型与对map迭代器...
  • C++中的map容器.pdf

    2021-01-07 22:08:27
    C++中的map容器
  • C++ 中 map 容器的内存释放机制及内存碎片管理 C++ 中的容器很好用,比如 vector, map 等,可以动态扩容,自己管理内存,不用用户关心,但是在某些极端情况下,如果内存比较紧张的情况下,可能用户对于这些容器自己...
  • Map容器的使用

    千次阅读 2016-09-17 10:49:00
    这里主要介绍map容器的使用,map通过键值对key-value的形式集合。 根据key值快速查找记录,查找的复杂度基本是Log(N),如果有1000个记录,最多查找10次,1,000,000个记录,最多查找20次。 快速插入Key -Value 记录...
  • map容器的详细用法

    万次阅读 2016-10-06 17:28:00
    map是STL的一个关联容器,它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据处理能力,由于这个特性,它完成有可能在我们处理一对一数据的时候,在编程...
  • c++中map容器的使用

    千次阅读 2018-03-02 13:21:02
    C++中map容器提供一个键值对容器,map与multimap差别仅仅在于multiple允许一个键对应多个值。 一、map的说明 1头文件 #include<map> 2定义 map<string,int>my_Map; 或者是typedefmap<string,int>...
  • map容器会自动根据key的值进行排序,要想要map容器中的内容根据value中的值进行排序 可先把map中的内容拷贝到vector容器中,然后再用sort排序 PointCloud.h typedef struct PitArea { int PointNum; float height;...
  • C++ STL之map容器用法详解 map 容器是关联容器的一种。在关联容器中,对象的位置取决于和它关联的键的值。键可以是基本类型,也可以是类类型。字符串经常被用来作为键,如果想要保存姓名和地址的记录,就可以这么...
  • C++:map容器的插入方法比较

    千次阅读 2019-05-11 09:51:08
      在C++的STL中引入了容器的概念,常见的...这篇blog比较map容器常见的两种插入方法,如下: 方法一:利用insert命令。 for(i = 0; i<nums.size();i++){ a.insert(map<int,int>::value_type(nums[i...
  • map容器的遍历

    2016-11-02 15:57:21
    在用列表时用到了map容器,,他的遍历是这样的: for(auto allianceInfo:map){ (中间赋值用:auto name=map.second.szName) }
  • map容器讲解

    2012-01-05 16:35:28
    Map是STL的一个关联容器,它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据处理能力,由于这个特性,它完成有可能在我们处理一对一数据的时候,在编程...
  • ts Map容器的使用

    千次阅读 2020-04-01 16:10:48
    interface Map<K, V> { //清空 clear(): void; //删除:通过key来删除value delete(key: K): boolean; //遍历 forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): ...
  • 使用 insert() 向 map 容器中插入键值对的过程是,先创建该键值对,然后再将该键值对复制或者移动到 map 容器中的指定位置; 使用 emplace() 或 emplace_hint() 插入键值对的过程是,直接在 map 容器中的指定位置...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 329,503
精华内容 131,801
关键字:

map容器