Let’s Make C++ Great Again——map与unordered_map

map

在 C++ 中，map 是一种关联式容器，它提供了一种将键映射到值的方法。map 中的每个元素都是一个键值对，其中键是唯一的，值可以重复。map 是按照键的大小进行排序的，因此可以按照键的顺序遍历容器。

以下是 map 的基本用法：

头文件

要使用 map，首先需要包含头文件

#include <map>

定义和插入元素

定义 map 很简单，可以使用以下语法：

map<key_type, value_type> my_map;

其中，key_type 是键的类型，value_type 是值的类型。例如，定义一个键为字符串，值为整数的 map：

map<string, int> my_map;

可以使用 [] 运算符向 map 中插入元素：

my_map["apple"] = 3;
my_map["banana"] = 2;
my_map["orange"] = 4;

也可以使用 insert() 函数插入元素：

my_map.insert(pair<string, int>("apple", 3));
my_map.insert(make_pair("banana", 2));
my_map.insert(map<string, int>::value_type("orange", 4));

访问元素

可以使用 [] 运算符访问元素：

int n = my_map["apple"];  // n = 3

如果指定的键不存在，则会自动插入一个默认值：

int m = my_map["pear"];  // m = 0，因为默认值为 0

也可以使用 at() 函数访问元素，如果指定的键不存在，则会抛出 out_of_range 异常：

int n = my_map.at("apple");  // n = 3
int m = my_map.at("pear");   // 抛出 out_of_range 异常

遍历元素

可以使用 for 循环遍历 map 中的元素：

for (auto it = my_map.begin(); it != my_map.end(); ++it) {
    cout << it->first << ": " << it->second << endl;
}

也可以使用范围循环遍历元素：

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

查找元素

可以使用 find() 函数查找指定键的元素，如果找到，则返回指向该元素的迭代器；如果未找到，则返回 end() 迭代器：

auto it = my_map.find("apple");
if (it != my_map.end()) {
    int n = it->second;
}

删除元素

可以使用 erase() 函数删除指定键的元素：

my_map.erase("apple");

也可以使用迭代器删除元素：

auto it = my_map.find("apple");
if (it != my_map.end()) {
    my_map.erase(it);
}

以上是 map 的基本用法，还有一些其他的函数和用法可以根据实际需要选择使用。

以下是一些常用的函数和用法

size()

可以使用 size() 函数获取 map 中元素的数量：

int n = my_map.size();
count()

可以使用 count() 函数查找指定键的元素数量，如果存在，则返回 1；如果不存在，则返回 0：

int n = my_map.count("apple");

empty()

可以使用 empty() 函数判断 map 是否为空：

if (my_map.empty()) {
    cout << "map is empty" << endl;
}

clear()

可以使用 clear() 函数清空 map 中的所有元素：

my_map.clear();
equal_range()

可以使用 equal_range() 函数查找指定键的元素范围，返回一个 pair，其中 first 是指向第一个匹配元素的迭代器，second 是指向最后一个匹配元素的下一个位置的迭代器。如果未找到，则返回一个空的范围：

auto range = my_map.equal_range("apple");
for (auto it = range.first; it != range.second; ++it) {
    int n = it->second;
}

自定义比较函数

默认情况下，map 使用 < 运算符进行键的比较。如果需要自定义比较函数，可以使用 template 关键字和 less 函数对象：

template <typename T>
struct MyLess {
    bool operator()(const T& a, const T& b) const {
        // 自定义比较函数的实现
    }
};

map<int, string, MyLess<int>> my_map;

以上是 map 的一些常用函数和用法，可以根据实际需要选择使用。

unordered_map

unordered_map 是 C++ STL 中的关联式容器之一，它提供了一种将键映射到值的方法，与 map 不同的是，它不对键进行排序。unordered_map 的实现使用哈希表，因此查找元素的时间复杂度为常数级别。

以下是 unordered_map 的基本用法：

头文件

要使用 unordered_map，首先需要包含头文件 <unordered_map>：

#include <unordered_map>

定义和插入元素

定义 unordered_map 很简单，可以使用以下语法：

unordered_map<key_type, value_type> my_map;

其中，key_type 是键的类型，value_type 是值的类型。例如，定义一个键为字符串，值为整数的 unordered_map：

unordered_map<string, int> my_map;

可以使用 [] 运算符或 insert() 函数向 unordered_map 中插入元素：

my_map["apple"] = 3;
my_map["banana"] = 2;
my_map["orange"] = 4;

my_map.insert(pair<string, int>("apple", 3));
my_map.insert(make_pair("banana", 2));
my_map.insert(unordered_map<string, int>::value_type("orange", 4));

访问元素

可以使用 [] 运算符或 at() 函数访问元素，用法和 map 相同：

int n = my_map["apple"];  // n = 3
int m = my_map.at("apple");  // m = 3

遍历元素

可以使用 for 循环遍历 unordered_map 中的元素，用法和 map 相同：

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

查找元素

可以使用 find() 函数查找指定键的元素，用法和 map 相同：

auto it = my_map.find("apple");
if (it != my_map.end()) {
    int n = it->second;
}

删除元素

可以使用 erase() 函数删除指定键的元素，用法和 map 相同：

my_map.erase("apple");

auto it = my_map.find("apple");
if (it != my_map.end()) {
    my_map.erase(it);
}

以下是一些常用的函数和用法：

size()

可以使用 size() 函数获取 unordered_map 中元素的数量：

int n = my_map.size();

count()

可以使用 count() 函数查找指定键的元素数量，如果存在，则返回 1；如果不存在，则返回 0：

int n = my_map.count("apple");

empty()

可以使用 empty() 函数判断 unordered_map 是否为空：

if (my_map.empty()) {
    cout << "unordered_map is empty" << endl;
}

clear()

可以使用 clear() 函数清空 unordered_map 中的所有元素：

my_map.clear();

自定义哈希函数

默认情况下，unordered_map 使用 std::hash 进行哈希函数的计算。如果需要自定义哈希函数，可以定义一个 struct 类型，并重载括号运算符 ()：

struct MyHash {
    size_t operator()(const MyKey& key) const {
        // 自定义哈希函数的实现
    }
};

unordered_map<MyKey, MyValue, MyHash> my_map;

其中，MyKey 是键的类型，MyValue 是值的类型。MyHash 是自定义哈希函数的类型。

自定义键比较函数

默认情况下，unordered_map 使用 std::equal_to 进行键的比较。如果需要自定义键比较函数，可以定义一个 struct 类型，并重载括号运算符 ()：

struct MyEqual {
    bool operator()(const MyKey& lhs, const MyKey& rhs) const {
        // 自定义键比较函数的实现
    }
};

unordered_map<MyKey, MyValue, MyHash, MyEqual> my_map;

其中，MyKey 是键的类型，MyValue 是值的类型。MyHash 是自定义哈希函数的类型，MyEqual 是自定义键比较函数的类型。

以上是 unordered_map 的一些常用函数和用法，可以根据实际需要选择使用。