【045】C++中map和multimap容器全面解析：深入学习，轻松掌握

最新推荐文章于 2024-02-13 08:25:07 发布
最新推荐文章于 2024-02-13 08:25:07 发布
阅读量1.2k 收藏 33
点赞数 38
分类专栏： C++从零开始到精通 文章标签： c++ 学习 开发语言 linux 服务器 C++11 map
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Long_xu/article/details/135572497
版权

这里写目录标题

一、介绍

在C++中，map和multimap容器是非常重要的数据结构，它们提供了一种键值对的映射关系，可以高效地组织和访问数据。map容器中的每个元素都包含一个键和一个值，而multimap容器允许键重复。

这两种容器在实际项目中广泛应用，特别适合需要快速查找和插入元素的场景。其底层实现采用了红黑树等高效的数据结构，map和multimap容器在处理大量数据时具有良好的性能表现。它们也提供了丰富的操作方法和函数，可以轻松地对容器中的数据进行插入、删除、查找和遍历操作。

深入理解map和multimap容器的使用方法和性能特点可以设计高效的数据结构和算法，提高程序的性能和可维护性。

二、map和multimap容器的基本概念

map的特性是，所有元素都会根据元素的键值自动排序。map所有的元素都是pair，同时拥有实值和键值，pair的第一元素被视为键值,第二元素被视为实值，map 不允许两个元素有相同的键值。我们可以通过map的迭代器改变map的键值吗?答案是不行，因为 map的键值关系到 map元素的排列规则，任意改变map键值将会严重破坏map数据组织。如果想要修改元素的实值，那么是可以的。

map和list拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。

map容器提供了快速的查找、插入和删除操作，时间复杂度为O(log n)。

multimap与map类似，也是键-值对的容器，不同之处在于它允许重复的键。multimap容器同样是有序的，使用红黑树来组织数据，提供了快速的查找、插入和删除操作，时间复杂度为O(log n)。

在这里插入图片描述
map容器：每个元素都是键值-实值成对存储，自动根据键值排序，键值不能重复，不能修改。
multimap和map的操作类似，唯一区别 multimap键值可重复。map和multimap都是以红黑树为底层实现机制。

三、map和multimap容器的基本操作

3.1、常用的接口函数API

（1）构造函数：

// 默认构造
map<Key, T> m;		//默认构造一个空的map，键的类型为Key，值的类型为T。
multimap<Key, T> mm;//默认构造一个空的multimap，键的类型为Key，值的类型为T。

// 带有比较函数参数的构造函数：
map< Key, T, Compare> m (const Compare& comp);		//通过指定比较函数comp来构造map。
multimap< Key, T, Compare> mm (const Compare& comp);//通过指定比较函数comp来构造multimap。

// 区间构造函数：
map< Key, T> m (InputIterator first, InputIterator last);		//使用迭代器范围[first, last)内的元素来构造map。
multimap< Key, T> mm (InputIterator first, InputIterator last)	//使用迭代器范围[first, last)内的元素来构造multimap。

//拷贝构造函数：
map< Key, T> m (const map& x);				//拷贝构造一个map，其元素和x相同。
multimap< Key, T> mm (const multimap& x);	//拷贝构造一个multimap，其元素和x相同。

//移动构造函数（C++11引入）：
map< Key, T> m (map&& x);			//移动构造一个map，取得x的资源但留下x为空。
multimap< Key, T> mm (multimap&& x);//移动构造一个multimap，取得x的资源但留下x为空。

（2）赋值操作：

// 赋值运算符：
map& operator=(const map& x);			//赋值运算符重载，用x的内容替换当前map的内容。
multimap& operator=(const multimap& x);	//赋值运算符重载，用x的内容替换当前multimap的内容。
// swap函数：
void swap(map& x);		//交换当前map和map x的内容。
void swap(multimap& x);	//交换当前multimap和multimap x的内容。

（3）大小操作：

// size函数：
size_type size() const;	//返回map或multimap中元素的个数。
// empty函数：
bool empty() const;		//如果map或multimap为空，则返回true，否则返回false。

（4）插入数据元素操作：

// insert函数：
pair<iterator, bool> insert(const value_type& val);			//在map中插入val，返回一个pair，第一个元素是一个迭代器，指向新插入的元素或者已存在的相同键的元素，第二个元素是一个bool值，表示插入是否成功。
iterator insert(iterator position, const value_type& val);	//在position位置插入val，并返回插入元素的迭代器。

// emplace函数：使用传入的参数构造元素并插入map中，返回一个pair，
// 第一个元素是一个迭代器，指向新插入的元素或者已存在的相同键的元素，第二个元素是一个bool值，表示插入是否成功。
template <class... Args> pair<iterator, bool> emplace(Args&&... args);

// insert_or_assign函数（C++17及以上版本）：如果k存在，则将其关联的值替换为obj，如果不存在则创建一个新的键值对，并返回一个pair，
// 第一个元素是一个迭代器，指向新插入或修改的元素，第二个元素是一个bool值，表示是插入还是修改操作。
- template <class M> pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);

（5）删除操作：

// erase函数：
iterator erase(iterator position);				//删除指向位置position的元素，并返回指向被删元素之后的下一个元素的迭代器。
size_type erase(const key_type& k);				//删除所有键为k的元素，并返回被删除的元素的数量。
iterator erase(iterator first, iterator last);	//删除[first, last)范围内的所有元素，并返回指向被删元素之后的下一个元素的迭代器。

// clear函数：删除map或multimap中的所有元素。
void clear();

（6）查找操作：

// find函数：
iterator find(const key_type& k);				//查找键为k的元素，并返回指向该元素的迭代器，如果未找到则返回指向尾部的迭代器。
const_iterator find(const key_type& k) const;	//在const map或multimap中查找键为k的元素，并返回指向该元素的const迭代器。

// count函数：返回map或multimap中键等于k的元素的个数。
size_type count(const key_type& k) const;

// lower_bound函数：返回一个迭代器，指向第一个不小于k的元素。
iterator lower_bound(const key_type& k);

// upper_bound函数：返回一个迭代器，指向第一个大于k的元素。
iterator upper_bound(const key_type& k);

// equal_range函数：返回一个pair，包含两个迭代器，第一个迭代器指向键值等于k的第一个元素，第二个迭代器指向键值大于k的第一个元素。
pair<iterator, iterator> equal_range(const key_type& k);

（7）访问元素：

  • operator[]：通过键访问对应的值。
  • at(key)：通过键访问对应的值，如果不存在会抛出out_of_range异常。
  • find(key)：查找键为key的元素，返回指向该元素的迭代器。

3.2、使用示例

（1）创建和初始化map和multimap容器：

#include <iostream>
#include <map>
#include <unordered_map>

int main() {
    // 创建并初始化map容器
    std::map<int, std::string> myMap = {
        {1, "One"},
        {2, "Two"},
        {3, "Three"}
    };

    // 创建并初始化multimap容器
    std::multimap<int, std::string> myMultimap = {
        {1, "Apple"},
        {2, "Banana"},
        {2, "Orange"}
    };

    // 输出map容器内容
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 输出multimap容器内容
    for (const auto& pair : myMultimap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

（2）插入和删除元素：

#include <iostream>
#include <map>
#include <unordered_map>

int main() {
    // 创建并初始化map容器
    std::map<int, std::string> myMap = {
        {1, "One"},
        {2, "Two"},
        {3, "Three"}
    };

    // 插入元素到map中
    myMap.insert(std::make_pair(4, "Four"));
    myMap[5] = "Five";  // 或者使用下标操作符[]

    // 输出map容器内容
    std::cout << "Map after insertions:" << std::endl;
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 删除元素从map中
    myMap.erase(2);  // 删除键为2的元素

    // 输出map容器内容
    std::cout << "\nMap after deletion:" << std::endl;
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 创建并初始化multimap容器
    std::multimap<int, std::string> myMultimap = {
        {1, "Apple"},
        {2, "Banana"},
        {2, "Orange"}
    };

    // 插入元素到multimap中
    myMultimap.insert(std::make_pair(3, "Peach"));

    // 输出multimap容器内容
    std::cout << "\nMultimap after insertions:" << std::endl;
    for (const auto& pair : myMultimap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 删除元素从multimap中
    // 删除multimap中所有键为2的元素
    auto it = myMultimap.find(2);
    myMultimap.erase(it, myMultimap.end());

    // 输出multimap容器内容
    std::cout << "\nMultimap after deletion:" << std::endl;
    for (const auto& pair : myMultimap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

（3）查找和访问元素：

#include <iostream>
#include <map>
#include <unordered_map>

int main() {
    // 创建并初始化map容器
    std::map<int, std::string> myMap = {
        {1, "One"},
        {2, "Two"},
        {3, "Three"}
    };

    // 查找和访问map中的元素
    // 使用find函数查找键为2的元素
    auto it = myMap.find(2);
    if (it != myMap.end()) {
        std::cout << "Element with key 2 found: " << it->second << std::endl;
    } else {
        std::cout << "Element with key 2 not found" << std::endl;
    }

    // 修改元素的值
    myMap[1] = "One (updated)";

    // 输出map容器内容
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 创建并初始化multimap容器
    std::multimap<int, std::string> myMultimap = {
        {1, "Apple"},
        {2, "Banana"},
        {2, "Orange"}
    };

    // 查找和访问multimap中的元素
    // 使用equal_range函数查找键为2的元素
    auto range = myMultimap.equal_range(2);
    for (auto it = range.first; it != range.second; ++it) {
        std::cout << "Element with key 2 found: " << it->second << std::endl;
    }

    return 0;
}

（4）遍历容器的所有元素：

#include <iostream>
#include <map>
#include <unordered_map>

int main() {
    // 创建并初始化map容器
    std::map<int, std::string> myMap = {
        {1, "One"},
        {2, "Two"},
        {3, "Three"}
    };

    // 遍历map容器的所有元素
    std::cout << "Iterating through map:" << std::endl;
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 创建并初始化multimap容器
    std::multimap<int, std::string> myMultimap = {
        {1, "Apple"},
        {2, "Banana"},
        {2, "Orange"}
    };

    // 遍历multimap容器的所有元素
    std::cout << "\nIterating through multimap:" << std::endl;
    for (const auto& pair : myMultimap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

3.3、性能分析

map和multimap都是关联容器，它们都基于红黑树实现。它们之间的主要区别在于：

  • map中的每个键都是唯一的，而multimap允许多个具有相同键的元素存在。
  • multimap中的元素在树中是按键值排序的，而map中的元素则按照键的比较函数进行排序。

从性能上来说，map通常比multimap具有更好的性能，因为map中的键是唯一的，可以更快地进行查找和访问操作。

如何选择：

  • 要保持键的唯一性，应该选择map。
  • 要允许多个具有相同键的元素存在，那么就应该选择multimap。

四、map和multimap容器的高级操作

（1）自定义比较函数和排序：在默认情况下，map和multimap容器使用元素的键值进行排序，但是有时候要根据不同的标准进行排序，这就需要自定义比较函数。

自定义比较函数需要满足严格弱顺序（Strict Weak Ordering）的要求：

  1. 反对称性：如果 a 不小于 b 且 b 不小于 a，则 a 等于 b。
  2. 传递性：如果 a 小于 b 且 b 小于 c，则 a 也小于 c。
  3. 可以相等：两个元素可以相等。

示例：

#include <iostream>
#include <map>
#include <string>

struct CustomCompare {
    bool operator() (const std::string& a, const std::string& b) const {
        // 根据字符串长度进行排序
        return a.length() < b.length();
    }
};

int main() {
    std::map<std::string, int, CustomCompare> myMap = {
        {"one", 1},
        {"three", 3},
        {"two", 2}
    };

    for (const auto& pair : myMap) {
        std::cout << pair.first << " : " << pair.second << std::endl;
    }

    return 0;
}

（2）处理重复键（multimap）：遍历查找特定键的所有值。

std::multimap<int, std::string> myMultimap;
myMultimap.insert({1, "one"});
myMultimap.insert({2, "two"});
myMultimap.insert({1, "first"}); // 在键为1的位置再插入一个值

int keyToFind = 1;
auto range = myMultimap.equal_range(keyToFind);
for (auto it = range.first; it != range.second; ++it) {
    std::cout << it->first << " : " << it->second << std::endl;
}

（3）对map和multimap容器中的数据进行排序：

  1. 对 map 容器进行元素值排序：可以将 map 中的键值对元素复制到一个 vector 中，然后使用自定义的比较函数对 vector 进行排序：

    std::map<int, std::string> myMap = {
    {2, "two"},
    {1, "one"},
    {3, "three"}
};

std::vector<std::pair<int, std::string>> vec(myMap.begin(), myMap.end());
std::sort(vec.begin(), vec.end(), 
          [](const std::pair<int, std::string>& a, const std::pair<int, std::string>& b) {
              return a.second < b.second;
          });

  2. 对 multimap 容器进行元素值排序：由于 multimap 允许重复的键值，我们可以使用相似的方法将 multimap 中的元素复制到一个 vector 中，并使用自定义的比较函数对 vector 进行排序：

    std::multimap<int, std::string> myMultiMap = {
    {2, "two"},
    {1, "one"},
    {3, "three"},
    {2, "second"}
};

std::vector<std::pair<int, std::string>> vec(myMultiMap.begin(), myMultiMap.end());
std::sort(vec.begin(), vec.end(), 
          [](const std::pair<int, std::string>& a, const std::pair<int, std::string>& b) {
              return a.second < b.second;
          });

这样就可以使用自定义的比较函数对 map 和 multimap 容器中的元素值进行排序。在需要按照元素值而不是键值进行排序时，这些方法都比较有用。

五、代码实践

（1）map容器的使用。

#include <iostream>
#include <map>
#include <utility>
#include <string>
using namespace std;
class Person
{
        friend void test01();
        friend void printAll(map<int,Person> &m);
private:
        int num;
        string name;
        float score;
public:
        Person(){}
        Person(int num,string name,float score){
                this->num = num;
                this->name = name;
                this->score = score;
        }
};

void printAll(map<int,Person> &m)
{
        for(auto &[key,value]:m)
        {
                cout<<value.name<<","<<value.num<<","<<value.score<<endl;
        }
}

void test01(){
        map<int,Person> m;
                //方式1
        m.insert(pair<int,Person> (103,Person(103,"Lion",100.1)));
        // 方式二（推荐）
        m.insert(make_pair(102,Person(102,"Lion2",100.1)));
        // 方式三
        m.insert(map<int,Person>::value_type(101,Person(101,"Lion3",100.1)));
        // 方式四(危险)
        m[100]=Person(100,"FLY",100.1);
        printAll(m);

        // 演示方式四的危险性。
        cout<<"***********************"<<endl;
        cout<<m[107].name<<","<<m[107].num<<","<<m[107].score<<endl;
        printAll(m);
}
int main(int argc, char *argv[]){
        test01();
        return 0;
}

输出：

FLY,100,100.1
Lion3,101,100.1
Lion2,102,100.1
Lion,103,100.1
***********************
,0,0
FLY,100,100.1
Lion3,101,100.1
Lion2,102,100.1
Lion,103,100.1
,0,0

（2）multimap的示例。

#include <iostream>
#include <map>
#include <string>

int main() {
    // 创建一个 multimap 容器，键是 int 型，值是 string 型
    std::multimap<int, std::string> myMultiMap;

    // 向 multimap 中插入元素
    myMultiMap.insert(std::make_pair(1, "apple"));
    myMultiMap.insert(std::make_pair(2, "banana"));
    myMultiMap.insert(std::make_pair(3, "apple")); // 重复的键值

    // 遍历 multimap 并打印所有元素
    std::cout << "All elements in the multimap:" << std::endl;
    for (auto it = myMultiMap.begin(); it != myMultiMap.end(); ++it) {
        std::cout << it->first << " : " << it->second << std::endl;
    }

    // 查找特定键值对应的所有元素
    int keyToFind = 1;
    auto range = myMultiMap.equal_range(keyToFind);
    std::cout << "All elements with key " << keyToFind << ":" << std::endl;
    for (auto it = range.first; it != range.second; ++it) {
        std::cout << it->first << " : " << it->second << std::endl;
    }

    return 0;
}

总结

map和multimap是C++标准库中非常重要且常用的容器类型，它们都是关联式容器（Associative Containers），用于实现键值对映射。

  1. map和multimap容器使用红黑树实现，因此能够在O(log n)的时间复杂度内进行查找和检索操作，这使得它们非常适合于需要快速查找特定键值的应用场景。

  2. 这两种容器中的元素默认按照键值进行排序，map要求键值唯一，而multimap允许键值重复。这使得它们非常适合于建立有序的键值对映射，使得对数据的处理更加方便。

  3. 由于其快速查找和自动排序的特性，map和multimap容器可以应用于各种类型的问题，如数据存储、索引管理、关联规则等。

  4. map和multimap容器提供了各种方法来插入、删除和修改元素，同时它们还提供了丰富的迭代器接口和算法，对数据的操作更加灵活和方便。

在这里插入图片描述

Lion Long
关注
  • 38
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 25
    评论
专栏目录
c++STL常用容器之Map/Multimap容器——全面总结（附案例解析）（十九）map按value值进行比较以及仿函数更改默认排序规则
cfl997
11-26 8767
这里有C++STL——全面总结详细教程（附案例解析）（持续更新中） 目录 map/ multimap容器 map基本概念 map构造和赋值 map大小和交换 map插入和删除 map查找和统计 map容器排序 仿函数更改默认排序规则和Value值排序 map/ multimap容器 map基本概念 简介： map中所有元素都是pair pair中第一个元素为...
c++中map的基本用法和嵌套用法实例分析
01-20
C++中map容器提供一个键值对容器，map与multimap差别仅仅在于multiple允许一个键对应多个值。本文主要总结一下map基本用法和嵌套用法示例。 一、map基本用法 1. 头文件 代码如下:#include <map> 2. 定义 代码...
浅析c++迭代器之multimap
tianxiaolu1175的专栏
09-10 3067
关联式容器 1.什么是关联式容器 关联式容器依据特定的排序法则，自动对容器内的数据元素进行排序。排序的准则是以函数的形式呈现出来的，用来比较数据元素的值（value）或者键（key）。在默认的缺省状态下是以 operator 2.关联式容器的底层实现 关联式容器是由搜索二叉树（binary tree）实现出来的。 3.关联式容器的类别： 关联式容器的差别主要在于数据元素
c++ STL系列——（六）multimap
最新发布
飞影铠甲的博客
02-13 447
c++STL
c++---map/multimap容器
m0_50046535的博客
04-22 1193
1.map基本概念 简介： map中所有元素都是pair pair中的第一个元素为key（键值），起到索引作用，第二个元素为value（实值） 所有元素都会根据元素的键值自动排序 本质： map/multimap属于关联式容器，底层结构是用二叉树实现 优点： 可以根据key值快速找到value值 map和multimap的区别 map不允许容器中有重复key元素 multimap允许有重复key元素 2、map构造和赋值 函数原型： map<T1,T2> mp；map默认构造
C++>并联式容器map,set,multimap,multidetset的底层实现
qq_42069216的博客
08-31 1157
C++>并联式容器map,set,multimap,multidetset的底层实现
【 C++ 】map、multimap的介绍和使用
bit_zyx的博客
09-04 1924
目录 1、map map的介绍 map的定义 insert插入函数 map的迭代器 [ ]运算符重载 find查找函数 erase删除函数 其它函数 总结 2、multimap multimap的介绍 multimap的使用...
C++进阶 —— multimap
NapoleonCoder的博客
05-30 5614
关联式容器multimap；
C++——map 和 multimap
qwjy的博客
04-03 2950
  文章目录结构构造操作非更易型操作查找操作赋值元素访问迭代器相关操作插入和移除       Map 和 multimap 将 key/value pair 当作元素进行管理。它们可根据 key 的排序准则自动为元素排序。Multimap 允许重复元素，map 不允许，如下图所示。 map 和 multimap 包含在头文件中： #include <map> 在其中，map 和 multimap 被定义为命名空间 std 内的 class template：
C++ multimap
weixin_45743799的博客
03-17 7240
multimap 是关联容器的一种，multimap 的每个元素都分为关键字和值两部分，容器中的元素是按关键字排序的，并且允许有多个元素的关键字相同。 注意：不能直接修改 multimap 容器中的关键字。因为 multimap 中的元素是按照关键字排序的，当关键字被修改后，容器并不会自动重新调整顺序，于是容器的有序性就会被破坏，再在其上进行查找等操作就会得到错误的结果。 使用 multimap ...
【C++ STL】 --- map
M2嵌入式
08-30 488
1、map基本概念 简介： map中所有元素都是pair pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值） 所有元素都会根据元素的键值自动排序 本质： map/multimap属于关联式容器，底层结构是用二叉树实现。 优点： 可以根据key值快速找到value值 map和multimap区别： map不允许容器中有重复key值元素 multimap允许容器中有重复key值元素 2、map的构造和赋值 功能描述： 对map容器进行构造和赋值操作
C++容器——字典（multimap）
shouhu010的博客
03-23 1238
c++ 容器 multimap 初始化 简介
cpp-btree:现代 C++ B 树容器
05-29
类似于 STL std::map 、 std::set 、 std::multimap和std::multiset模板，这个库提供了btree::map 、 btree::set 、 btree::multimap和btree::multiset 。 这与 Google 的原始项目不同，因为容器的行为更像现代 ...
C++ STL(vector+multimap容器)案例
03-16
公司今天招聘了10个员工，10名员工进入公司之后，需要指派员工在那个部门工作 员工信息有: 姓名 工资组成；...分组后，将员工部门编号作为key，具体员工作为value，放入到multimap容器中 分部门显示员工信息
C++中vector和map的删除方法(推荐)
01-01
1.连续内存序列容器(vector,string,deque) 序列容器的erase方法返回值是指向紧接在被删除元素之后的元素...2.关联容器(set,multiset,map,multimap) 关联容器的erase方法没有返回值，被删除的迭代器失效，所以删除前必须
C++中map容器的说明和使用技巧
08-13
C++中map容器提供一个键值对容器，map与multimap差别仅仅在于multiple允许一个键对应多个值。
【C++】map & multimap
Captain_ldx的博客
11-21 187
map介绍，map使用（代码示例）；multimap介绍，multimap使用（代码示例）；
【C++ 十八】C++ map/ multimap容器
qq_45138120的博客
04-21 1177
本文包含map基本概念、map构造和赋值、map大小和交换、map插入和删除、map查找和统计、map容器排序。
[C/C++] multimap查找一个key对应的多个value
weixin_30765577的博客
05-12 1130
在multimap中，同一个键关联的元素必然相邻存放。基于这个事实，就可以将某个键对应的值一一输出。 1、使用find和count函数。count函数求出某个键出现的次数，find函数返回一个迭代器，指向第一个拥有正在查找的键的实例。 2、使用lower_bound(key)和upper_bound(key) lower_bound(key)返回一个迭代器，指向键不小于...
std::multimap和std::map的区别
05-25
`std::map` 和 `std::multimap` 都是 C++ STL 中的关联容器，它们都提供了键值对的存储和查找操作，但是它们之间有一些区别。 1. 键值唯一性：`std::map` 中每个键只能对应一个值，而 `std::multimap` 中每个键可以对应多个值。 2. 插入操作：当使用 `std::map` 进行插入时，如果该容器中已经存在相同的键值，则插入操作不会成功；而 `std::multimap` 则可以插入相同的键值。 3. 查找操作：`std::map` 中的查找操作会返回一个迭代器，指向该键所对应的唯一值，而 `std::multimap` 中的查找操作会返回一个指向该键所对应的值范围的迭代器，这个范围可能包含多个值。 4. 内部实现：`std::map` 使用红黑树（一种自平衡二叉搜索树）来实现，而 `std::multimap` 通常使用红黑树或者散列表来实现。 因此，如果需要存储键值对且每个键只需要对应一个值，那么使用 `std::map` 是比较合适的选择；如果需要允许相同的键对应多个值，则使用 `std::multimap` 更为适合。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lion Long

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值