std::map

已于 2022-11-24 15:00:25 修改
阅读量1.2k 收藏
点赞数
分类专栏： C/C++ 文章标签： c++
于 2022-11-24 12:16:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TimerSea/article/details/128015899
版权
本文详细介绍了C++标准库中的std::map容器，包括其成员函数如构造、访问、迭代器、容量修改、查找等操作，并通过示例代码展示其用法。std::map是一个有序键值对容器，使用红黑树实现，键是唯一的。文章还涵盖了非成员函数，如比较操作和容器操作。
摘要由CSDN通过智能技术生成

std::map

介绍

成员函数

非成员函数

介绍

// map 模板定义
template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>> class map;	
namespace pmr {
    template< class Key, class T, class Compare = std::less<Key> >
    using map = std::map<Key, T, Compare, std::pmr::polymorphic_allocator<std::pair<const Key, T>>>
}
  • std::map 介绍摘选自 cppreference.com 中文网 std::map 介绍
  • std::map 是有序键值对容器，它的元素的键是唯一的
  • 用比较函数 Compare 排序键、搜索、移除和插入操作拥有对数复杂度
  • map 通常实现为红黑树
  • 标准库使用比较 (Compare) 概念时用等价关系确定唯一性
  • 不精确地说，如果两个对象 a 与 b 相互不比较小于对方：!comp(a, b) && !comp(b, a)，那么认为它们等价

成员函数

构造析构
#include <QCoreApplication>
#include <algorithm>
#include <iostream>
#include <map>
#include <string>

auto Print(const std::string &msg, const std::map<int, int> &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " - " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using map_int = std::map<int, int>;
  map_int m1; //默认构造
  Print("m1", m1);

  std::allocator<std::pair<int, int>> alloc;
  std::less<int> cmp;
  map_int m2(cmp, alloc); //设置比较器和分配器
  Print("m2", m2);

  map_int m3(alloc); //设置分配器
  Print("m3", m3);

  map_int m4{{2, 2}, {3, 3}, {4, 4}};
  Print("m4", m4);
  map_int m5(m4.begin(), m4.end()); //迭代器初始化
  Print("m5", m5);

  map_int m6(m5); //拷贝构造初始化
  Print("m6", m6);

  map_int m7(std::move(m6)); //移动构造初始化
  Print("m7", m7);

  map_int m8{{2, 2}, {3, 3}, {4, 4}}; //初始化列表
  Print("m8", m8);

  //析构函数默认
  return 0; // a.exec();
}

输出结果：
m1 :
m2 :
m3 :
m4 : 2 - 2 3 - 3 4 - 4
m5 : 2 - 2 3 - 3 4 - 4
m6 : 2 - 2 3 - 3 4 - 4
m7 : 2 - 2 3 - 3 4 - 4
m8 : 2 - 2 3 - 3 4 - 4

元素访问
auto Print(const std::string &msg, const std::map<int, int> &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " - " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using map_int = std::map<int, int>;
  map_int m1{{100, 10}, {200, 20}, {300, 30}, {400, 40}, {500, 50}};
  Print("m1", m1);

  std::cout << "m1.at(100) : " << m1.at(100) << std::endl;
  std::cout << "m1.at(300) : " << m1.at(300) << std::endl;
  std::cout << "m1.at(500) : " << m1.at(500) << std::endl;

  std::cout << "m1[100] : " << m1[100] << std::endl;
  std::cout << "m1[300] : " << m1[300] << std::endl;
  std::cout << "m1[500] : " << m1[500] << std::endl;

  return 0; // a.exec();
}

输出结果：
m1 : 100 - 10 200 - 20 300 - 30 400 - 40 500 - 50
m1.at(100) : 10
m1.at(300) : 30
m1.at(500) : 50
m1[100] : 10
m1[300] : 30
m1[500] : 50

迭代器
auto Print(const std::string &msg, const std::map<int, int> &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " - " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using map_int = std::map<int, int>;
  map_int m1{{100, 10}, {200, 20}, {300, 30}, {400, 40}, {500, 50}};
  Print("m1", m1);

  map_int::iterator iter = m1.begin();
  std::cout << "m1 : ";
  for (; iter != m1.end(); ++iter) {
    std::cout << iter->first << " - " << iter->second << "\t";
  }
  std::cout << "\n";

  map_int::const_iterator citer = m1.begin(); //返回指向起始的迭代器
  std::cout << "m1 : ";
  for (; citer != m1.end(); ++citer) {
    std::cout << citer->first << " - " << citer->second << "\t";
  }
  std::cout << "\n";

  map_int::reverse_iterator rbiter = m1.rbegin(); //返回指向起始的逆向迭代器
  std::cout << "m1 : ";
  for (; rbiter != m1.rend(); ++rbiter) {
    std::cout << rbiter->first << " - " << rbiter->second << "\t";
  }
  std::cout << "\n";

  map_int::const_reverse_iterator crbiter = m1.crbegin(); //返回指向起始的迭代器
  std::cout << "m1 : ";
  for (; crbiter != m1.crend(); ++crbiter) {
    std::cout << crbiter->first << " - " << crbiter->second << "\t";
  }
  std::cout << "\n";

  return 0; // a.exec();
}

输出结果：
m1 : 100 - 10 200 - 20 300 - 30 400 - 40 500 - 50
m1 : 100 - 10 200 - 20 300 - 30 400 - 40 500 - 50
m1 : 100 - 10 200 - 20 300 - 30 400 - 40 500 - 50
m1 : 500 - 50 400 - 40 300 - 30 200 - 20 100 - 10
m1 : 500 - 50 400 - 40 300 - 30 200 - 20 100 - 10

容量
auto Print(const std::string &msg, const std::map<int, int> &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " - " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using map_int = std::map<int, int>;
  map_int m1{{100, 10}, {200, 20}, {300, 30}, {400, 40}, {500, 50}};
  Print("m1", m1);

  //检查容器是否为空
  std::cout << std::boolalpha << "m1.empty() : " << m1.empty() << std::endl;

  std::cout << "m1.size() : " << m1.size() << std::endl; //返回容纳的元素数
  std::cout << "m1.max_size() : " << m1.max_size()
            << std::endl; //返回可容纳的最大元素数，和平台有关

  return 0; // a.exec();
}

输出结果：
m1 : 100 - 10 200 - 20 300 - 30 400 - 40 500 - 50
m1.empty() : false
m1.size() : 5
m1.max_size() : 461168601842738790

修改器
auto Print(const std::string &msg, const std::map<int, int> &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " - " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using map_int = std::map<int, int>;
  map_int m1{{100, 10}, {200, 20}, {300, 30}, {400, 40}, {500, 50}};
  Print("m1", m1);

  m1.clear(); //  清除内容
  Print("m1", m1);
  m1.insert(std::pair<int, int>(1, 10)); //插入元素或结点
  m1.insert({2, 20});
  Print("m1", m1);
  m1.emplace(3, 30); //原位构造元素
  m1.emplace(4, 40);
  Print("m1", m1);

  m1.emplace_hint(m1.end(), 5, 50); //使用提示原位构造元素
  m1.emplace_hint(m1.end(), 6, 60);
  m1.emplace_hint(m1.end(), 7, 70);
  Print("m1", m1);
  m1.erase(m1.begin());
  Print("m1", m1);
  
  return 0; // a.exec();
}

输出结果：
m1 : 100 - 10 200 - 20 300 - 30 400 - 40 500 - 50
m1 :
m1 : 1 - 10 2 - 20
m1 : 1 - 10 2 - 20 3 - 30 4 - 40
m1 : 1 - 10 2 - 20 3 - 30 4 - 40 5 - 50 6 - 60 7 - 70
m1 : 2 - 20 3 - 30 4 - 40 5 - 50 6 - 60 7 - 70

查找
auto Print(const std::string &msg, const std::map<int, int> &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " - " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using map_int = std::map<int, int>;
  map_int m1{{100, 10}, {200, 20}, {300, 30}, {400, 40}, {500, 50}};
  Print("m1", m1);

  std::cout << "m1.count() : " << m1.count(300)
            << std::endl; //返回匹配特定键的元素数量
  auto it = m1.find(200); //寻找带有特定键的元素
  if (it == m1.end()) {
    std::cout << "m1.find(200) : m1.end()" << std::endl;
  } else {
    std::cout << "m1.find(200) : " << it->first << " - " << it->second
              << std::endl;
  }

  //返回容器中所有拥有给定关键的元素范围。范围以二个迭代器定义，一个指向首个不小于
  // key 的元素，另一个指向首个大于 key 的元素。首个迭代器可以换用 lower_bound()
  //获得，而第二迭代器可换用 upper_bound() 获得
  std::pair<map_int::iterator, map_int::iterator> pa =
      m1.equal_range(100); //返回匹配特定键的元素范围

  std::cout << pa.first->first << " - " << pa.first->second << std::endl;
  std::cout << pa.second->first << " - " << pa.second->second << std::endl;

  map_int::iterator lit =
      m1.lower_bound(300); //返回指向首个不小于给定键的元素的迭代器
  std::cout << "m1.lower_bound(300) : " << lit->first << " - " << lit->second
            << std::endl;

  lit = m1.upper_bound(100); //返回指向首个大于给定键的元素的迭代器
  std::cout << "m1.upper_bound(100) : " << lit->first << " - " << lit->second
            << std::endl;
  return 0; // a.exec();
}

输出结果：
m1 : 100 - 10 200 - 20 300 - 30 400 - 40 500 - 50
m1.count() : 1
m1.find(200) : 200 - 20
100 - 10
200 - 20
m1.lower_bound(300) : 300 - 30
m1.upper_bound(100) : 200 - 20

非成员函数

auto Print(const std::string &msg, const std::map<int, int> &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " - " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using map_int = std::map<int, int>;
  map_int m1{{100, 10}, {200, 20}, {300, 30}, {400, 40}, {500, 50}};
  map_int m2{{100, 1}, {200, 2}, {300, 3}, {400, 4}, {500, 5}};
  Print("m1", m1);
  Print("m2", m2);

  std::cout.setf(std::ios::boolalpha);
  std::cout << "m1 == m2 : " << (m1 == m2) << std::endl;
  std::cout << "m1 != m2 : " << (m1 != m2) << std::endl;
  std::cout << "m1 > m2 : " << (m1 > m2) << std::endl;
  std::cout << "m1 >= m2 : " << (m1 >= m2) << std::endl;
  std::cout << "m1 < m2 : " << (m1 < m2) << std::endl;
  std::cout << "m1 <= m2 : " << (m1 <= m2) << std::endl;
  std::cout.unsetf(std::ios::boolalpha);
  // c++20 废弃以上操作符重载，提供三路运算符 operator <=> ()

  std::swap(m1, m2);
  Print("m1", m1);
  Print("m2", m2);

  return 0; // a.exec();
}

输出结果：
m1 : 100 - 10 200 - 20 300 - 30 400 - 40 500 - 50
m2 : 100 - 1 200 - 2 300 - 3 400 - 4 500 - 5
m1 == m2 : false
m1 != m2 : true
m1 > m2 : true
m1 >= m2 : true
m1 < m2 : false
m1 <= m2 : false
m1 : 100 - 1 200 - 2 300 - 3 400 - 4 500 - 5
m2 : 100 - 10 200 - 20 300 - 30 400 - 40 500 - 50

起始

无夜_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++——std::Set
zy2317878的博客
01-05 2269
写在前面： 在写这篇博客之前吐个槽，其实也可不不用这么麻烦这么写博客。讲道理其实在书本上学这些知识应该挺快的。可以书上看一遍记个大概，然后做题的过程中，不断遇见各种小知识，这样分散的积累，然后一定规模后，就可以系统的整理。但是现在先花时间来做这件事，其实也可以，建立主体的框架，后面再慢慢细化丰富。也没必要想那么多，慢慢来。不管方法是什么，重要的是每天要做点事。那么这篇博客学习set容器。目前学习...
map std 浮点数索引_std::map 简介及其使用
weixin_42378973的博客
01-14 698
注：std::map C++11标准map概述template < class Key, //map::key_typeclass T, //map::mapped_typeclass Compare = less, ...
std::Set
weixin_30462049的博客
08-22 241
C++标准库：std_set作为一个有序集合 摘要：std::set作为标准库的一个关联容器，实现内部元素进行了排序，使用这特性可以对一组元素进行插入排序。std::set最初的设计是完成数学中“集合”的概念，它提供的接口也是如此。本文简单地介绍一下这一个标准库容器。 为了使用std::set，我只需要如下： #include<set> ...
深入解析C++标准库中的std::map容器
最新发布
m0_72877724的博客
06-30 459
红黑树是一种自平衡二叉搜索树，通过旋转和颜色标记的方式保持树的平衡，从而保证在最坏情况下基本操作（如插入、删除和查找）的时间复杂度为 O(logn)。在 C++ 标准库中是一个有序关联容器，通过键值对存储数据。，这些方法可以帮助在区间查询和范围操作中。除了基本的插入、删除和查找操作，还提供了一些有用的方法，如。
std::set用法
热门推荐
baund的专栏
04-20 6万+
std::set成员函数及简要使用方法函数 声明 说明insert pair insert(const value_type& x) iterator insert(iterator position, const value_type& x) 1、向集合中添加一个元素 2、在迭代器指向的位置上放置指定的元素count size_type count(const key_typ
​std::multimap
weixin_34355715的博客
12-02 514
2019独角兽企业重金招聘Python工程师标准>>> ...
MFC，C++,C语言 json转换成std::map源码,无需编译,无需关心引用位置，直接引用即可使用
09-09
std::map<std::string, std::string> mapData = json.parseJson(jsonString); // 现在可以访问mapData中的数据 std::cout << "Name: " << mapData["name"] << std::endl; std::cout << "Age: " << mapData["age...
线程安全的std :: map和无锁映射的速度
04-11
1. **线程安全的std::map**：在C++标准库中，std::map不是线程安全的，这意味着在并发环境下，不同线程同时对map进行读写操作可能导致未定义的行为。为了在多线程环境下使用std::map，开发者通常需要手动添加锁来...
离奇的std::map、std::set崩溃
weixin_40548441的博客
06-23 1548
离奇的std::map、std::set崩溃定位分析以及解决办法
c++中hash_table以及std::map应用案例
12-24
代码重点是hash_table，附加std::map与其做对比，实现的是一条sql语句：select c_nationkey, c_mktsegment, count(*), max(c_acctbal) from aaa_customer_1g group by c_nationkey, c_mktsegment order by c_...
STL学习笔记-- multimap
weixin_33946020的博客
04-08 628
multimap 多重映照容器 multimap 与 map 一样，都是使用红黑树对记录型的元素数据,按元素键值的比较关系，进行快速的插入、删除和检索操作，所不同的是 multimap 允许将具有重复键值的元素插入容器。在 multimap 容器中，元素的键值与元素的映照数据的映照关系，是多对多的，因此，multimap 称为多重映照容器。multimap 与 map 之间的多重特性差...
std::multimap
dianyun7150的博客
06-20 657
标准库还定义了一个 multimap 容器，它与 map 类似，所不同的是它允许重复键。 成员函数 insert() 　　　　make_pair() 辅助函数来完成此任务。 find(k) 　　　　 返回指向第一个与键 k 匹配的 pair 的迭代指针， count(k) 　　　 成员函数返回与给定键关联的值得数量。 lower_bound(k) ...
C++11 容器库 std::map
mayue_web的博客
01-17 8392
概念 std::map 是有序键值对容器，它的元素的键是唯一的。用比较函数 Compare 排序键。搜索、移除和插入操作拥有对数复杂度。 map 通常实现为红黑树。 map映照容器运用了哈希表地址映射的思想，也就是key-value的思想，每一个key对应着一个值，每个key是唯一的，底层采用红黑树的数据结构实现。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节点都没有什...
std::set使用
欧特GO
07-21 760
#include <iostream> #include <set> using namespace std; /*Student结构体*/ struct Student { string name; int age; string sex; }; /*“仿函数"。为Student set指定排序准则*/ class SortCriterion { public: bool operator() (const Student& a, co
std：：set
qq_33179208的博客
10-24 427
STL set的用法总结  (2013-01-08 13:19:39) 转载▼ 标签：  stl   set   c/c   it   分类： 计算机相关知识⊙_⊙         工作上遇到一些set的使用问题，上网查了一下set的用法，大多数被称为“STL set学习笔记”的文章，几乎都照搬C++ p
stl map用法总结(网上转载)
08-07 848
  stl map用法总结(网上转载) 给出了map的基本用法如插入、查找、删除、遍历等等，同时告诉你如何实现双键map，包括(1) 只有两个键都匹配才命中目标(2) 两个键中任意一个匹配就命中目标可以扩展到多键(一) 介绍特点：1.map将Key的object和T的Object绑定到一起，因此是一种Pair Associative Container,
容器库(9)-std::multimap
Lucy_stone的博客
02-20 1005
std::multimap是一种关联容器，包含键值对的已排序的列表。和std::map不同的是，std::multimap允许重复的key值。搜索、移除和插入操作具有对数复杂度。
C++/C++11中std::set用法汇总
网络资源是无限的
03-18 6万+
C++/C++11中std::set用法汇总
std::map<std::string,std::map<std::string,std::string>> my_map;如何插入数据
04-28
要向`std::map<std::string,std::map<std::string,std::string>>`类型的`my_map`中插入数据，可以按照以下步骤进行操作： 1. 创建要插入的数据项，包括外层`std::string`类型的键和内层`std::map<std::string,std::string>`类型的值。例如，假设要插入的数据项为`key1 -> (inner_key1 -> value1, inner_key2 -> value2)`。 2. 使用`my_map[key1]`来访问外层`std::map`中的键`key1`对应的值，如果该键不存在，则会自动创建一个新的内层`std::map`。 3. 使用内层`std::map`的插入函数，例如`my_map[key1].insert(std::make_pair(inner_key1, value1))`，将内层键值对`(inner_key1, value1)`插入到对应的内层`std::map`中。 4. 重复上述步骤，插入其他内层键值对。 下面是一个示例代码，演示了如何向`my_map`中插入数据： ```cpp #include <iostream> #include <map> #include <string> int main() { std::map<std::string, std::map<std::string, std::string>> my_map; // 创建要插入的数据项 std::string key1 = "key1"; std::string inner_key1 = "inner_key1"; std::string value1 = "value1"; std::string inner_key2 = "inner_key2"; std::string value2 = "value2"; // 插入数据项 my_map[key1].insert(std::make_pair(inner_key1, value1)); my_map[key1].insert(std::make_pair(inner_key2, value2)); // 输出结果 for (const auto& outer_pair : my_map) { std::cout << outer_pair.first << " -> "; for (const auto& inner_pair : outer_pair.second) { std::cout << "(" << inner_pair.first << " -> " << inner_pair.second << ") "; } std::cout << std::endl; } return 0; } ``` 输出结果为： ``` key1 -> (inner_key1 -> value1) (inner_key2 -> value2) ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值