std::multimap

最新推荐文章于 2024-10-03 23:38:57 发布
最新推荐文章于 2024-10-03 23:38:57 发布
阅读量898 收藏 1
点赞数
分类专栏： C/C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TimerSea/article/details/128019970
版权
本文详细介绍了C++标准库中的关联容器std::multimap，包括其构造、元素访问、迭代器操作、容量管理、元素修改、查找功能，并通过实例演示了各种成员函数的使用。此外，还提到了非成员函数，如比较运算符在多映射中的应用。
摘要由CSDN通过智能技术生成

std::multimap

介绍

成员函数

非成员函数

介绍

// multimap 模板定义
template<class Key, class T, class Compare = std::less<Key>,
    class Allocator = std::allocator<std::pair<const Key, T>>> class multimap;
namespace pmr {
    template< class Key, class T, class Compare = std::less<Key> >
    using multimap = std::multimap<Key, T, Compare,
        std::pmr::polymorphic_allocator<std::pair<const Key, T>>>;
}
  • std::multimap 介绍摘选自 cppreference.com 中文网 std::multimap 介绍
  • multimap 是关联容器，含有键值对的已排序列表，同时容许多个元素拥有同一键，按照应用到键的比较函数 Compare 排序
  • 搜索、插入和移除操作拥有对数复杂度
  • 拥有等价键的键值对的顺序就是插入顺序，且不会更改
  • 标准库使用比较 (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::multimap<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::multimap<int, int>;
  map_int m1; //默认构造
  Print("m1", m1);

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

  map_int m4{{1, 1}, {1, 2}, {2, 1}, {2, 2}};
  Print("m4", m4);

  map_int m5(m4.begin(), m4.end()); //迭代器初始化
  Print("m5", m5);

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

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

  map_int m10{{1, 1}, {1, 2}, {2, 1}, {2, 2}}; //初始化列表
  Print("m10", m10);

  map_int m11 = m10; // 赋值运算符
  Print("m11", m11);

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

输出结果：
m1 :
m2 :
m3 :
m4 : 1 - 1 1 - 2 2 - 1 2 - 2
m5 : 1 - 1 1 - 2 2 - 1 2 - 2
m6 : 1 - 1 1 - 2 2 - 1 2 - 2
m7 : 1 - 1 1 - 2 2 - 1 2 - 2
m8 : 1 - 1 1 - 2 2 - 1 2 - 2
m9 : 1 - 1 1 - 2 2 - 1 2 - 2
m10 : 1 - 1 1 - 2 2 - 1 2 - 2
m11 : 1 - 1 1 - 2 2 - 1 2 - 2

元素访问
auto Print(const std::string &msg, const std::multimap<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::multimap<int, int>;
  map_int m1{{1, 1}, {1, 2}, {2, 1}, {2, 2}};
  Print("m1", m1);

  std::cout << "m1 : ";
  for (auto iter = m1.begin(); iter != m1.end(); ++iter) { // 打印 key 的元素
    if (iter->first == 1)
      std::cout << iter->first << " - " << iter->second << "\t";
  }
  std::cout << std::endl;
  return 0; // a.exec();
}

输出结果：
m1 : 1 - 1 1 - 2 2 - 1 2 - 2
m1 : 1 - 1 1 - 2

迭代器
auto Print(const std::string &msg, const std::multimap<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::multimap<int, int>;
  map_int m1{{1, 1}, {1, 2}, {2, 1}, {2, 2}};
  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 riter = m1.rbegin(); //返回指向起始的逆向迭代器
  std::cout << "m1 : ";
  for (; riter != m1.rend(); ++riter) {
    std::cout << riter->first << " - " << riter->second << "\t";
  }
  std::cout << "\n";

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

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

输出结果：
m1 : 1 - 1 1 - 2 2 - 1 2 - 2
m1 : 1 - 1 1 - 2 2 - 1 2 - 2
m1 : 1 - 1 1 - 2 2 - 1 2 - 2
m1 : 2 - 2 2 - 1 1 - 2 1 - 1
m1 : 2 - 2 2 - 1 1 - 2 1 - 1

容量
auto Print(const std::string &msg, const std::multimap<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::multimap<int, int>;
  map_int m1{{1, 1}, {1, 2}, {2, 1}, {2, 2}};
  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 : 1 - 1 1 - 2 2 - 1 2 - 2
m1.empty() : false
m1.size() : 4
m1.max_size() : 461168601842738790

修改器
auto Print(const std::string &msg, const std::multimap<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::multimap<int, int>;
  map_int m1{{1, 1}, {1, 2}, {2, 1}, {2, 2}};
  Print("m1", m1);

  m1.clear(); //  清除内容
  Print("m1", m1);
  m1.insert(std::pair<int, int>(1, 10)); //插入元素或结点
  m1.insert({1, 10});
  Print("m1", m1);
  m1.emplace(3, 30); //原位构造元素
  m1.emplace(3, 30);
  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);

  map_int m2;
  m2.swap(m1);
  Print("m1", m1);
  Print("m2", m2);

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

输出结果：
m1 : 1 - 1 1 - 2 2 - 1 2 - 2
m1 :
m1 : 1 - 10 1 - 10
m1 : 1 - 10 1 - 10 3 - 30 3 - 30
m1 : 1 - 10 1 - 10 3 - 30 3 - 30 5 - 50 6 - 60 7 - 70
m1 : 1 - 10 3 - 30 3 - 30 5 - 50 6 - 60 7 - 70
m1 :
m2 : 1 - 10 3 - 30 3 - 30 5 - 50 6 - 60 7 - 70

查找
auto Print(const std::string &msg, const std::multimap<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::multimap<int, int>;
  map_int m1{{1, 1}, {1, 2}, {2, 1}, {2, 2}};
  Print("m1", m1);

  std::cout << "m1.count(1) : " << m1.count(1)
            << std::endl; //返回匹配特定键的元素数量

  //寻找键等于 key 的的元素，若容器中有数个拥有键 key 的元素，则可能返回任意一者
  auto it = m1.find(2); //寻找带有特定键的元素
  if (it == m1.end()) {
    std::cout << "m1.find(2) : m1.end()" << std::endl;
  } else {
    std::cout << "m1.find(2) : " << it->first << " - " << it->second
              << std::endl;
  }

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

  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(2); //返回指向首个不小于给定键的元素的迭代器
  std::cout << "m1.lower_bound(2) : " << lit->first << " - " << lit->second
            << std::endl;

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

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

输出结果：
m1 : 1 - 1 1 - 2 2 - 1 2 - 2
m1.count(1) : 2
m1.find(2) : 2 - 1
1 - 1
2 - 1
m1.lower_bound(2) : 2 - 1
m1.upper_bound(1) : 2 - 1

非成员函数

auto Print(const std::string &msg, const std::multimap<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::multimap<int, int>;
  map_int m1{{1, 1}, {1, 2}, {2, 1}, {2, 2}};
  map_int m2{{1, 3}, {1, 2}, {2, 5}, {2, 2}};
  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 : 1 - 1 1 - 2 2 - 1 2 - 2
m2 : 1 - 3 1 - 2 2 - 5 2 - 2
m1 == m2 : false
m1 != m2 : true
m1 > m2 : false
m1 >= m2 : false
m1 < m2 : true
m1 <= m2 : true
m1 : 1 - 3 1 - 2 2 - 5 2 - 2
m2 : 1 - 1 1 - 2 2 - 1 2 - 2

起始

无夜_
关注
专栏目录
第四十五节 C++ STL（标准模板库）-映射类std::map std::multimap std::unordered_map std::unordered_multimap
菜鸟博客
05-01 870
map的操作与set类似，操作可参考上一节，这里仅介绍基本操作映射类： 为key-value(键-值)对容器, 支持根据key查找value， 如根据int可查找对应的stringstd::map: 存储唯一的键, 默认从小到大排序std::mulitmap: 可存储重复的键 ， 默认从小到大排序 std::unordered_map: 用散列函数排序，键唯一 std::unordered_mul...
std::map和std::multimap的使用总结
大山喵写博客的地方
11-07 1万+
Map和Multimap 　　Map和Multimap（下文统称Map）将key/value作为元素进行管理，逻辑上是一种键值映射关系，即数据结构中哈希表。它们可以根据key的排序规则进行自动元素排序，Multimap允许元素重复，而Map不允许。 　　在使用Map和Multimap之前， 必须引入头文件map #include&lt;map&gt; 　　在其中，map和multimap在s...
C++——std::Set
zy2317878的博客
01-05 2336
写在前面： 在写这篇博客之前吐个槽，其实也可不不用这么麻烦这么写博客。讲道理其实在书本上学这些知识应该挺快的。可以书上看一遍记个大概，然后做题的过程中，不断遇见各种小知识，这样分散的积累，然后一定规模后，就可以系统的整理。但是现在先花时间来做这件事，其实也可以，建立主体的框架，后面再慢慢细化丰富。也没必要想那么多，慢慢来。不管方法是什么，重要的是每天要做点事。那么这篇博客学习set容器。目前学习...
std::map
TimerSea的博客
11-24 1313
std::map基本操作代码示例
std::Set
weixin_30462049的博客
08-22 257
C++标准库：std_set作为一个有序集合 摘要：std::set作为标准库的一个关联容器，实现内部元素进行了排序，使用这特性可以对一组元素进行插入排序。std::set最初的设计是完成数学中“集合”的概念，它提供的接口也是如此。本文简单地介绍一下这一个标准库容器。 为了使用std::set，我只需要如下： #include<set> ...
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和std::map的区别
05-25
`std::map` 和 `std::multimap` 都是 C++ STL 中的关联容器，它们都提供了键值对的存储和查找操作，但是它们之间有一些区别。 1. 键值唯一性：`std::map` 中每个键只能对应一个值，而 `std::multimap` 中每个键可以...
std::multimap<int,char*>m2; std::map<int,std::multimap<int,char*>>m1;怎么才能获取m1中的multimap中的char*的值
09-10
在C++中，`std::multimap` 是一个可以存储键值对的容器，其中键是唯一的，但每个键可以关联多个值。`std::map` 是一个键唯一，每个键关联单个值的容器。 要从 `std::map,std::multimap,char*>>` 类型的 `m1` 中获取...
​std::multimap
weixin_34355715的博客
12-02 532
2019独角兽企业重金招聘Python工程师标准>>> ...
STL学习笔记-- multimap
weixin_33946020的博客
04-08 645
multimap 多重映照容器 multimap 与 map 一样，都是使用红黑树对记录型的元素数据,按元素键值的比较关系，进行快速的插入、删除和检索操作，所不同的是 multimap 允许将具有重复键值的元素插入容器。在 multimap 容器中，元素的键值与元素的映照数据的映照关系，是多对多的，因此，multimap 称为多重映照容器。multimap 与 map 之间的多重特性差...
C++11 容器库 std::map
mayue_web的博客
01-17 8718
概念 std::map 是有序键值对容器，它的元素的键是唯一的。用比较函数 Compare 排序键。搜索、移除和插入操作拥有对数复杂度。 map 通常实现为红黑树。 map映照容器运用了哈希表地址映射的思想，也就是key-value的思想，每一个key对应着一个值，每个key是唯一的，底层采用红黑树的数据结构实现。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节点都没有什...
std::set使用
欧特GO
07-21 781
#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 459
STL set的用法总结  (2013-01-08 13:19:39) 转载▼ 标签：  stl   set   c/c   it   分类： 计算机相关知识⊙_⊙         工作上遇到一些set的使用问题，上网查了一下set的用法，大多数被称为“STL set学习笔记”的文章，几乎都照搬C++ p
std::set
最新发布
南城以北的博客
10-03 573
std::set用于存储唯一的元素，并且这些元素会根据键的顺序自动排序。与std::map不同，std::set只存储键，而不存储键值对。std::set(const std::set& other)：拷贝构造函数，深拷贝。count(const key_type& k)：返回指定键的元素数量（总是0或1）swap(std::set& other)：交换两个set的内容。find(const key_type& k)：查找指定键的元素。std::set()：默认构造一个空的集合。
stl map用法总结(网上转载)
08-07 865
  stl map用法总结(网上转载) 给出了map的基本用法如插入、查找、删除、遍历等等，同时告诉你如何实现双键map，包括(1) 只有两个键都匹配才命中目标(2) 两个键中任意一个匹配就命中目标可以扩展到多键(一) 介绍特点：1.map将Key的object和T的Object绑定到一起，因此是一种Pair Associative Container,
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值