文章目录
1. unordered_map的介绍
（1）unordered_map是存储<key, value>键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。
（2）在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
（3）在内部,unordered_map没有对<kye, value>按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
（4）unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。
（5）unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问value。
（6）它的迭代器至少是前向迭代器。
unordered_map和map的区别：
（1）底层实现：map内部使用红黑树（一种自平衡二叉查找树）来实现，而unordered_map则使用哈希表来实现。因此，在map中，元素是按照键的大小进行有序排列的，而在unordered_map中，则不保证元素的顺序。
（2）性能表现：当需要有序地遍历元素时，map的性能比unordered_map更好。 但是，当需要快速查找特定的元素时，unordered_map通常比map更快。原因在于，map在插入和删除操作时需要维护红黑树的平衡，而unordered_map则只需要计算哈希值并将元素放入相应的桶中即可。
（3）用途：由于map可以保证元素的有序性，所以适合用于需要有序的情况下，例如按照键排序输出元素、寻找最小值/最大值等。而unordered_map则适合用于需要快速查找元素的情况下，例如查找是否存在某个键值对、统计某个值出现的次数等。
2. unordered_map的使用
2.1unordered_map的构造函数
以下是几个unordered_map构造函数的例子：
（1）默认构造函数：
unordered_map<int, string> mymap;
（2）使用n个元素构造unordered_map：
unordered_map<int, string> mymap = {{1, "one"}, {2, "two"}, {3, "three"}};
（3）使用给定的范围构造unordered_map：
vector<pair<int, string>> myVector = {{1, "one"}, {2, "two"}, {3, "three"}};
unordered_map<int, string> mymap(myVector.begin(), myVector.end());
（4）使用给定的哈希函数和相等比较函数构造unordered_map：
struct myHashFunction {
size_t operator()(const int& key) const {
return hash<int>()(key);
}
};
struct myEqualFunction {
bool operator()(const int& key1, const int& key2) const {
return key1 == key2;
}
};
unordered_map<int, string, myHashFunction, myEqualFunction> mymap;
2.2unordered_map的迭代器
| 函数声明 | 功能介绍 |
|---|---|
| begin | 返回unordered_map第一个元素的迭代器 |
| end | 返回unordered_map最后一个元素下一个位置的迭代器 |
| cbegin | 返回unordered_map第一个元素的const迭代器 |
| cend | 返回unordered_map最后一个元素下一个位置的const迭代器 |
以下是使用unordered_map迭代器的示例：
（1）使用迭代器遍历unordered_map，从begin()到end()。在循环中，使用it->first和it->second分别访问键和值。
#include <iostream>
#include <unordered_map>
int main() {
std::unordered_map<int, std::string> mymap = {{1, "one"}, {2, "two"}, {3, "three"}};
// 使用迭代器遍历unordered_map
for (auto it = mymap.begin(); it != mymap.end(); ++it) {
std::cout << "Key: " << it->first << ", Value: " << it->second << std::endl;
}
return 0;
}
//Key: 1, Value: one
//Key: 2, Value: two
//Key: 3, Value: three
（2）使用范围for循环遍历unordered_map，这种方式更加简洁。使用const auto& pair来捕获每个键值对，并使用pair.first和pair.second分别访问键和值。
#include <iostream>
#include <unordered_map>
int main() {
std::unordered_map<int, std::string> mymap = {{1, "one"}, {2, "two"}, {3, "three"}};
// 使用范围for循环遍历unordered_map
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
2.3unordered_map的容量和访问函数
| 函数声明 | 功能介绍 |
|---|---|
| bool empty() const | 检测unordered_map是否为空 |
| size_t size() const | 获取unordered_map的有效元素个数 |
| operator[] | 返回与key对应的value，没有一个默认值 |
下面是unordered_map中容量和访问函数的示例：
（1）empty() 函数用于检查 unordered_map 是否为空，即是否不包含任何键值对。如果 unordered_map 为空，则返回 true；否则返回 false。
#include <iostream>
#include <unordered_map>
int main() {
std::unordered_map<int, std::string> myMap;
if (myMap.empty()) {
std::cout << "myMap is empty" << std::endl;
} else {
std::cout << "myMap is not empty" << std::endl;
}
myMap = {{1, "one"}, {2, "two"}, {3, "three"}};
if (myMap.empty()) {
std::cout << "myMap is empty" << std::endl;
} else {
std::cout << "myMap is not empty" << std::endl;
}
return 0;
}
//myMap is empty
//myMap is not empty
（2）size() 函数返回 unordered_map 中存储的键值对的数量。
#include <iostream>
#include <unordered_map>
int main() {
std::unordered_map<int, std::string> myMap = {{1, "one"}, {2, "two"}, {3, "three"}};
std::cout << "Size of myMap: " << myMap.size() << std::endl;
return 0;
}
//Size of myMap: 3
（3）operator[] 用于访问或修改指定键的值。如果键不存在，则会插入一个新的键值对，其中键为指定的键，值为该类型的默认值。
#include <iostream>
#include <unordered_map>
int main() {
std::unordered_map<std::string, int> my_map;
// 使用operator[]插入键值对
my_map["apple"] = 1;
my_map["banana"] = 2;
// 使用operator[]访问键值对
std::cout << "Apple: " << my_map["apple"] << std::endl;
std::cout << "Banana: " << my_map["banana"] << std::endl;
// 如果键不存在，operator[]将插入新的键值对，并赋予默认值
std::cout << "Orange: " << my_map["orange"] << std::endl;
return 0;
}
//Apple: 1
//Banana: 2
//Orange: 0
2.4unordered_map的增删查改函数
| 函数声明 | 功能介绍 |
|---|---|
| iterator find(const K& key) | 返回key在哈希桶中的位置 |
| size_t count(const K& key) | 返回哈希桶中关键码为key的键值对的个数 |
| insert | 向容器中插入键值对 |
| erase | 删除容器中的键值对 |
| void clear() | 清空容器中有效元素个数 |
| void swap(unordered_map&) | 交换两个容器中的元素 |
下面是unordered_map中增删查改函数的示例：
（1）find方法用于查找具有指定键的元素。
std::unordered_map<Key, Value> my_map;
// 插入一些元素...
// 使用find方法查找具有指定键的元素
auto it = my_map.find("key");
if (it != my_map.end()) {
// 键存在于unordered_map中
std::cout << "Found key: " << it->first << ", value: " << it->second << std::endl;
} else {
// 键不存在于unordered_map中
std::cout << "Key not found" << std::endl;
}
（2）count方法用于获取具有指定键的元素的数量。
std::unordered_map<Key, Value> my_map;
// 插入一些元素...
// 使用count方法获取具有指定键的元素数量
size_t count = my_map.count("key");
if (count > 0) {
std::cout << "Key found" << std::endl;
} else {
std::cout << "Key not found" << std::endl;
}
（3）insert方法用于插入元素。
std::unordered_map<Key, Value> my_map;
// 使用insert方法插入元素
std::pair<std::unordered_map<Key, Value>::iterator, bool> result = my_map.insert({"key", "value"});
if (result.second) {
// 插入成功
std::cout << "Inserted key: " << result.first->first << ", value: " << result.first->second << std::endl;
} else {
// 插入失败（键已存在）
std::cout << "Key already exists" << std::endl;
}
//Inserted key: key, value: value
（4）erase方法用于删除元素。
std::unordered_map<Key, Value> my_map;
// 插入一些元素...
// 使用erase方法删除具有指定键的元素
auto it = my_map.find("key");
if (it != my_map.end()) {
my_map.erase(it);
std::cout << "Erased key: " << it->first << std::endl;
} else {
std::cout << "Key not found" << std::endl;
}
//Erased key: key
（5）clear方法用于删除所有元素。
std::unordered_map<Key, Value> my_map;
// 插入一些元素...
// 使用clear方法删除所有元素
my_map.clear();
if (my_map.empty()) {
std::cout << "Map is empty" << std::endl;
} else {
std::cout << "Map is not empty" << std::endl;
}
//Map is empty
（6）swap方法用于交换两个unordered_map对象的内容。
std::unordered_map<Key, Value> my_map1;
// 插入一些元素到my_map1...
std::unordered_map<Key, Value> my_map2;
// 插入一些元素到my_map2...
// 使用swap方法交换my_map1和my_map2的内容
my_map1.swap(my_map2);
// 现在my_map1包含my_map2以前的元素，反之亦然
