C++ std::map 的使用

原创 已于 2025-04-23 01:13:22 修改 · 746 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c++ #开发语言 #数据结构
于 2025-04-17 01:31:06 首次发布

注1：参考 cppreference.com 内容，这里对 cppreference.com 中的内容做实例举证

注2：本文基于 C++17

一、 std::map 是有序的

1.1 std::map 默认排序

std::map 是一种有序关联容器，键之间以函数 Compare 排序。

std::map 默认的迭代器以升序为迭代器，此升序由构造时所用的比较函数定义。

如下为 std::map 的默认：

int main() {
    std::map<int, std::string> mapDebug;
    mapDebug.insert({30, "abc"});
    mapDebug.insert({4, "abddc"});
    mapDebug.insert({7, "afsdfdsbc"});
    mapDebug.insert({1, "haha"});

    for (auto curKV : mapDebug) {
        std::cout << curKV.first << ":" << curKV.second << "; ";
    }
    std::cout << std::endl;
}

// 输出如下：
// 1:haha; 4:abddc; 7:afsdfdsbc; 30:abc;

1.2 std::map 自定义排序

如果是自定义的数据结构作为 key，则需要重新写比较函数，要不然会报错，如下：

struct DataInfo {
    int numKey;
    char charKey;
    std::string strKey;
    DataInfo(int a, char b, std::string c) : 
        numKey(a), charKey(b), strKey(c) {};
};

struct CmpKey {
    bool operator() (const DataInfo &a, const DataInfo &b) const
    {
        if (a.numKey == b.numKey) {
            if (a.charKey == b.charKey) {
                return a.strKey < b.strKey;  // strKey 升序；
            }
            return a.charKey > b.charKey;  // charKey 降序；
        }
        return a.numKey < b.numKey;  // numKey 升序；
    }
};

void OptDataMap()
{
    std::map<DataInfo, std::string, CmpKey> mapDebug;
    mapDebug.insert({{4, 'h', "abc"}, "abc"});
    mapDebug.insert({{2, 'd', "efg"}, "abddc"});
    mapDebug.insert({{1, 'f', "lmn"}, "afsdfdsbc"});
    mapDebug.insert({{2, 'c', "hik"}, "haha"});
    mapDebug.insert({{4, 'h', "def"}, "haha"});
    for (auto curKV : mapDebug) {
        std::cout << "{" << curKV.first.numKey << ", "
                  << curKV.first.charKey << ", "
                  << curKV.first.strKey << "}, "
                  << curKV.second << std::endl;
    }
}

int main() {
    OptDataMap();
}

/* 输出如下：
 * {1, f, lmn}, afsdfdsbc
 * {2, d, efg}, abddc
 * {2, c, hik}, haha
 * {4, h, abc}, abc
 * {4, h, def}, haha
 */

1.3 std::map 自定义排序续集

利用自定义数据结构的重载，完成排序，代码如下：


struct DataInfo {
    int numKey;
    char charKey;
    std::string strKey;

    DataInfo(int a, char b, std::string c) : 
        numKey(a), charKey(b), strKey(c) {};

    bool operator< (const DataInfo &input) const
    {
        if (this->numKey == input.numKey) {
            if (this->charKey == input.charKey) {
                return this->strKey < input.strKey;  // strKey 升序；
            }
            return this->charKey > input.charKey;  // charKey 降序；
        }
        return this->numKey < input.numKey;  // numKey 升序；
    }
};

void OptDataMap()
{
    std::map<DataInfo, std::string> mapDebug;
    mapDebug.insert({{4, 'h', "abc"}, "abc"});
    mapDebug.insert({{2, 'd', "efg"}, "abddc"});
    mapDebug.insert({{1, 'f', "lmn"}, "afsdfdsbc"});
    mapDebug.insert({{2, 'c', "hik"}, "haha"});
    mapDebug.insert({{4, 'h', "def"}, "haha"});
    for (auto curKV : mapDebug) {
        std::cout << "{" << curKV.first.numKey << ", "
                  << curKV.first.charKey << ", "
                  << curKV.first.strKey << "}, " << curKV.second << std::endl;
    }
}

/* 输出如下：
 * {1, f, lmn}, afsdfdsbc
 * {2, d, efg}, abddc
 * {2, c, hik}, haha
 * {4, h, abc}, abc
 * {4, h, def}, haha
 */

二、 std::map 的初始化及数据修改

  • 直接赋值，没啥介绍的，常规且基本操作，一笔带过
void MapInit()
{
    std::map<int, std::string> mapDebug;
    mapDebug[4] = "it`s 4";
    mapDebug[2] = "it`s 2";
    for (auto kv : mapDebug) {
        std::cout << "k:" << kv.first 
                  << ", v:" << kv.second
                  << std::endl;
    }
}

// k:2, v:it`s 2
// k:4, v:it`s 4
  • insert 方法赋值，cppreference.com 中的介绍是 insert 可以插入元素或节点(C++17 起)。这里分别实验一下
{
    using namespace std::string_literals; // 支持 "xxx"s 字面量
    std::map<std::string, float> heights;

    // 第一次插入（成功）
    const auto [it1, success1] = heights.insert({"Hinata"s, 162.8});
    std::cout << "Inserted? " << success1 // 输出 1（true）
              << "; Inserted at " << std::distance(heights.begin(), it1)
              << std::endl;

    // 第二次插入相同键（失败）
    const auto [it2, success2] = heights.insert({"Hinata"s, 165.0});
    std::cout << "Inserted? " << success2 // 输出 0（false）
              << "; Inserted at " << std::distance(heights.begin(), it2)
              << std::endl;

    // 第三次插入相同键（失败）
    const auto [it3, success3] = heights.insert({"Hinata3"s, 165.0});
    std::cout << "Inserted? " << success3 // 输出 1（true）
              << "; Inserted at " << std::distance(heights.begin(), it3)
              << std::endl;
// 输出如下：
// Inserted? 1; Inserted at 0
// Inserted? 0; Inserted at 0
// Inserted? 1; Inserted at 1
}

大概查了一下，insert 插入节点，并不怎么实用，这里一笔带过

#include <map>

int main() {
    std::map<int, std::string> m1, m2;
    m1[1] = "apple";

    // 提取节点（不释放内存）
    auto node = m1.extract(1);

    // 插入节点到另一个 map
    if (!node.empty()) {
        m2.insert(std::move(node));  // 无需重新分配内存
    }

    // 此时 m1 为空，m2 包含 {1, "apple"}
    return 0;
}

insert 从范围插入。从范围插入，必须是两个相同类型的 map，代码如下：

std::map<std::string, float> heights;    
std::map<std::string, float> heights2;
heights.insert({"Hinata"s, 162.8});
heights.insert({"Kageyama", 180.6});
 
// 从范围插入
heights2.insert(std::begin(heights), std::end(heights));

insert 还可以从列表插入，提供一个 initializer_list，一起插入，代码如下：

std::map<std::string, float> heights2;
heights2.insert({{"Kozume"s, 169.2}, {"Kuroo", 187.7}});
  •  使用 emplace 插入数据，代码如下：
#include <iostream>
#include <string>
#include <utility>
#include <map>
 
int main()
{
    std::map<std::string, std::string> m;
 
    // 使用 pair 的移动构造函数
    auto [it, result] = m.emplace(std::make_pair(std::string("a"), std::string("a")));
    std::cout << std::distance(m.begin(), it) << std::endl;  // 输出 0
    std::cout << result << std::endl;  //  输出 1，表示成功
 
    // 使用 pair 的转换移动构造函数
    m.emplace(std::make_pair("b", "abcd"));
 
    // 使用 pair 的模板构造函数
    m.emplace("d", "ddd");
 
    // 带有重复键的 emplace 没有效果
    auto [it1, result1] = m.emplace("d", "DDD");
    std::cout << std::distance(m.begin(), it1) << std::endl;
    // 输出 2，其实表示的是上面插入 d,ddd 的结果，就是 key=d 的下标
    std::cout << result1 << std::endl;  // 输出 0 ，表示插入失败
 
    for (const auto& p : m)
        std::cout << p.first << " => " << p.second << '\n';
}

/*
a => a
b => abcd
d => ddd
*/
  • 使用 try_emplace 插入数据。C++17 推荐使用 try_emplace 方式插入数据

  •  使用 insert_or_assign 方式插入数据。插入元素，或若键已存在则赋值给当前元素。这个使用与一定场景，如果已经有数据，可以覆盖原来的值
#include <iostream>
#include <string>
#include <map>
 
void print_node(const auto& node)
{
    std::cout << '[' << node.first << "] = " << node.second << '\n';
}
 
void print_result(auto const& pair)
{
    std::cout << (pair.second ? "inserted: " : "assigned: ");
    print_node(*pair.first);
}
 
int main()
{
    std::map<std::string, std::string> myMap;
 
    print_result(myMap.insert_or_assign("a", "apple"));
    print_result(myMap.insert_or_assign("b", "banana"));
    print_result(myMap.insert_or_assign("c", "cherry"));
    print_result(myMap.insert_or_assign("c", "clementine"));
 
    for (const auto& node : myMap)
        print_node(node);
}
/*
inserted: [a] = apple
inserted: [b] = banana
inserted: [c] = cherry
assigned: [c] = clementine
[a] = apple
[b] = banana
[c] = clementine
*/

extrace 提取容器中的节点，提取之后，map 中就没有这个节点数据了。

#include <algorithm>
#include <iostream>
#include <string_view>
#include <map>
 
void print(std::string_view comment, const auto& data)
{
    std::cout << comment;
    for (auto [k, v] : data)
        std::cout << ' ' << k << '(' << v << ')';
 
    std::cout << '\n';
}
 
int main()
{
    std::map<int, char> cont{{1, 'a'}, {2, 'b'}, {3, 'c'}};
 
    print("Start:", cont);
 
    // 提取节点句柄并改变键
    auto nh = cont.extract(1);
    nh.key() = 4;  //  注意这个用法，比较实用
 
    print("After extract and before insert:", cont);
 
    // 将节点句柄插回去
    cont.insert(std::move(nh));
 
    print("End:", cont);
}

/*
输出：
Start: 1(a) 2(b) 3(c)
After extract and before insert: 2(b) 3(c)
End: 2(b) 3(c) 4(a)
*/
  •  erase() 擦除元素。关键点是注意 for 循环和 while 循环时候的自增运算
#include <map>
#include <iostream>
 
int main()
{
    std::map<int, std::string> c =
    {
        {1, "one" }, {2, "two" }, {3, "three"},
        {4, "four"}, {5, "five"}, {6, "six"  }
    };
 
    // 从 c 移除所有奇数
    for (auto it = c.begin(); it != c.end(); )
    {  //  注意 for 循环的写法，第三个表达式不写
        if (it->first % 2 != 0)
            it = c.erase(it);  // 调用了 erase 的话，就不++
        else
            ++it;  // 没调用 erase 的时候，for 循环 ++
    }
 
    for (auto& p : c)
        std::cout << p.second << ' ';
    std::cout << '\n';
}
  • merge() 函数，假如当前有两个 map 对象，m1 和 m2，将 m2 merge 到 m1 里面，merge 会尝试从 m2 中提取每个元素，然后插入到 m1 中。插入到 m1 的时候，如果 m1 中已经有等价的元素，则不会从 m2 中提取元素。如果 m1 中没有等价的元素，则会提取并插入到 m1 中，需要注意的是，从 m2 中提取元素会修改 m2 的数据，m2 中不再有提取出来的元素。代码：
void MapMergeDebug() {
    std::map<int, std::string> ma{{1, "apple"}, {5, "pear"}, {10, "banana"}};
    std::map<int, std::string> mb{{2, "zorro"}, {4, "batman"}, {5, "X"}, {8, "alpaca"}};

    ma.merge(mb);

    std::cout << "ma.size(): " << ma.size() << '\n';
    std::cout << "mb.size(): " << mb.size() << '\n';
    std::cout << "ma: ";
    for (auto const& kv : ma)
        std::cout << kv.first << "," << kv.second << "; ";
    std::cout << std::endl;
    std::cout << "mb: ";
    for (auto const& kv : mb)
        std::cout << kv.first << "," << kv.second << "; ";
    std::cout << std::endl;
}
/* 输出：
ma.size(): 6
mb.size(): 1
ma: 1,apple; 2,zorro; 4,batman; 5,pear; 8,alpaca; 10,banana; 
mb: 5,X;
*/

SBJBA
关注
C++(10): std::map、std::multimap与std::unordered_map
tecsai的博客
04-07 2205
std::map、std::multimap 和 std::unordered_map 是 C++ 标准模板库（STL）中的三种关联容器，它们提供了存储键值对（pair）的方式，并允许通过键来快速检索值。这三者之间的主要区别在于它们的内部数据结构和对元素的排序方式。
std:map与迭代器简析
格物致知 诚意正心
09-17 4157
背景 最近在读ROS操作系统源代码，多处遇到std::map这一容器。为更好理解ROS源代码，现将std::map的相关知识进行一个梳理。 因ROS而动意写此文，但下面内容主要描述ROS代码相关部分。 概览 std::map是一种关联容器，查询一个元素是否存在，并有效地获取元素。具体地，map是一个键/值（key/value）对，键（key）用于查询，而值（value）包含我们希望使用的数据
[C++]std::map用法
最新发布
sillyoung的博客
05-02 145
这里给出三种数据查找方法 1、用count函数来判定关键字是否出现，其缺点是无法定位数据出现位置,由于map的特性，一对一的映射关系，就决定了count函数的返回值只有两个，要么是0，要么是1，出现的情况，当然是返回1了 2、用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节点都没有什么影响。
STL中的map
明朗晨光的专栏
01-17 1631
map的初始化，使用，以及该类中的函数
突破编程_C++_STL教程（ map 的基础知识）
突破编程
03-10 1628
C++ STL教程： map 的基础知识
对std::map进行排序
dizi9750的博客
08-06 4785
1、对Key排序。 　　std::map的第三个参数即为对key进行排序的比较函数。默认为less，表示升序。如果要降序，可以改为greater。 2、对Value排序 不支持，因为map不是一个序列的容器。如果真要排序，需要转为一个保存pair的vector，再排序。 不过这样性能就受损了，建议更换容器。 详细参考： https://blog....
std::map
热门推荐
05-03 3万+
映射和多重映射基于某一类型Key的键集的存在，提供对T类型的数据进行快速和高效的检索。对map而言，键只是指存储在容器中的某一成员。Map不支持副本键，multimap支持副本键。Map和multimap对象包涵了键和各个键有关的值，键和值的数据类型是不相同的，这与set不同。set中的key和value是Key类型的，而map中的key和value是一个pair结构中的两个分量。
《C++——std::map》
fwfxhhx的博客
08-24 1224
在 C++ 标准模板库（STL）中，std::map 是一个非常实用的关联容器，它以键值对（key-value）的形式存储数据，并能自动按照键（key）进行排序。无论是存储配置信息、建立映射关系还是实现字典功能，std::map 都是开发者的得力助手。本文将带你从零开始，快速掌握 std::map 的使用方法。
C++——std::Map
zy2317878的博客
01-02 4134
写在前面： 有一段时间没有继续进行C++容器的学习了。这次接着C++-std::Vector 的内容继续学习。通过之前的vector的学习，我发现虽然对该容器有一个比较全面的认识，但是很多细节还是不能注意好。比如在 LeetCode-406. Queue Reconstruction by Height 这道题中使用vector的insert函数，而我之前的方法由于没有把握好erase函数的使用...
C++ std:map深入解析与用法指南
weixin_74396256的博客
10-28 6806
C++ std::map 深入解析与用法指南
c++ std::map使用笔记
曾经也曾立志
02-28 721
std::map默认使用运算符对键进行排序。// 使用 greater<string> 实现降序排序// 自定义比较函数std::map是一个高效的关联容器，适合存储键值对并自动按键排序。键的唯一性。自动按键排序。高效的查找、插入和删除操作（(O(\log n))）。支持自定义排序规则。如果需要存储重复键，可以使用。
C++ std::map几种遍历方式(正序、倒序)
Adunn的专栏
02-04 2万+
C++ std::map几种遍历方式(正序、倒序) 1、map 的定义方式 2、正序遍历 map 2.1 使用 for 循环 2.2 使用 while 循环 3、倒序遍历 map 3.1 使用 for 循环 3.2 使用 while 循环 4、使用 std::greater 属性，直接定义倒序存储的 map 4.1 使用 for 循环 4.2 使用 while 循环
自定义std::map的排序
qq_28107929的博客
06-03 6948
std::map的内部排序是按照红黑树进行的，所以，查询时间复杂度为O(log2n). STL中map的定义是： 复制代码 1 template<class _Kty, 2 class _Ty, 3 class _Pr = less<_Kty>, 4 class _Alloc = allocator<pair<const _Kty, _Ty&g...
std::map容器中的元素排序
weixin_38213410的博客
08-18 867
如上述代码所示，当我们想比较map中元素进行排序的时候，并不需要考虑Element的具体类型，在写谓词函数的时候，只需要考虑key的类型即可。OK，这里不进一步讨论红黑树的实现，主要是想说一下，要对map中的元素进行排序，特别是当我们的值是自定义的时候，如何实现自定义的排序。map作为C++标准库提供的关联容器之一，内部使用的是红黑树（Red-Black Tree）作为其底层的数据结构的。假设键的类型是简单数据类型，比如int。
std map用法
alex1801
03-26 1万+
目录 1、map定义 2、赋值 or 插入 3、访问 3.1、通过key直接访问 3.2、迭代器 4、查找key值是否存在 5、移除key 6、容量 7、顺序比较 map的底层结构是红黑树，映射是关联容器。map中的元素是一些关键字-值对：关键字 起到索引的作用，值则表示与索引向关联的数据。 关键字是唯一的，不能重名。对于迭代器来说，可以修改实值，而不能修改key。根据key值快速查找记录，查找的复杂度基本是Log(N)，map是按key值排序，且与插入顺序无关。 头文件： #i
std::map使用方式以及注意事项(关于相同key的问题)
YiYeZhiNian的博客
12-31 7724
std::map的使用在C++开发中也是经常会用到的一些东西，这里进行一些简单的使用记录，包括如何插入、删除以及修改等。
【C++】STL——map的介绍和使用、map的构造函数、map的迭代器、map的容量和访问函数、map的增删查改函数
Crocodile1006的博客
08-22 8716
STL、map的介绍、map的使用、map的构造函数、map的迭代器、map的容量和访问函数、empty、size、operator[]、map的增删查改函数、insert、erase
C++笔记 STL map容器基本操作 排序
weixin_40933653的博客
03-31 2295
map默认按照key进行升序排序，和输入的顺序无关。 为了实现快速查找，map内部本身就是按序存储的（比如红黑树）。在我们插入<key, value>键值对时，就会按照key的大小顺序进行存储，其中key的类型必须能够进行 < 运算，且唯一，默认排序是按照从小到大便利记忆联想到需要支持小于运算。 1、使用迭代器进行遍历打印 void printMap1(map<int, int, MyCompare> &m) { for (map<int,...
stdmap 容器使用详细说明
一直在水些技术小文
08-25 824
下面说下，map在空间上的特性，否则，估计你用起来会有时候表现的比较郁闷，由于map的每个数据对应红黑树上的一个节点，这个节点在不保存你的数据时，是占用16个字节的，一个父节点指针，左右孩子指针，还有一个枚举值（标示红黑的，相当于平衡二叉树中的平衡因子），我想大家应该知道，这些地方很费内存了吧，不说了……由于STL是一个统一的整体，map的很多用法都和STL中其它的东西结合在一起，比如在排序上，这里默认用的是小于号，即less，如果要从大到小排序呢，这里涉及到的东西很多，在此无法一一加以说明。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值