<think>我们正在讨论C++中的hash_
map，但需要注意的是，在C++标准库中，哈希映射容器的标准名称是`unordered_
map`（在C++11及以后版本中）。`hash_
map`通常是非标准实现（如某些编译器扩展）中的名称，但为了遵循标准，我们使用`unordered_
map`。下面我将介绍`unordered_
map`的
常用操作方法。
### 1. 包含头文件和声明
首先，需要包含头文件`<unordered_
map>`，并声明一个`unordered_
map`对象，指定键和值的类型。
```cpp
#include <unordered_
map>
#include <string>
int main() {
// 声明一个键为string，值为int的unordered_
map
std::unordered_
map<std::string, int> my
Map;
}
```
### 2.
插入元素
插入元素有多种方法：
- 使用`insert`函数：可以
插入一个键值对（`std::pair`）或使用初始化列表（在初始化时）。
- 使用`operator[]`：如果键
不存在，会
插入该键，并将值初始化为默认值（例如int为0），然后可以赋值。
- 使用`emplace`：直接构造元素，避免
不必要的复制。
```cpp
// 使用insert
插入单个元素
my
Map.insert(std::make_pair("apple", 5));
my
Map.insert({"banana", 3}); // C++11及以上
// 使用operator[]
插入或修改
my
Map["orange"] = 8; // 如果"orange"
不存在，则
插入；存在则修改值
// 使用emplace直接构造元素
my
Map.emplace("grape", 10); // 直接在容器内构造键值对
```
### 3. 访问元素
- 使用`operator[]`：通过键访问值。如果键
不存在，会
插入该键并初始化值（默认构造）。因此，如果你
不希望
插入新元素，应谨慎使用。
- 使用`at`函数：通过键访问值，如果键
不存在，会抛出`std::out_of_range`异常。
- 使用`find`函数：查找指定键，返回一个迭代器。如果找到，迭代器指向该键值对；否则，返回`end()`迭代器。
```cpp
// 使用operator[]访问
int appleCount = my
Map["apple"]; // 存在则返回，
不存在则
插入
// 使用at访问（安全访问）
try {
int orangeCount = my
Map.at("orange");
} catch (const std::out_of_range& e) {
// 处理键
不存在的情况
}
// 使用find查找
auto it = my
Map.find("banana");
if (it != my
Map.end()) {
// 找到元素，it->first是键，it->second是值
int bananaCount = it->second;
} else {
// 未找到
}
```
### 4. 删除元素
- 使用`erase`函数：可以按键删除，也可以按迭代器删除。
```cpp
// 按键删除
my
Map.erase("apple"); // 如果键存在，则删除；
不存在则无
操作
// 按迭代器删除
auto it = my
Map.find("banana");
if (it != my
Map.end()) {
my
Map.erase(it);
}
```
### 5. 遍历元素
使用迭代器遍历所有元素：
```cpp
for (auto it = my
Map.begin(); it != my
Map.end(); ++it) {
std::cout << it->first << ": " << it->second << std::endl;
}
// 或者使用C++11范围for循环
for (const auto& kv : my
Map) {
std::cout << kv.first << ": " << kv.second << std::endl;
}
```
### 6. 其他
常用操作
- `size()`：返回元素个数。
- `empty()`：判断是否为空。
- `clear()`：清空所有元素。
- `count(key)`：返回键为key的元素个数（对于unordered_
map，只能是0或1）。
```cpp
if (!my
Map.empty()) {
std::cout << "元素个数: " << my
Map.size() << std::endl;
my
Map.clear(); // 清空
}
```
### 7. 哈希特性和冲突处理
`unordered_
map`使用哈希表，因此其性能依赖于哈希函数和冲突处理。我们可以自定义哈希函数和相等比较函数（如果需要）。默认情况下，对于常见类型（如int, string等）已经有内置的哈希函数。
### 示例：自定义类型作为键
如果你想使用自定义类型作为键，需要提供哈希函数和相等比较函数。例如：
```cpp
struct MyKey {
int id;
std::string name;
};
// 自定义哈希函数
struct MyKeyHash {
std::size_t operator()(const MyKey& k) const {
return std::hash<int>()(k.id) ^ (std::hash<std::string>()(k.name) << 1);
}
};
// 自定义相等比较
struct MyKeyEqual {
bool operator()(const MyKey& lhs, const MyKey& rhs) const {
return lhs.id == rhs.id && lhs.name == rhs.name;
}
};
// 使用自定义哈希和相等比较的unordered_
map
std::unordered_
map<MyKey, int, MyKeyHash, MyKeyEqual> myCustom
Map;
```
### 性能特点
- 平均时间复杂度：
插入、删除、查找
操作的平均时间复杂度为$O(1)$。
- 最坏情况：当哈希冲突严重时，时间复杂度可能退化到$O(n)$（n为元素数量）。因此，选择一个好的哈希函数很重要。
§§相关问题§§
1. `unordered_
map`和`
map`（基于红黑树）的主要区别是什么？
2. 如何优化`unordered_
map`的性能以减少哈希冲突？
3. `unordered_
map`在内存管理方面有什么特点？如何减少其内存占用？
4. 在多线程环境下使用`unordered_
map`需要注意什么？</think>### C++ `unordered_
map`
常用操作指南
`unordered_
map` 是 C++ 标准库中的哈希表实现（C++11 引入），用于高效存储键值对（key-value pairs）。它提供平均 $O(1)$ 时间复杂度的查找、
插入和删除
操作。以下是
常用操作详解：
---
#### **1. 基础声明与初始化**
```cpp
#include <unordered_
map>
#include <string>
// 声明（键类型为string，值类型为int）
std::unordered_
map<std::string, int> my
Map;
// 初始化（C++11及以上）
std::unordered_
map<std::string, int> fruit
Map = {
{"apple", 5},
{"banana", 3},
{"orange", 8}
};
```
---
#### **2.
插入元素**
```cpp
// 方法1: insert()
fruit
Map.insert({"grape", 12}); //
插入键值对
fruit
Map.insert(std::make_pair("pear", 4));
// 方法2: operator[]
fruit
Map["mango"] = 7; //
不存在则
插入，存在则覆盖
// 方法3: emplace()（高效构造）
fruit
Map.emplace("kiwi", 9); // 直接构造键值对，避免复制
```
---
#### **3. 访问与查找元素**
```cpp
// 通过键访问（
不存在时自动
插入并初始化）
int appleCount = fruit
Map["apple"]; // 返回5
// 安全访问（避免自动
插入）
auto it = fruit
Map.find("banana");
if (it != fruit
Map.end()) {
int bananaCount = it->second; // it->first为键，it->second为值
}
// 检查键是否存在
if (fruit
Map.contains("orange")) { // C++20引入
// ...
}
```
---
#### **4. 删除元素**
```cpp
// 按键删除
fruit
Map.erase("apple"); // 删除键为"apple"的元素
// 按迭代器删除
auto pos = fruit
Map.find("banana");
if (pos != fruit
Map.end()) {
fruit
Map.erase(pos);
}
// 清空所有元素
fruit
Map.clear();
```
---
#### **5. 遍历元素**
```cpp
// 方法1: 迭代器
for (auto it = fruit
Map.begin(); it != fruit
Map.end(); ++it) {
std::cout << it->first << ": " << it->second << std::endl;
}
// 方法2: 范围for循环（推荐）
for (const auto& pair : fruit
Map) {
std::cout << pair.first << ": " << pair.second << std::endl;
}
```
---
#### **6. 容量与状态查询**
```cpp
if (fruit
Map.empty()) {
std::cout << "
map为空！";
}
std::cout << "元素数量: " << fruit
Map.size(); // 返回键值对数量
std::cout << "桶数量: " << fruit
Map.bucket_count(); // 哈希桶数量
```
---
#### **7. 性能优化技巧**
1. **预分配桶数量**
减少动态扩容开销：
```cpp
std::unordered_
map<std::string, int> large
Map;
large
Map.reserve(1000); // 预分配1000个元素的桶空间
```
2. **自定义哈希函数**（针对自定义类型键）
```cpp
struct Point { int x, y; };
struct PointHash {
size_t operator()(const Point& p) const {
return std::hash<int>()(p.x) ^ std::hash<int>()(p.y);
}
};
std::unordered_
map<Point, int, PointHash> point
Map;
```
---
#### **8. 与`
map`的核心区别**
| 特性 | `unordered_
map` | `
map` |
|--------------------|----------------------|---------------------|
| **底层实现** | 哈希表 | 红黑树 |
| **查找时间复杂度** | 平均 $O(1)$，最坏 $O(n)$ | 稳定 $O(\log n)$ |
| **元素顺序** | 无序 | 按键排序 |
| **适用场景** | 需快速查找/
插入 | 需有序遍历或范围查询 |
> 💡 **提示**：若需高频查找且
不关心顺序，优先选择 `unordered_
map`；若需有序遍历或范围查询（如连续键值），使用 `
map`[^1][^2]。
---
本文介绍了Python中map数据结构的set、get、values、keys和entries方法，以及size属性的用法，帮助读者掌握如何高效操作和遍历映射数据类型。
扫一扫
224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
