【C++11 之新增容器 array、foward_list、tuple、unordered_(multi)map/set】应知应会

C++11 标准中新增了多个容器，这些容器为 C++ 程序员提供了更多的选择，以满足不同的编程需求。以下是对这些新容器的介绍和使用案例：

std::array

介绍：

1. std::array 是一个固定大小的数组容器，它在栈上分配内存，并提供了类似于标准库容器的接口。
2. 它提供了更好的类型安全性和范围检查，同时保持了与原生数组相似的性能。
3. std::array 的大小必须在编译时确定，并且不能更改。

使用案例：

#include <iostream>  
#include <array>  
  
int main() {  
    std::array<int, 5> arr = {1, 2, 3, 4, 5};  
    for (int i = 0; i < arr.size(); ++i) {  
        std::cout << arr[i] << " ";  
    }  
    return 0;  
}

std::forward_list

介绍：

1. std::forward_list 是一个单向链表容器，它提供了高效的插入操作（在链表头部插入元素为常数时间）。
2. 与 std::list 相比，它只支持前向迭代，不支持双向迭代，因此其空间效率更高。

使用案例：

#include <iostream>  
#include <forward_list>  
  
int main() {  
    std::forward_list<int> flst = {1, 2, 3, 4, 5};  
    for (const auto& elem : flst) {  
        std::cout << elem << " ";  
    }  
    return 0;  
}

std::unordered_map 和 std::unordered_set

介绍：

1. std::unordered_map 和 std::unordered_set 是无序的关联容器，它们使用哈希表实现，提供了基于键的常数时间复杂度的查找、插入和删除操作。
2. 与 std::map 和 std::set 相比，它们不保证元素的顺序，但通常具有更好的性能。

使用案例（以 std::unordered_map 为例）：

#include <iostream>  
#include <unordered_map>  
  
int main() {  
    std::unordered_map<std::string, int> umap = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};  
    for (const auto& pair : umap) {  
        std::cout << pair.first << ": " << pair.second << std::endl;  
    }  
    return 0;  
}

std::tuple

介绍：

1. std::tuple 是一个可以包含任意类型元素的固定大小的容器。
2. 它类似于结构体，但可以在运行时构造和访问其元素。

使用案例：

#include <iostream>  
#include <tuple>  
  
int main() {  
    std::tuple<int, std::string, double> t(1, "hello", 3.14);  
    std::cout << std::get<0>(t) << ", " << std::get<1>(t) << ", " << std::get<2>(t) << std::endl;  
    return 0;  
}

unordered_multimap

介绍

unordered_multimap是C++标准库中的一种无序关联容器，用于存储具有重复键的键值对集合。其主要特点如下：

1. 无序性：容器中的元素没有特定的顺序，与插入的顺序无关。
2. 哈希表实现：内部使用哈希表作为数据结构，使得查找、插入和删除操作在平均情况下具有常数时间复杂度。
3. 允许重复键：不同于unordered_map，unordered_multimap允许存储具有相同键的多个键值对。
4. 自定义键类型：支持使用自定义类型作为键，但需要提供自定义的哈希函数和相等比较函数。

unordered_multimap使用案例

#include <iostream>  
#include <unordered_map>  
#include <string>  
  
int main() {  
    // 1. 创建unordered_multimap对象  
    std::unordered_multimap<std::string, int> my_multimap;  
  
    // 2. 插入元素  
    my_multimap.insert({"apple", 1});  
    my_multimap.insert({"banana", 2});  
    my_multimap.insert({"apple", 3}); // 允许重复键  
  
    // 3. 查找元素  
    for (const auto& pair : my_multimap) {  
        std::cout << pair.first << ": " << pair.second << std::endl;  
    }  
  
    // 4. 查找特定键的所有值  
    auto range = my_multimap.equal_range("apple");  
    for (auto it = range.first; it != range.second; ++it) {  
        std::cout << "apple: " << it->second << std::endl;  
    }  
  
    // 5. 删除元素  
    // 删除一个键值对（如果有多个，只删除一个）  
    my_multimap.erase(my_multimap.find("banana"));  
  
    // 删除所有具有特定键的键值对  
    for (auto it = range.first; it != range.second;) {  
        it = my_multimap.erase(it);  
    }  
  
    return 0;  
}

unordered_multiset

介绍

unordered_multiset是C++标准库中的一种无序关联容器，用于存储可以重复的元素集合。其主要特点与unordered_multimap类似，但仅存储元素，不存储键值对。

unordered_multiset使用案例

#include <iostream>  
#include <unordered_set>  
  
int main() {  
    // 1. 创建unordered_multiset对象  
    std::unordered_multiset<int> my_multiset;  
  
    // 2. 插入元素（允许重复）  
    my_multiset.insert(1);  
    my_multiset.insert(2);  
    my_multiset.insert(1); // 允许重复元素  
  
    // 3. 遍历元素  
    for (const auto& elem : my_multiset) {  
        std::cout << elem << " ";  
    }  
    std::cout << std::endl;  
  
    // 4. 删除元素（如果有多个，只删除一个）  
    my_multiset.erase(my_multiset.find(1));  
  
    // 5. 再次遍历元素  
    for (const auto& elem : my_multiset) {  
        std::cout << elem << " ";  
    }  
    std::cout << std::endl;  
  
    return 0;  
}

这两个容器都提供了高效的查找、插入和删除操作，适用于需要快速处理大量数据的场景。

这些新容器为 C++ 提供了更多的灵活性和性能优化选项，使得开发者能够更加高效地处理数据。