C++ 容器类 <map>

在 C++ 中，<map> 是标准模板库（STL）的一部分，它提供了一种关联容器，用于存储键值对（key-value pairs）。

map 容器中的元素是按照键的顺序自动排序的，这使得它非常适合需要快速查找和有序数据的场景。

定义和特性

• 键值对：map 存储的是键值对，其中每个键都是唯一的。
• 排序：map 中的元素按照键的顺序自动排序，通常是升序。
• 唯一性：每个键在 map 中只能出现一次。
• 双向迭代器：map 提供了双向迭代器，可以向前和向后遍历元素。

基本语法

包含头文件:

#include <map>

声明 map 容器:

std::map<key_type, value_type> myMap;

• key_type 是键的类型。
• value_type 是值的类型。

插入元素:

myMap[key] = value;

访问元素:

value = myMap[key];

遍历 map:

for (std::map<key_type, value_type>::iterator it = myMap.begin(); it != myMap.end(); ++it) {
    std::cout << it->first << " => " << it->second << std::endl;
}

C++11 及以上标准，遍历部分可以简化为范围 for 循环，代码更简洁：

for (auto &p : m) {
    std::cout << p.first << " : " << p.second << std::endl;
}

实例

下面是一个使用 map 的简单实例，我们将创建一个 map 来存储员工的姓名和他们的年龄，并遍历这个 map 来打印每个员工的姓名和年龄。

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

int main() {
    // 创建一个 map 容器，存储员工的姓名和年龄
    std::map<std::string, int> employees;

    // 插入员工信息
    employees["Alice"] = 30;
    employees["Bob"] = 25;
    employees["Charlie"] = 35;

    // 遍历 map 并打印员工信息
    for (std::map<std::string, int>::iterator it = employees.begin(); it != employees.end(); ++it) {
        std::cout << it->first << " is " << it->second << " years old." << std::endl;
    }

    return 0;
}

输出：

Alice is 30 years old.
Bob is 25 years old.
Charlie is 35 years old.

进阶用法

检查键是否存在:

if (myMap.find(key) != myMap.end()) {
    // 键存在
}

删除元素:

myMap.erase(key);

清空 map:

myMap.clear();

获取 map 的大小:

size_t size = myMap.size();

其他方法：

myMap.empty();      // 是否为空
myMap.count("Bob"); // key 是否存在（返回 0 或 1）

自定义排序，默认升序排序，可以用 std::greater 或自定义比较函数：

std::map<int, std::string, std::greater<int>> m;  // 降序

使用自定义比较函数：

#include <map>
#include <string>
#include <functional>

bool myCompare(const std::string& a, const std::string& b) {
    return a < b;
}

int main() {
    std::map<std::string, int, std::function<bool(const std::string&, const std::string&)>> myMap(myCompare);

    // 其他操作...

    return 0;
}

map 是 C++ STL 中一个非常有用的容器，特别适合需要快速查找和有序数据的场景：

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

int main() {
    std::map<std::string, int> scores;

    // 插入
    scores["Alice"] = 90;
    scores["Bob"] = 85;
    scores.insert({"Charlie", 92});

    // 遍历
    for (auto &p : scores) {
        std::cout << p.first << " => " << p.second << std::endl;
    }

    // 查找
    auto it = scores.find("Bob");
    if (it != scores.end()) {
        std::cout << "Bob's score: " << it->second << std::endl;
    }

    // 删除
    scores.erase("Alice");

    std::cout << "Size: " << scores.size() << std::endl;

    return 0;
}

输出：

Alice => 90
Bob => 85
Charlie => 92
Bob's score: 85
Size: 2

C++ 容器类 <unordered_map>

在 C++ 中，<unordered_map> 是标准模板库（STL）的一部分，提供了一种基于哈希表的键值对容器。

与 std::map 不同，unordered_map 不保证元素的排序，但通常提供更快的查找速度。

unordered_map 是一个关联容器，它存储了键值对（key-value pairs），其中每个键（key）都是唯一的。unordered_map 使用哈希表来存储元素，这使得它在查找、插入和删除操作中具有平均常数时间复杂度。

基本语法

#include <unordered_map>

std::unordered_map<key_type, value_type> map_name;

• key_type 是键的类型。
• value_type 是值的类型。

构造函数

unordered_map 可以以多种方式构造：

// 默认构造
std::unordered_map<int, std::string> myMap;

// 构造并初始化
std::unordered_map<int, std::string> myMap = {{1, "one"}, {2, "two"}};

// 构造并指定初始容量
std::unordered_map<int, std::string> myMap(10);

// 构造并复制另一个 unordered_map
std::unordered_map<int, std::string> anotherMap = myMap;

基本操作

插入元素:

myMap.insert({3, "three"});

访问元素:

std::string value = myMap[1]; // 获取键为1的值

删除元素:

myMap.erase(1); // 删除键为1的元素

查找元素:

auto it = myMap.find(2); // 查找键为2的元素
if (it != myMap.end()) {
    std::cout << "Found: " << it->second << std::endl;
}

实例

下面是一个使用 unordered_map 的简单实例，包括输出结果。

#include <iostream>
#include <unordered_map>

int main() {
    // 创建一个 unordered_map，键为 int，值为 string
    std::unordered_map<int, std::string> myMap;

    // 插入一些键值对
    myMap[1] = "one";
    myMap[2] = "two";
    myMap[3] = "three";

    // 打印所有元素
    for (const auto& pair : myMap) {
        std::cout << "Key: " << pair.first << ", Value: " << pair.second << std::endl;
    }

    // 访问特定键的值
    std::cout << "Value for key 2: " << myMap[2] << std::endl;

    // 删除键为1的元素
    myMap.erase(1);

    // 再次打印所有元素
    std::cout << "After erasing key 1:" << std::endl;
    for (const auto& pair : myMap) {
        std::cout << "Key: " << pair.first << ", Value: " << pair.second << std::endl;
    }

    return 0;
}

输出结果:

Key: 1, Value: one
Key: 2, Value: two
Key: 3, Value: three
Value for key 2: two
After erasing key 1:
Key: 2, Value: two
Key: 3, Value: three

注意事项

• unordered_map 不保证元素的顺序，因此元素的迭代顺序可能在不同的运行中不同。
• 哈希表的性能依赖于良好的哈希函数，以避免过多的哈希冲突。
• 与 std::map 相比，unordered_map 在元素数量较少时可能占用更多的内存