C++map用法

最新推荐文章于 2025-06-19 19:06:33 发布
最新推荐文章于 2025-06-19 19:06:33 发布
阅读量949 收藏
点赞数
分类专栏： C++基础知识 文章标签： STL
本文主要介绍了C++中map容器的相关操作。map是一种键值对容器，数据成对出现。内容涵盖声明、插入操作（使用[ ]和insert）、取值（at和[ ]）、容量查询、迭代器、删除交换、顺序比较、查找以及操作符等方面，还给出了部分操作的具体示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一 声明 二 插入操作 三 取值 四 容量查询 五 迭代器 六 删除交换 七 顺序比较 八 查找 九 操作符

C++中map提供的是一种键值对容器，里面的数据都是成对出现的,如下图：每一对中的第一个值称之为关键字(key)，每个关键字只能在map中出现一次；第二个称之为该关键字的对应值。

https://i-blog.csdnimg.cn/blog_migrate/1a5b450822228c6a59eb8bb3450eea2d.png

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

一. 声明


   
  1. 
     
    
      
    
     
    
     
    
      
    
       //头文件
      
    
     
  2. 
     
    
      
    
     
    
     
    
      
    
       #include<map>
      
    
     
  3. 
     
    
      
    
     
    
     
    
      
     
      
    
     
  4. 
     
    
      
    
     
    
     
    
      
    
       map<int, string> ID_Name;
      
    
     
  5. 
     
    
      
    
     
    
     
    
      
     
      
    
     
  6. 
     
    
      
    
     
    
     
    
      
    
       // 使用{}赋值是从c++11开始的，因此编译器版本过低时会报错，如visual studio 2012
      
    
     
  7. 
     
    
      
    
     
    
     
    
      
    
       map<int, string> ID_Name = {
      
    
     
  8. 
     
    
      
    
     
    
     
    
      
    
                       { 
       2015, 
       "Jim" },
      
    
     
  9. 
     
    
      
    
     
    
     
    
      
    
                       { 
       2016, 
       "Tom" },
      
    
     
  10. 
     
    
      
    
     
    
     
    
      
    
                       { 
       2017, 
       "Bob" } };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

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

二. 插入操作

2.1 使用[ ]进行单个插入

   
  1. 
     
    
      
    
     
    
     
    
      
    
       map<int, string> ID_Name;
      
    
     
  2. 
     
    
      
    
     
    
     
    
      
     
      
    
     
  3. 
     
    
      
    
     
    
     
    
      
    
       // 如果已经存在键值2015，则会作赋值修改操作，如果没有则插入
      
    
     
  4. 
     
    
      
    
     
    
     
    
      
    
       ID_Name[
       2015] = 
       "Tom";
  • 1
  • 2
  • 3
  • 4
2.1 使用insert进行单个和多个插入

insert共有4个重载函数：


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

下面是具体使用示例：


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


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

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

四. 容量查询


   
  1. 
     
    
      
    
     
    
     
    
      
    
       // 查询map是否为空
      
    
     
  2. 
     
    
      
    
     
    
     
    
      
    
       bool 
       empty();
      
    
     
  3. 
     
    
      
    
     
    
     
    
      
     
      
    
     
  4. 
     
    
      
    
     
    
     
    
      
    
       // 查询map中键值对的数量
      
    
     
  5. 
     
    
      
    
     
    
     
    
      
    
       size_t 
       size();
      
    
     
  6. 
     
    
      
    
     
    
     
    
      
     
      
    
     
  7. 
     
    
      
    
     
    
     
    
      
    
       // 查询map所能包含的最大键值对数量，和系统和应用库有关。
      
    
     
  8. 
     
    
      
    
     
    
     
    
      
    
       // 此外，这并不意味着用户一定可以存这么多，很可能还没达到就已经开辟内存失败了
      
    
     
  9. 
     
    
      
    
     
    
     
    
      
    
       size_t 
       max_size();
      
    
     
  10. 
     
    
      
    
     
    
     
    
      
     
      
    
     
  11. 
     
    
      
    
     
    
     
    
      
    
       // 查询关键字为key的元素的个数，在map里结果非0即1
      
    
     
  12. 
     
    
      
    
     
    
     
    
      
    
       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情况下，不允许对值进行修改。如下面代码所示：


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

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

这里写图片描述

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

六. 删除交换

6.1 删除

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

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

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

七. 顺序比较


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

示例：


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

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

八. 查找


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

举例：


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

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

九. 操作符

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

C++ map用法
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-22 550
C++ map用法 map是C++中的一个标准容器，她提供了很好一对一的关系，在一些程序中建立一个map可以起到事半功倍的效果，本文为大家总结了map的一些基本简单的操作! 1、map最基本的构造函数; map<string , int >mapstring; map<int ,string >mapint; map<sring, char>mapstring;...
C++之map
专注
03-02 2307
map是C++ STL的一个关联容器，它提供一对一的数据处理能力。其中，各个键值对的键和值可以是任意数据类型，包括 C++ 基本数据类型（int、double 等）、使用结构体或类自定义的类型。第一个可以称为关键字(key)；第二个可能称为该关键字的值(value)；使用 map 容器存储的各个键值对，键的值既不能重复也不能被修改。换句话说，map 容器中存储的各个键值对不仅键的值独一无二，键的类型也会用 const 修饰，这意味着只要键值对被存储到 map 容器中，其键的值将不能再做任何修改。
c++map的用法
flqbestboy的专栏
11-14 6万+
最全的c++map的用法 此文是复制来的0.0 1. map最基本的构造函数； mapmapstring; mapmapint; mapmapstring; mapmapchar; mapmapchar; mapmapint； 2. map添加数据； mapmaplive; 1. maplive.insert(pair(102,"aclive")); 2. maplive
c++map的使用
最新发布
2401_88413914的博客
06-19 1963
C++ 标准库中的 map 容器是一种基于红黑树实现的关联容器，具有自动排序、键值唯一和高效操作特性。本文详细介绍了 map 的基本使用方法，包括声明初始化、元素插入（insert/emplace/operator[]）、安全访问（find/at/count）、删除修改、遍历迭代等核心操作，并探讨了自定义排序规则、容器合并等高级特性。通过时间复杂度分析对比了 map 和 unordered_map 的适用场景，最后总结 map 作为稳定高效的关联容器在 C++ 开发中的重要性。
C++ Map常见用法说明
热门推荐
shuzfan的专栏
11-10 28万+
C++中map提供的是一种键值对容器，里面的数据都是成对出现的,如下图：每一对中的第一个值称之为关键字(key)，每个关键字只能在map中出现一次；第二个称之为该关键字的对应值。一. 声明//头文件 #include<map>map<int, string> ID_Name;// 使用{}赋值是从c++11开始的，因此编译器版本过低时会报错，如visual studio 2012 map<int,
C++中的map
SmileLing的专栏
04-28 3万+
文章目录1. 简介2. pair类型2.1 pair类型的定义和初始化2.2 pair对象的一些操作3. map基本操作3.1 头文件3.2 创建map对象3.3 map元素访问3.3.1 使用下标 [ ] 访问3.3.2 使用 at() 方法访问3.4 map中元素的插入3.4.1 使用下标[]插入3.4.2 使用insert()插入元素3.4 erase() 删除元素3.5 count(k) ...
STL Map的使用
weixin_30617695的博客
08-16 888
STL map常用操作简介 1。目录 1. map简介 2. map的功能 3. 使用map 4. 在map中插入元素 5. 查找并获取map中的元素 6. 从map中删除元素 2。map简介 map是一类关联式容器。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节点都没有什么影响。对于迭代器来说，可...
C++ map用法总结（整理）
09-04
在本文中，我们将深入探讨`map`的基本概念、特性、操作以及实际应用，帮助你全面掌握C++ `map`的用法。 ### 1. `map`的定义与类型 `map`是C++标准库中`<map>`头文件的一部分，它是一个红黑树（Red-Black Tree）...
第三十八章 C++ map用法
2401_89610374的博客
01-09 984
第三十八章 C++ map用法
c++ map 用法总结
JIAN_ZANG1125的博客
09-29 293
1，map简介 map是STL的一个关联容器，它提供一对一的hash。 第一个可以称为关键字(key)，每个关键字只能在map中出现一次； 第二个可能称为该关键字的值(value)； map以模板(泛型)方式实现，可以存储任意类型的数据，包括使用者自定义的数据类型。Map主要用于资料一对一映射(one-to-one)的情況，map內部的实现自建一颗红黑树，这颗树具有对数据自动排序的功能。在map内部所有的数据都是有序的，后边我们会见识到有序的好处。比如一个班级中，每个学生的学号跟他的姓名就存在著一对一
c++ 中 map 的用法
XFDG01的博客
04-08 5769
通过键自动排序，并提供快速检索能力。它主要用于快速查找、插入和删除键值对。是一个关联容器，它存储键值对，其中每个键唯一，并且每个键映射到一个值。下面讲讲 .find() 和.count()函数。遍历输出map中的值，也有两种方法。这里我们先介绍迭代器的定义。然后适用于迭代器的遍历。也有一种更方便的方法。
Map (c++实现的简易map)
03-16
vs2013 自己实现的一个简易Map(c++)。
C++中map的使用
漆灿
08-03 1133
目录 1. 简单的map 2. hash_map、unorder_map 3. （通过key找value）和（通过value找key） 1. 简单的map https://www.cnblogs.com/omelet/p/6617362.html https://blog.youkuaiyun.com/wangjingqi930330/article/details/81938998 ...
C++ map的基本操作和使用
jfkidear的专栏
03-19 1165
C++ map的基本操作和使用  (2009-09-23 14:58:21) 标签：  c   map   编程   基本操作   live   hai   it 分类： Pro.Languages    Map是c++的一个标准容器，她提供了很好一对一的关系，在一些程序中建立一个ma
map常见操作
qq_41035681的博客
08-23 1426
1，map简介 map是STL的一个关联容器，它提供一对一的hash。 第一个可以称为关键字(key)，每个关键字只能在map中出现一次； 第二个可能称为该关键字的值(value)； map以模板(泛型)方式实现，可以存储任意类型的数据，包括使用者自定义的数据类型。Map主要用于资料一对一映射(one-to-one)的情況，map內部的实现自建一颗红黑树，这颗树具有对数据自动排序的功能。在...
c++ map用法
老猫的博客
02-20 513
Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据 处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树(一 种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，后边我们会见识...
C++学习之map类型
xywlpo的专栏
06-15 1万+
1。目录 map简介 map的功能 map的定义 在map中添加元素 查找并获取map中的元素 从map中删除元素map对象的迭代遍历 2。map简介 map是一类关联式容器，它是模板类。关联的本质在于元素的值与某个特定的键相关联，而并非通过元素在数组中的位置类获取。它的特点是增加和删除节点对迭代器的影响很小，除了操作节点，对其他的节点都没有什么影响。对
map的使用方法
xuetao0214的专栏
03-03 552
Map是c++的一个标准容器，它提供了很好一对一的关系，在一些程序中建立一个map可以起到事半功倍的效果，总结了一些map基本简单实用的操作！ 1. map构造函数； mapmapstring; mapmapint; mapmapstring; mapmapchar; mapmapchar; mapmapint; 2. map添加数据； map maplive;  1.maplive
C语言map用法
05-22
### C语言中 Map 数据结构的使用方法 尽管C语言本身并没有像其他高级编程语言（如C++中的`std::map`或Python中的字典）那样提供内置的映射（Map）数据结构，但通过组合使用结构体、数组以及哈希表等方式可以实现类似的映射功能。 #### 定义 Map 结构 为了模拟一个简单的 `key-value` 映射关系，通常定义一个结构体来存储键值对。例如： ```c #define KEY_MAX_LENGTH 50 typedef struct { char key[KEY_MAX_LENGTH]; int value; } KeyValue; KeyValue map[100]; // 假设最多支持100个键值对 int mapSize = 0; // 当前已存入的键值对数量 ``` 此代码片段展示了如何创建一个固定大小的数组用于保存键值对[^1]。 #### 插入操作 向自定义的 Map 中插入新的键值对时，需注意重复键的情况处理逻辑。以下是插入新键值对的一个简单例子： ```c #include <string.h> void insertIntoMap(char *key, int value) { for (int i = 0; i < mapSize; ++i) { if (strcmp(map[i].key, key) == 0) { // 如果找到相同的键则更新其对应的值 map[i].value = value; return; } } strcpy(map[mapSize].key, key); map[mapSize].value = value; mapSize++; } ``` 这段程序实现了当给定键已经存在于当前集合里时就替换旧值；否则新增加一对记录到列表末端的功能[^2]。 #### 查找操作 对于查找特定键关联的数值而言，可以通过线性扫描整个数组完成这一任务: ```c int* findInMap(const char* key){ for(int i=0;i<mapSize;++i){ if(strcmp(map[i].key,key)==0){ return &(map[i].value); } } return NULL;//如果没有匹配项返回null指针表示未查找到任何东西。 } ``` 上述函数接受一个字符型参数作为输入并尝试定位它在内部储存器的位置，成功的话即反馈相应位置处整数变量地址，失败则给出空指针信号表明不存在这样的条目[^3]。 #### 遍历所有元素 要打印或者进一步处理所有的键值配对情况，可采用如下方式逐一访问它们： ```c void iterateThroughMap(){ for(int idx=0;idx!=mapSize;++idx){ printf("Key:%s Value:%d\n",map[idx].key,map[idx].value); } } ``` 这个过程利用循环语句依次读取每一个成员的信息直至结束标志为止[^4]。 ### 性能考量与优化建议 虽然以上介绍的方法易于理解和实施，但在实际应用当中可能存在效率低下等问题特别是随着规模增大之后表现尤为明显因此有必要考虑引入更高效的数据组织形式比如散列(hash table)等技术手段加以改进从而减少不必要的计算消耗提升整体运行速度降低资源占用率等等优点[^5]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值