在 C++ 中，有许多常见的容器，每种都有其特定的用途和性能特征。以下是一些常见的容器类型：
1. 数组（Array）：是一组连续存储的相同类型元素的集合。数组的大小在创建时就确定，并且不能动态改变。
2. 向量（Vector）：是一种动态数组，大小可以在运行时动态增长。`std::vector` 提供了对数组的动态访问和管理。
3. 列表（List）：是双向链表的一种实现，允许在任意位置高效地插入和删除元素。与向量不同，列表中的元素在内存中不是连续存储的。
4. 队列（Queue）：是一种先进先出（FIFO）的数据结构，元素的插入和删除操作都发生在队列的两端。`std::queue` 是一个基于其他容器（通常是双端队列）实现的队列。
5. 栈（Stack）：是一种后进先出（LIFO）的数据结构，只允许在栈顶进行插入和删除操作。`std::stack` 是一个基于其他容器（通常是 deque）实现的栈。
6. 集合（Set）：是一种无序的容器，其中的元素唯一且不重复。`std::set` 提供了对集合的操作，如插入、查找和删除等。
7. 映射（Map）：是一种关联容器，存储键值对（key-value pairs）。每个键都是唯一的，而且按照某种规则进行排序。`std::map` 提供了对映射的操作，如插入、查找和删除等。
8. 哈希表（Hash Table）：是一种根据键直接访问值的数据结构，通过哈希函数将键映射到存储桶中。`std::unordered_map` 和 `std::unordered_set` 是基于哈希表实现的关联容器。
这些是 C++ 中的一些常见容器类型，你可以根据具体的需求选择合适的容器来存储和操作数据。

每种容器类型举例说明其用法：

• 数组（Array）：

#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5}; // 创建一个包含5个元素的整数数组
    std::cout << "Array elements:";
    for (int i = 0; i < 5; ++i) {
        std::cout << " " << arr[i];
    }
    std::cout << std::endl;
    return 0;
}

• 向量（Vector）：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5}; // 创建一个包含5个整数的向量
    std::cout << "Vector elements:";
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << " " << vec[i];
    }
    std::cout << std::endl;
    return 0;
}

• 列表（List）：

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4, 5}; // 创建一个包含5个整数的列表
    std::cout << "List elements:";
    for (const auto& elem : myList) {
        std::cout << " " << elem;
    }
    std::cout << std::endl;
    return 0;
}

• 队列（Queue）：

#include <iostream>
#include <queue>

int main() {
    std::queue<int> myQueue;
    myQueue.push(1);
    myQueue.push(2);
    myQueue.push(3);
    std::cout << "Queue elements:";
    while (!myQueue.empty()) {
        std::cout << " " << myQueue.front();
        myQueue.pop();
    }
    std::cout << std::endl;
    return 0;
}

• 栈（Stack）：

#include <iostream>
#include <stack>

int main() {
    std::stack<int> myStack;
    myStack.push(1);
    myStack.push(2);
    myStack.push(3);
    std::cout << "Stack elements:";
    while (!myStack.empty()) {
        std::cout << " " << myStack.top();
        myStack.pop();
    }
    std::cout << std::endl;
    return 0;
}

• 集合（Set）：

#include <iostream>
#include <set>

int main() {
    std::set<int> mySet = {3, 1, 4, 1, 5}; // 创建一个包含5个整数的集合
    std::cout << "Set elements:";
    for (const auto& elem : mySet) {
        std::cout << " " << elem;
    }
    std::cout << std::endl;
    return 0;
}

• 映射（Map）：

#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> myMap = {{"a", 1}, {"b", 2}, {"c", 3}}; // 创建一个包含3个键值对的映射
    std::cout << "Map elements:";
    for (const auto& pair : myMap) {
        std::cout << " (" << pair.first << ", " << pair.second << ")";
    }
    std::cout << std::endl;
    return 0;
}

• 哈希表（Hash Table）：

#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<std::string, int> myHashMap = {{"a", 1}, {"b", 2}, {"c", 3}}; // 创建一个包含3个键值对的哈希表
    std::cout << "Hash Map elements:";
    for (const auto& pair : myHashMap) {
        std::cout << " (" << pair.first << ", " << pair.second << ")";
    }
    std::cout << std::endl;
    return 0;
}

--

在 C++ 标准库中，迭代器（iterator）是一种用于访问容器中元素的抽象概念。迭代器类似于指针，它指向容器中的某个元素，可以通过迭代器对该元素进行访问和修改。

迭代器类型是由容器类定义的一个类型，用于表示迭代器。每种容器类都有自己的迭代器类型，例如：

• vector<int>::iterator 表示 vector<int> 容器中元素的迭代器类型。
• list<string>::iterator 表示 list<string> 容器中元素的迭代器类型。
• map<int, string>::iterator 表示 map<int, string> 容器中元素的迭代器类型。

迭代器类型是容器类与算法类之间的接口，使得算法可以在不同类型的容器上工作。例如，可以使用 std::sort 算法对 vector<int> 容器进行排序，也可以使用 std::sort 算法对 list<string> 容器进行排序，因为这两种容器都支持随机访问迭代器。 

转载自CSDN-专业IT技术社区

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/book_dw5189/article/details/138261936