C++ 中 std::map 的实用操作指南_c++ std::map

在 C++ 中，`map` 是一种基于键值对的容器，其中的数据总是以成对形式出现。如所示，每一对中的第一个元素是关键字（key），这些关键字在 `map` 中具有唯一性，即每个关键字只能出现一次；第二个元素是与该关键字相对应的值（value）。这种结构使得 `map` 成为管理具有明确关联关系的数据的理想选择。

 一. 声明

在下面的 C++ 代码片段中，我们首先包含了 map 容器所需的头文件 map，然后声明了两个 map 类型的变量：ID_Name。这些 map 存储的是基于 int 类型的关键字和 string 类型的值。

// 包含 map 容器的头文件
#include <map>
#include <string> // 确保 string 类型被正确引入
 
// 声明 map 容器，存储整数 ID 和对应的名称
std::map<int, std::string> ID_Name;
 
// 使用列表初始化（自 C++11 起支持）来初始化 map
// 注意：这需要 C++11 或更高版本的编译器支持
std::map<int, std::string> ID_Name = {
    { 2015, "Jim" },
    { 2016, "Tom" },
    { 2017, "Bob" }
};

代码注释解释：

• #include <map>：包含标准库中的 map 容器，它允许我们创建和操作键值对集合。
• #include <string>：包含字符串类型，确保 string 类型可以在 map 中使用。
• 第一个 map 初始化示例没有在声明时提供任何初始值。
• 第二个 map 使用了 C++11 引入的列表初始化语法 {} 来直接在声明时初始化 map。这种初始化方式允许我们在声明 map 变量的同时，明确指定其包含的键值对。

注意：

• 列表初始化语法 {} 是从 C++11 开始支持的。因此，如果你使用的是 C++11 之前的编译器版本（例如 Visual Studio 2012 或更早版本），这种初始化方式将导致编译错误。确保你的开发环境支持 C++11 或更高版本，以便使用这种便捷的初始化方式。

二. 插入操作

2.1 使用 [ ] 进行单个插入

        在 C++ 中，使用 map 容器的 [] 操作符可以便捷地进行插入或修改操作。例如：

#include <map>
#include <string>
 
std::map<int, std::string> ID_Name;
 
// 使用[]操作符进行插入或修改
// 如果键2015已存在，此操作将修改其对应的值为"Tom"
// 如果键2015不存在，将创建一个新键值对(2015, "Tom")
ID_Name[2015] = "Tom";

2.2 使用 insert 进行单个和多个插入

   std::map 提供了几种重载的 insert 方法，用于插入单个或多个元素：

#include <map>
#include <string>
#include <iterator>
 
std::map<int, std::string> ID_Name;
 
// 插入单个键值对，并返回一个包含迭代器和成功标志的pair
// 如果插入的键已存在，插入操作将失败，返回的pair中的bool为false
auto result = ID_Name.insert(std::make_pair(2015, "Tom"));
if (result.second) {
    std::cout << "Insert successful" << std::endl;
} else {
    std::cout << "Key already exists" << std::endl;
}
 
// 在指定位置尝试插入，虽然位置提示可能提高效率，但插入位置不保证成功
auto pos = ID_Name.begin();
ID_Name.insert(pos, std::make_pair(2016, "Jim")); // 提示插入位置
 
// 插入多个键值对（假设first和last是合法的迭代器）
// ID_Name.insert(first, last);
 
// C++11起支持使用初始化列表插入多个键值对
ID_Name.insert({ {2017, "Bob"}, {2018, "Alice"} });

代码注释解释：

• 使用 insert 插入单个键值对时，返回类型为 std::pair<std::map<int, std::string>::iterator, bool>。bool 表示插入是否成功（true 表示成功，false 表示键已存在），而迭代器指向被插入或已存在的元素。

• insert 的另一个重载接受一个“提示”位置，这有助于优化插入操作的性能。尽管如此，正确的插入位置仍由 map 决定。

• 插入范围的重载接受一对迭代器，允许从另一个相容容器中批量插入元素。

• 使用初始化列表插入多个键值对是 C++11 引入的功能，它允许直接在 insert 函数中指定一个键值对列表。

下面是具体使用示例：

#include <iostream>
#include <map>
 
int main() {
    std::map<char, int> mymap;
 
    // 插入单个键值对
    mymap.insert(std::pair<char, int>('a', 100));
    mymap.insert(std::pair<char, int>('z', 200));
 
    // 尝试插入已存在的键，并获取操作的结果
    std::pair<std::map<char, int>::iterator, bool> ret;
    ret = mymap.insert(std::pair<char, int>('z', 500));
    if (!ret.second) {
        std::cout << "Element 'z' already existed with a value of " << ret.first->second << '\n';
    }
 
    // 在指定位置插入，尽管位置指定可能帮助提高插入效率，但最终位置仍由 map 控制
    std::map<char, int>::iterator it = mymap.begin();
    mymap.insert(it, std::pair<char, int>('b', 300));  // 提示位置接近正确，有助于提高效率
    mymap.insert(it, std::pair<char, int>('c', 400));  // 提示位置较远，效率提升可能不明显
 
    // 从一个 map 插入另一个 map 的部分数据
    std::map<char, int> anothermap;
    anothermap.insert(mymap.begin(), mymap.find('c')); // 插入从开始到 'c' 之前的元素
 
    // 使用初始化列表批量插入多个键值对
    anothermap.insert({ {'d', 100}, {'e', 200} });
 
    return 0;
}

• 单个插入：通过 insert 方法插入单个键值对。如果尝试插入的键已存在，则 insert 不会修改已有键值对，而是返回一个指向该元素的迭代器和一个表示插入失败的 bool 值 (false).

• 指定位置插入：insert 的这个重载版本接受一个迭代器作为“位置提示”。这个提示可以帮助 map 更高效地插入新元素，尤其是当提示位置接近目标位置时。但请注意，map 总是确保元素的正确排序，因此最终插入位置可能与提示位置不同。

• 范围插入：这种形式的 insert 允许从另一个 map 或同类型容器的一部分进行数据插入。在本例中，我们从 mymap 的开始到找到的 'c' 之前的元素进行插入。

• 列表插入：C++11 引入了初始化列表，您可以使用它来简洁地插入多个键值对。这种方式非常适合在构造时或在需要添加多个元素时使用。

三. 取值操作

在 C++ 的 std::map 容器中，元素的取值主要通过两种方式实现：at() 和操作符 []。两者的主要区别在于对键的存在性的检查。

#include <iostream>
#include <map>
#include <string>
 
int main() {
    std::map<int, std::string> ID_Name;
 
    // 使用[]操作符，如果键2016不存在，会自动创建该键并初始化其值（空字符串）
    // 因此，下面的语句不会报错，但打印出的结果是空字符串
    std::cout << ID_Name[2016] << std::endl;
 
    // 使用at()方法会进行键的存在性检查，如果键不存在则抛出std::out_of_range异常
    try {
        std::string name = ID_Name.at(2016); // 这里会抛出异常
    } catch (const std::out_of_range& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
 
    return 0;
}

四. 容量查询

std::map 提供了几个方法来查询其容量和大小，这些方法有助于了解容器的状态和性能调优。

#include <iostream>
#include <map>
 
int main() {
    std::map<int, std::string> ID_Name;
 
    // 查询 map 是否为空
    bool isEmpty = ID_Name.empty();
    std::cout << "Map is " << (isEmpty ? "empty" : "not empty") << std::endl;
 
    // 查询 map 中键值对的数量
    size_t numElements = ID_Name.size();
    std::cout << "Map size: " << numElements << std::endl;
 
    // 查询 map 所能包含的最大键值对数量
    size_t maxCapacity = ID_Name.max_size();
    std::cout << "Map maximum size: " << maxCapacity << std::endl;
 
    // 查询关键字为 key 的元素的个数，在 map 中结果非 0 即 1
    size_t countKey = ID_Name.count(2016);
    std::cout << "Count for key 2016: " << countKey << std::endl;
 
    return 0;
}

注释解释：

• empty() 返回一个布尔值，表示 map 是否为空。
• size() 返回 map 中存储的键值对的数量。
• max_size() 返回 map 可以存储的最大键值对数量。这个值受限于系统或库的实现，通常非常大，实际可达到的大小取决于系统资源。
• count(const Key& key) 检查特定键在 map 中的存在性，返回 0 或 1，因为 map 的键是唯一的。

五. 迭代器

在 C++ 中，std::map 提供了多种方式来获取迭代器，用以访问或遍历容器中的元素。这里我们将详细解释这些迭代器的获取方式及其用途。

获取迭代器的函数

对于 std::map，有以下几种函数用于获取迭代器：

• 正向迭代器

  • begin() / end(): 这两个函数返回的迭代器分别指向容器中的第一个元素和末尾（末尾即容器最后一个元素的下一个位置，不是最后一个元素）。如果容器是非常量的，这些迭代器允许修改它们所指向的元素的值。
  • cbegin() / cend(): 这对函数总是返回常量迭代器，即使在非常量的 map 上调用也是如此。常量迭代器不允许修改其指向的元素，这主要用于只读访问。

• 反向迭代器

  • rbegin() / rend(): 这是反向迭代器的版本，rbegin() 指向最后一个元素，而 rend() 指向第一个元素之前的位置。它们允许你从后向前遍历 map。
  • crbegin() / crend(): 这对函数返回的是常量反向迭代器，不允许修改指向的元素，适用于只读逆序遍历。

        以下是一个示例代码，展示如何使用这些迭代器：

#include <iostream>
#include <map>
 
int main() {
    std::map<int, int> mmap = {{1, 100}, {2, 200}, {3, 300}};
    const std::map<int, int> const_mmap = mmap;
 
    // 获取迭代器
    auto it = mmap.begin(); // 非常量迭代器，可以修改值
    auto cit = mmap.cbegin(); // 常量迭代器，只读
 
    // 对于常量 map，所有迭代器均为常量迭代器
    auto const_it = const_mmap.begin(); // 常量迭代器，只读
    auto const_cit = const_mmap.cbegin(); // 常量迭代器，只读
 
    // 输出
    std::cout << "First element value using non-const iterator: " << it->second << std::endl;
    std::cout << "First element value using const iterator from non-const map: " << cit->second << std::endl;
    std::cout << "First element value using const iterator from const map: " << const_it->second << std::endl;
 
    return 0;
}

注意事项

• 如果 map 是空的，则 begin() 和 end() 返回的迭代器相等，同样适用于 rbegin() 和 rend()。
• 迭代器操作通常不涉及加减整数值（这是针对连续内存的 vector 等容器的操作），但可以进行递增 (++) 或递减 (--) 来访问相邻元素。

六. 删除和交换

6.1 删除

std::map 提供了几种删除元素的方法：

• 单个元素删除
  • erase(iterator pos): 删除迭代器 pos 指向的元素，并返回指向下一个元素的迭代器。
• 区间删除
  • erase(const_iterator first, const_iterator last): 删除从 first 到 last（不包括 last）的元素，并返回指向下一元素的迭代器。
• 按键删除
  • erase(const key_type& key): 根据键值 key 删除元素。由于 map 中的键值是唯一的，所以这个方法要么删除一个元素，要么一个都不删除（如果键不存在）。返回删除的元素数量，即 0 或 1。
• 清空整个 map
  • clear(): 删除 map 中的所有元素，使其大小变为 0。

#include <iostream>
#include <map>
 
int main() {
    std::map<char, int> mymap;
 
    // 插入一些元素
    mymap['a'] = 10;
    mymap['b'] = 20;
    mymap['c'] = 30;
    mymap['d'] = 40;
 
    // 使用迭代器删除单个元素
    auto it = mymap.find('b');
    if (it != mymap.end()) {
        mymap.erase(it);
    }
 
    // 输出当前 map
    std::cout << "Map after erasing 'b':" << std::endl;
    for (const auto& p : mymap) {
        std::cout << p.first << " => " << p.second << std::endl;
    }
 
    // 使用键值直接删除元素
    mymap.erase('c');
 
    // 输出当前 map
    std::cout << "Map after erasing 'c':" << std::endl;
    for (const auto& p : mymap) {
        std::cout << p.first << " => " << p.second << std::endl;
    }
 
    // 清空整个 map
    mymap.clear();
    std::cout << "Map size after clearing: " << mymap.size() << std::endl;
 
    return 0;
}

6.2 交换

• swap(map& other): 与另一个 map other 交换内容。这通常是一个非常快速的操作，因为只涉及到内部数据结构的指针交换，而不是元素本身的复制。

#include <iostream>
#include <map>
 
int main() {
    std::map<char, int> map1, map2;
 
    // 初始化 map1 和 map2
    map1['x'] = 100;
    map1['y'] = 200;
    map2['a'] = 10;
    map2['b'] = 20;
 
    // 输出原始 map
    std::cout << "Original map1:" << std::endl;
    for (const auto& p : map1) {
        std::cout << p.first << " => " << p.second << std::endl;
    }
 
    std::cout << "Original map2:" << std::endl;
    for (const auto& p : map2) {
        std::cout << p.first << " => " << p.second << std::endl;
    }
 
    // 交换 map1 和 map2
    map1.swap(map2);
 
    // 输出交换后的 map
    std::cout << "Map1 after swap:" << std::endl;
    for (const auto& p : map1) {
        std::cout << p.first << " => " << p.second << std::endl;
    }
 
    std::cout << "Map2 after swap:" << std::endl;
    for (const auto& p : map2) {
        std::cout << p.first << " => " << p.second << std::endl;
    }
 
    return 0;
}

七. 顺序比较

每个 std::map 都有一个内部的比较对象，用于维持键的顺序。你可以通过 key_comp() 方法获取这个比较对象。

• key_comp()
  • 返回一个用于比较键的函数对象。如果第一个参数在顺序上位于第二个参数之前，则此函数对象返回 true。

std::map<char, int> mymap;
auto mycomp = mymap.key_comp();
 
mymap['a'] = 100;
mymap['b'] = 200;
 
bool result = mycomp('a', 'b'); // 返回 true，因为 'a' 在 'b' 前面

八. 查找

std::map 提供了 find() 方法来检索具有特定键的元素：

• find(const key_type& k)
  • 如果找到键 k，则返回一个指向该键的迭代器；如果未找到，则返回一个指向 map 结束 (end()) 的迭代器。

std::map<char, int> mymap;
mymap['a'] = 50;
mymap['b'] = 100;
mymap['c'] = 150;
mymap['d'] = 200;
 
auto it = mymap.find('b');
if (it != mymap.end()) {
    mymap.erase(it); // 删除找到的元素
}

在这个例子中，我们查找键为 'b' 的元素，找到后使用返回的迭代器将其从 map 中删除。

通过这些解释，希望你能更清楚地理解 std::map 中的操作和方法。

九. 操作符

在 C++ 标准库中，std::map 提供了几个比较操作符，用于比较两个 map 对象。这些操作符包括 ==, !=, <, <=, >, >=。这些操作符的行为和含义如下：

等于和不等于操作符 (== 和 !=)

• ==（等于）：当两个 map 的大小相等，并且每一个对应位置上的键值对都相等时，这两个 map 被认为是相等的。这意味着每个键值对的键和值都必须完全一致，并且它们的排列顺序也必须完全一样。由于 std::map 自动根据键进行排序，因此只要键值对相同，顺序自然会相同。
• !=（不等于）：如果两个 map 在大小或至少一个键值对上不相等，则这两个 map 被认为是不相等的。这是 == 的逻辑否定。

关系操作符 (<, <=, >, >=)

• <（小于）：如果第一个 map 在字典顺序上比第二个 map 小，则返回 true。字典顺序是按照键来比较的，首先比较第一个键，如果相同则比较第二个键，依此类推。
• <=（小于等于）：如果第一个 map 小于或等于第二个 map（即第一个 map 是第二个的子集或完全相等），则返回 true。
• >（大于）：如果第一个 map 在字典顺序上大于第二个 map，则返回 true。
• >=（大于等于）：如果第一个 map 大于或等于第二个 map（即第一个 map 包含第二个 map 或完全相等），则返回 true。

这些操作符使得 std::map 可以直接用在条件表达式中，非常适合进行集合比较、排序容器中的元素等操作。

#include <iostream>
#include <map>
 
int main() {
    std::map<int, int> map1 {{1, 100}, {2, 200}};
    std::map<int, int> map2 {{1, 100}, {2, 200}};
    std::map<int, int> map3 {{1, 100}, {3, 300}};
 
    // 检查等于和不等于
    std::cout << "map1 == map2: " << (map1 == map2) << std::endl;
    std::cout << "map1 != map3: " << (map1 != map3) << std::endl;
 
    // 检查其他关系操作符
    std::cout << "map1 < map3: " << (map1 < map3) << std::endl;
    std::cout << "map3 > map1: " << (map3 > map1) << std::endl;
 
    return 0;
}

附录：

字典顺序（Lexicographical order）并不是指元素的大小（size），而是一种用于比较两个序列的方法，它按照元素的顺序逐个比较，直到找到一个不同的元素为止。这种比较方式类似于在字典中查找单词的顺序，因此得名“字典顺序”。在 C++ 中，这种比较方式通常用于字符串、数组、列表以及其他序列型容器。

字典顺序的具体规则：

当比较两个序列（例如两个 std::vector、std::string 或 std::map 中的键序列）时，从两个序列的第一个元素开始比较：

1. 比较元素：比较两个序列的当前元素。
   • 如果第一个序列的当前元素小于第二个序列的当前元素，则第一个序列在字典顺序中被认为是“小于”第二个序列。
   • 如果第一个序列的当前元素大于第二个序列的当前元素，则第一个序列在字典顺序中被认为是“大于”第二个序列。
2. 相同则继续：如果当前元素相等，则比较下一个元素。
3. 长度判别：如果所有对应元素都相等，那么序列的长度将用于决定顺序：
   • 较短的序列在字典顺序中被认为是“小于”较长的序列。

示例

考虑以下字符串的比较：

• 字符串 "apple" 和 "banana"：

  • 比较 'a' (apple) 和 'b' (banana)。由于 'a' < 'b'，"apple" 在字典顺序中小于 "banana"。

• 字符串 "book" 和 "bookcase"：

  • "book" 和 "bookcase" 的前四个字符都相同，但 "book" 较短，因此在字典顺序中 "book" 小于 "bookcase"。

在 std::map 中的应用

当使用 <、<=、> 和 >= 操作符比较两个 std::map 对象时，比较是基于键的字典顺序进行的。std::map 的键会自动保持排序，因此比较两个 map 就是按键的字典顺序来比较的。如果一个 map 的键集合在字典顺序上小于另一个 map 的键集合，那么这个 map 就被认为在字典顺序上是“小于”另一个 map。

这种字典顺序比较为 std::map 和其他容器提供了一种自然而直观的比较方式，使得它们可以直接用于排序和其他比较操作。

参考资料：

        http://blog.csdn.net/shuzfan/article/details/53115922