【C++】STL—— unordered_map的介绍和使用、 unordered_map的构造函数和迭代器、 unordered_map的增删查改函数

1. unordered_map的介绍

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;
1

             

  （2）使用n个元素构造unordered_map：

unordered_map<int, string> mymap = {{1, "one"}, {2, "two"}, {3, "three"}};
1

             

  （3）使用给定的范围构造unordered_map：

vector<pair<int, string>> myVector = {{1, "one"}, {2, "two"}, {3, "three"}};  
unordered_map<int, string> mymap(myVector.begin(), myVector.end());
1
2

             

  （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;
1
2
3
4
5
6
7
8
9
10
11
12
13

             

2.2unordered_map的迭代器

             

             

  以下是使用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  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

             

  （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  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

             

2.3unordered_map的容量和访问函数

             

下面是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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

             

  （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
1
2
3
4
5
6
7
8
9
10
11
12

             

  （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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

             

2.4unordered_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;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13

             

  （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;  
}
1
2
3
4
5
6
7
8
9
10
11

             

  （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
1
2
3
4
5
6
7
8
9
10
11
12
13
14

             

  （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
1
2
3
4
5
6
7
8
9
10
11
12
13

             

  （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
1
2
3
4
5
6
7
8
9
10
11
12
13

             

  （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以前的元素，反之亦然
1
2
3
4
5
6
7
8
9
10