zoukankan      html  css  js  c++  java
  • C++中的map用法学习

    map是STL的一个关联容器,它提供一对一的hash。

    • 第一个可以称为关键字(key),每个关键字只能在map中出现一次;
    • 第二个可能称为该关键字的值(value);


    map以模板(泛型)方式实现,可以存储任意类型的数据,包括使用者自定义的数据类型。Map主要用于资料一对一映射(one-to-one)的情況,map內部的实现自建一颗红黑树,这颗树具有对数据自动排序的功能。在map内部所有的数据都是有序的,后边我们会见识到有序的好处。比如一个班级中,每个学生的学号跟他的姓名就存在著一对一映射的关系。

    2,map的功能

    自动建立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个构造函数,这块涉及到内存分配器这些东西,略过不表,在下面我们将接触到一些map的构造方法,这里要说下的就是,我们通常用如下方法构造一个map:

    map<int, string> mapStudent;

     map<string , int >mapstring;        map<int ,string >mapint;
       map<sring, char>mapstring;        map< char ,string>mapchar;
       map<char ,int>mapchar;           map<int ,char >mapint;

    5,插入元素

    // 定义一个map对象
    map<int, string> mapStudent;
     
    // 第一种 用insert函數插入pair
    mapStudent.insert(pair<int, string>(000, "student_zero"));
     
    // 第二种 用insert函数插入value_type数据
    mapStudent.insert(map<int, string>::value_type(001, "student_one"));
     
    // 第三种 用"array"方式插入
    mapStudent[123] = "student_first";
    mapStudent[456] = "student_second";
    以上三种用法,虽然都可以实现数据的插入,但是它们是有区别的,当然了第一种和第二种在效果上是完成一样的,用insert函数插入数据,在数据的 插入上涉及到集合的唯一性这个概念,即当map中有这个关键字时,insert操作是不能在插入数据的,但是用数组方式就不同了,它可以覆盖以前该关键字对 应的值,用程序说明如下:

    mapStudent.insert(map<int, string>::value_type (001, "student_one"));
     
    mapStudent.insert(map<int, string>::value_type (001, "student_two"));
    上面这两条语句执行后,map中001这个关键字对应的值是“student_one”,第二条语句并没有生效,那么这就涉及到我们怎么知道insert语句是否插入成功的问题了,可以用pair来获得是否插入成功,程序如下

    // 构造定义,返回一个pair对象
    pair<iterator,bool> insert (const value_type& val);
     
    pair<map<int, string>::iterator, bool> Insert_Pair;
     
    Insert_Pair = mapStudent.insert(map<int, string>::value_type (001, "student_one"));
     
    if(!Insert_Pair.second)
        cout << ""Error insert new element" << endl;
    我们通过pair的第二个变量来知道是否插入成功,它的第一个变量返回的是一个map的迭代器,如果插入成功的话Insert_Pair.second应该是true的,否则为false。

    6, 查找元素

    当所查找的关键key出现时,它返回数据所在对象的位置,如果沒有,返回iter与end函数的值相同。

    // find 返回迭代器指向当前查找元素的位置否则返回map::end()位置
    iter = mapStudent.find("123");
     
    if(iter != mapStudent.end())
           cout<<"Find, the value is"<<iter->second<<endl;
    else
       cout<<"Do not Find"<<endl;
    7, 刪除与清空元素

    //迭代器刪除
    iter = mapStudent.find("123");
    mapStudent.erase(iter);
     
    //用关键字刪除
    int n = mapStudent.erase("123"); //如果刪除了會返回1,否則返回0
     
    //用迭代器范围刪除 : 把整个map清空
    mapStudent.erase(mapStudent.begin(), mapStudent.end());
    //等同于mapStudent.clear()
    8,map的大小

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

    int nSize = mapStudent.size();
     

     9,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的函数

    二. 插入操作

    2.1 使用[ ]进行单个插入

    map<int, string> ID_Name;

    // 如果已经存在键值2015,则会作赋值修改操作,如果没有则插入

    ID_Name[2015] = "Tom";

    2.1 使用insert进行单个和多个插入

    insert共有4个重载函数:

    // 插入单个键值对,并返回插入位置和成功标志,插入位置已经存在值时,插入失败

    pair<iterator,bool> insert (const value_type& val);

    //在指定位置插入,在不同位置插入效率是不一样的,因为涉及到重排

    iterator insert (const_iterator position, const value_type& val);

    // 插入多个

    void insert (InputIterator first, InputIterator last);

    //c++11开始支持,使用列表插入多个   

    void insert (initializer_list<value_type> il);

    下面是具体使用示例:

    #include <iostream>

    #include <map>

    int main()

    {

        std::map<char, int> mymap;

        // 插入单个值

        mymap.insert(std::pair<char, int>('a', 100));

        mymap.insert(std::pair<char, int>('z', 200));

        //返回插入位置以及是否插入成功

        std::pair<std::map<char, int>::iterator, bool> ret;

        ret = mymap.insert(std::pair<char, int>('z', 500));

        if (ret.second == false) {

            std::cout << "element 'z' already existed";

            std::cout << " with a value of " << ret.first->second << ' ';

        }

        //指定位置插入

        std::map<char, int>::iterator it = mymap.begin();

        mymap.insert(it, std::pair<char, int>('b', 300));  //效率更高

        mymap.insert(it, std::pair<char, int>('c', 400));  //效率非最高

        //范围多值插入

        std::map<char, int> anothermap;

        anothermap.insert(mymap.begin(), mymap.find('c'));

        // 列表形式插入

        anothermap.insert({ { 'd', 100 }, {'e', 200} });

        return 0;

    }

    三. 取值

    Map中元素取值主要有at和[ ]两种操作,at会作下标检查,而[]不会。

    map<int, string> ID_Name;

    //ID_Name中没有关键字2016,使用[]取值会导致插入

    //因此,下面语句不会报错,但打印结果为空

    cout<<ID_Name[2016].c_str()<<endl;

    //使用at会进行关键字检查,因此下面语句会报错

    ID_Name.at(2016) = "Bob";

    四. 容量查询

    // 查询map是否为空

    bool empty();

    // 查询map中键值对的数量

    size_t size();

    // 查询map所能包含的最大键值对数量,和系统和应用库有关。

    // 此外,这并不意味着用户一定可以存这么多,很可能还没达到就已经开辟内存失败了

    size_t max_size();

    // 查询关键字为key的元素的个数,在map里结果非0即1

    size_t count( const Key& key ) const; //

    ——————————————————————————————————————————————

    五. 迭代器

    共有八个获取迭代器的函数:* begin, end, rbegin,rend* 以及对应的 * cbegin, cend, crbegin,crend*。

    二者的区别在于,后者一定返回 const_iterator,而前者则根据map的类型返回iterator 或者 const_iterator。const情况下,不允许对值进行修改。如下面代码所示:

    map<int,int>::iterator it;

    map<int,int> mmap;

    const map<int,int> const_mmap;

    it = mmap.begin(); //iterator

    mmap.cbegin(); //const_iterator

    const_mmap.begin(); //const_iterator

    const_mmap.cbegin(); //const_iterator

    返回的迭代器可以进行加减操作,此外,如果map为空,则 begin = end。

    六. 删除交换

    6.1 删除

    // 删除迭代器指向位置的键值对,并返回一个指向下一元素的迭代器

    iterator erase( iterator pos )

    // 删除一定范围内的元素,并返回一个指向下一元素的迭代器

    iterator erase( const_iterator first, const_iterator last );

    // 根据Key来进行删除, 返回删除的元素数量,在map里结果非0即1

    size_t erase( const key_type& key );

    // 清空map,清空后的size为0

    void clear();

    6.2 交换

    // 就是两个map的内容互换

    void swap( map& other );

     Map中的swap不是一个容器中的元素交换,而是两个容器交换;———————

    6.map的sort问题:
      Map中的元素是自动按key升序排序,所以不能对map用sort函数

    七. 顺序比较

    // 比较两个关键字在map中位置的先后

    key_compare key_comp() const;

    示例:

    map<char,int> mymap;

    map<char,int>::key_compare mycomp = mymap.key_comp();

    mymap['a']=100;

    mymap['b']=200;

    mycomp('a', 'b');  // a排在b前面,因此返回结果为true

    ——————————————————————————————————————————————

    八. 查找

    // 关键字查询,找到则返回指向该关键字的迭代器,否则返回指向end的迭代器

    // 根据map的类型,返回的迭代器为 iterator 或者 const_iterator

    iterator find (const key_type& k);

    const_iterator find (const key_type& k) const;

    举例:

    std::map<char,int> mymap;

    std::map<char,int>::iterator it;

    mymap['a']=50;

    mymap['b']=100;

    mymap['c']=150;

    mymap['d']=200;

    it = mymap.find('b');

    if (it != mymap.end())

        mymap.erase (it); // b被成功删除

    ——————————————————————————————————————————————

    九. 操作符

    operator: == != < <= > >=

    注意 对于==运算符, 只有键值对以及顺序完全相等才算成立。

    http://blog.sina.com.cn/s/blog_61533c9b0100fa7w.html

    https://www.cnblogs.com/yonglin1998/p/11780828.html

    二. 插入操作

    2.1 使用[ ]进行单个插入

    map<int, string> ID_Name;
    
    // 如果已经存在键值2015,则会作赋值修改操作,如果没有则插入
    ID_Name[2015] = "Tom";
    • 1
    • 2
    • 3
    • 4

    2.1 使用insert进行单个和多个插入

    insert共有4个重载函数:

    // 插入单个键值对,并返回插入位置和成功标志,插入位置已经存在值时,插入失败
    pair<iterator,bool> insert (const value_type& val);
    
    //在指定位置插入,在不同位置插入效率是不一样的,因为涉及到重排
    iterator insert (const_iterator position, const value_type& val);
    
    // 插入多个
    void insert (InputIterator first, InputIterator last);
    
    //c++11开始支持,使用列表插入多个   
    void insert (initializer_list<value_type> il);
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    下面是具体使用示例:

    #include <iostream>
    #include <map>
    
    int main()
    {
        std::map<char, int> mymap;
    
        // 插入单个值
        mymap.insert(std::pair<char, int>('a', 100));
        mymap.insert(std::pair<char, int>('z', 200));
    
        //返回插入位置以及是否插入成功
        std::pair<std::map<char, int>::iterator, bool> ret;
        ret = mymap.insert(std::pair<char, int>('z', 500));
        if (ret.second == false) {
            std::cout << "element 'z' already existed";
            std::cout << " with a value of " << ret.first->second << '
    ';
        }
    
        //指定位置插入
        std::map<char, int>::iterator it = mymap.begin();
        mymap.insert(it, std::pair<char, int>('b', 300));  //效率更高
        mymap.insert(it, std::pair<char, int>('c', 400));  //效率非最高
    
        //范围多值插入
        std::map<char, int> anothermap;
        anothermap.insert(mymap.begin(), mymap.find('c'));
    
        // 列表形式插入
        anothermap.insert({ { 'd', 100 }, {'e', 200} });
    
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    ——————————————————————————————————————————————

    三. 取值

    Map中元素取值主要有at和[ ]两种操作,at会作下标检查,而[]不会。

    map<int, string> ID_Name;
    
    //ID_Name中没有关键字2016,使用[]取值会导致插入
    //因此,下面语句不会报错,但打印结果为空
    cout<<ID_Name[2016].c_str()<<endl;
    
    //使用at会进行关键字检查,因此下面语句会报错
    ID_Name.at(2016) = "Bob";
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    ——————————————————————————————————————————————

    四. 容量查询

    // 查询map是否为空
    bool empty();
    
    // 查询map中键值对的数量
    size_t size();
    
    // 查询map所能包含的最大键值对数量,和系统和应用库有关。
    // 此外,这并不意味着用户一定可以存这么多,很可能还没达到就已经开辟内存失败了
    size_t max_size();
    
    // 查询关键字为key的元素的个数,在map里结果非0即1
    size_t count( const Key& key ) const; //
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    ——————————————————————————————————————————————

    五. 迭代器

    共有八个获取迭代器的函数:* begin, end, rbegin,rend* 以及对应的 * cbegin, cend, crbegin,crend*

    二者的区别在于,后者一定返回 const_iterator,而前者则根据map的类型返回iterator 或者 const_iterator。const情况下,不允许对值进行修改。如下面代码所示:

    map<int,int>::iterator it;
    map<int,int> mmap;
    const map<int,int> const_mmap;
    
    it = mmap.begin(); //iterator
    mmap.cbegin(); //const_iterator
    
    const_mmap.begin(); //const_iterator
    const_mmap.cbegin(); //const_iterator
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    返回的迭代器可以进行加减操作,此外,如果map为空,则 begin = end。

    这里写图片描述

    ——————————————————————————————————————————————

    六. 删除交换

    6.1 删除

    
    // 删除迭代器指向位置的键值对,并返回一个指向下一元素的迭代器
    iterator erase( iterator pos )
    
    // 删除一定范围内的元素,并返回一个指向下一元素的迭代器
    iterator erase( const_iterator first, const_iterator last );
    
    // 根据Key来进行删除, 返回删除的元素数量,在map里结果非0即1
    size_t erase( const key_type& key );
    
    // 清空map,清空后的size为0
    void clear();
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    6.2 交换

    // 就是两个map的内容互换
    void swap( map& other );
    • 1
    • 2

    ——————————————————————————————————————————————

    七. 顺序比较

    // 比较两个关键字在map中位置的先后
    key_compare key_comp() const;
    • 1
    • 2

    示例:

    map<char,int> mymap;
    map<char,int>::key_compare mycomp = mymap.key_comp();
    
    mymap['a']=100;
    mymap['b']=200;
    mycomp('a', 'b');  // a排在b前面,因此返回结果为true
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    ——————————————————————————————————————————————

    八. 查找

    // 关键字查询,找到则返回指向该关键字的迭代器,否则返回指向end的迭代器
    // 根据map的类型,返回的迭代器为 iterator 或者 const_iterator
    iterator find (const key_type& k);
    const_iterator find (const key_type& k) const;
    • 1
    • 2
    • 3
    • 4

    举例:

    std::map<char,int> mymap;
    std::map<char,int>::iterator it;
    
    mymap['a']=50;
    mymap['b']=100;
    mymap['c']=150;
    mymap['d']=200;
    
    it = mymap.find('b');
    if (it != mymap.end())
        mymap.erase (it); // b被成功删除
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    ——————————————————————————————————————————————

    九. 操作符

    operator: == != < <= > >=
    注意 对于==运算符, 只有键值对以及顺序完全相等才算成立。

  • 相关阅读:
    Java jni字符串转换
    Python读取PE文件(exe/dll)中的时间戳
    深度学习word embedding猜测性别初探
    闪存内容汇编(截止20170405)
    如何自动化安装字体(命令行批量)
    如何分析进程的内存占用问题
    Python print报ascii编码异常的靠谱解决办法
    Linux界面自动化测试框架不完全汇总
    Qt实现同步(阻塞式)http get等网络访问操作
    基于第三方开源库的OPC服务器开发指南(4)——后记:与另一个开源库opc workshop库相关的问题
  • 原文地址:https://www.cnblogs.com/klb561/p/13831382.html
Copyright © 2011-2022 走看看