c++遍历容器（vector、list、set、map

遍历vector

1. 基于范围的 for 循环（C++11 起推荐使用）

#include <vector>
#include <iostream>

std::vector<int> vec = {1, 2, 3, 4, 5};

for (const auto& element : vec) {
std::cout << element << " ";
}

• 使用 const auto& 避免不必要的拷贝（尤其对大型对象有用）。
• 如果你需要修改元素，可以去掉 const 或使用 auto&。

2. 使用迭代器

for (auto it = vec.begin(); it != vec.end(); ++it) {
std::cout << *it << " ";
}

或者使用 const_iterator（只读）：

for (auto it = vec.cbegin(); it != vec.cend(); ++it) {
std::cout << *it << " ";
}

3. 传统下标循环

for (size_t i = 0; i < vec.size(); ++i) {
std::cout << vec[i] << " ";
}

• 注意：size() 返回的是 size_t（无符号类型），避免与有符号整数比较产生警告。

4. 使用 std::for_each（函数式风格）

#include <algorithm>

std::for_each(vec.begin(), vec.end(), [](int n) {
std::cout << n << " ";
});

输出两层循环的vector

方法 1：基于范围的 for 循环（推荐）

for (const auto& row : matrix) {
for (const auto& elem : row) {
std::cout << elem << " ";
}
std::cout << "\\n"; // 每行结束后换行
}

方法 2：传统下标循环

for (size_t i = 0; i < matrix.size(); ++i) {
for (size_t j = 0; j < matrix[i].size(); ++j) {
std::cout << matrix[i][j] << " ";
}
std::cout << "\\n";
}

⚠️ 注意：使用 size_t 避免有符号/无符号比较警告。

方法 3：迭代器方式

for (auto row_it = matrix.begin(); row_it != matrix.end(); ++row_it) {
for (auto elem_it = row_it->begin(); elem_it != row_it->end(); ++elem_it) {
std::cout << *elem_it << " ";
}
std::cout << "\\n";
}

遍历deque

在 C++ 中，std::deque（双端队列）是一个支持在两端高效插入/删除、同时支持随机访问的顺序容器。遍历 deque 的方式非常灵活，几乎和 vector 一样丰富。

方法 1：基于范围的 for 循环（C++11 起，推荐）

#include <iostream>
#include <deque>

std::deque<int> dq = {10, 20, 30, 40};
for (const auto& elem : dq) {
std::cout << elem << " ";
}
// 输出: 10 20 30 40

如果需要修改元素：

for (auto& elem : dq) {
elem *= 2; // 所有元素翻倍
}

方法 2：使用下标（随机访问）

for (size_t i = 0; i < dq.size(); ++i) {
std::cout << dq[i] << " "; // 或 dq.at(i)
}

方法 3：使用迭代器（正向）

// 普通迭代器
for (auto it = dq.begin(); it != dq.end(); ++it) {
std::cout << *it << " ";
}

// 只读迭代器（推荐用于只读场景）
for (auto it = dq.cbegin(); it != dq.cend(); ++it) {
std::cout << *it << " ";
}

方法 4：反向遍历（从尾到头）

// 基于范围（C++17 不支持直接反向范围 for，需用迭代器）
for (auto rit = dq.rbegin(); rit != dq.rend(); ++rit) {
std::cout << *rit << " ";
}
// 输出: 40 30 20 10

方法 5：使用 std::for_each + lambda

#include <algorithm>

std::for_each(dq.begin(), dq.end(), [](int n) {
std::cout << n << " ";
});

⚠️ deque 遍历注意事项

遍历set

在 C++ 中，std::set 是一个有序、唯一的关联容器（通常基于红黑树实现），遍历方式与 vector 类似，但由于其元素是 const 的（不可修改），有一些细节需要注意。

1. 基于范围的 for 循环（推荐，C++11 起）

#include <iostream>
#include <set>

std::set<int> mySet = {3, 1, 4, 1, 5};

for (const auto& elem : mySet) {
std::cout << elem << " "; // 输出: 1 3 4 5
}

• 元素自动按升序排列（默认使用 std::less）。
• 不能通过遍历修改元素（因为 set 中的 key 是 const 的），所以用 const auto& 是安全且高效的。

2. 使用迭代器

for (auto it = mySet.begin(); it != mySet.end(); ++it) {
std::cout << *it << " ";
}

或只读迭代器（更明确）：

for (auto it = mySet.cbegin(); it != mySet.cend(); ++it) {
std::cout << *it << " ";
}

3. 使用 std::for_each + lambda

#include <algorithm>

std::for_each(mySet.begin(), mySet.end(), [](const int& n) {
std::cout << n << " ";
});

• std::set 不支持下标访问（如 mySet[i] 是非法的）。
• 遍历时元素自动排序（除非你自定义了比较函数）。
• 所有遍历方式都是只读的——这是由 set 的设计决定的（修改 key 会破坏内部结构）。

遍历list

在 C++ 中，std::list 是一个双向链表容器，支持高效的插入和删除操作（但不支持随机访问）。遍历 std::list 的方式与其他 STL 容器类似，但由于其底层是链表结构，不能使用下标（如 list[i]）。

注意事项

方法 1：基于范围的 for 循环（C++11 起，推荐）

#include <iostream>
#include <list>

std::list<int> mylist = {10, 20, 30, 40};
for (const auto& elem : mylist) {
std::cout << elem << " ";
}
// 输出: 10 20 30 40

如果需要修改元素，可用 auto&：

for (auto& elem : mylist) {
elem *= 2; // 所有元素翻倍
}

方法 2：使用迭代器

// 正向遍历
for (auto it = mylist.begin(); it != mylist.end(); ++it) {
std::cout << *it << " ";
}

// 只读遍历（更安全）
for (auto it = mylist.cbegin(); it != mylist.cend(); ++it) {
std::cout << *it << " ";
}

方法 3：反向遍历（从尾到头）

for (auto rit = mylist.rbegin(); rit != mylist.rend(); ++rit) {
std::cout << *rit << " ";
}
// 输出: 40 30 20 10

方法 4：使用 std::for_each + lambda

#include <algorithm>

std::for_each(mylist.begin(), mylist.end(), [](int n) {
std::cout << n << " ";
});

性能提示

• std::list 遍历速度通常比 std::vector 慢（因为内存不连续，缓存不友好）。
• 如果只是顺序读取且不需要频繁中间插入/删除，优先考虑 vector 或 deque。

遍历map

在 C++ 中，std::map 是一个有序的键值对（key-value）关联容器，每个元素是一个 std::pair<const Key, Value>。遍历 map 的结果会按键的升序自动排序（默认使用 std::less<Key>）。

方法 1：基于范围的 for 循环（C++11 起，推荐）

#include <iostream>
#include <map>
#include <string>

std::map<std::string, int> scores = {
{"Alice", 95},
{"Bob", 87},
{"Charlie", 92}
};

for (const auto& pair : scores) {
std::cout << pair.first << " => " << pair.second << "\\n";
}

或者使用结构化绑定（C++17 起更清晰）：

for (const auto& [key, value] : scores) {
std::cout << key << " => " << value << "\\n";
}

方法 2：使用迭代器

for (auto it = scores.begin(); it != scores.end(); ++it) {
std::cout << it->first << " => " << it->second << "\\n";
}

方法 3：使用 std::for_each + lambda

#include <algorithm>

std::for_each(scores.begin(), scores.end(), [](const auto& p) {
std::cout << p.first << " => " << p.second << "\\n";
});

一、基本特性总览

遍历方式对比

性能对比（时间复杂度）

使用场景建议

完整容器列表

 所有 unordered_* 容器要求 key 类型支持哈希（即提供 std::hash<Key> 特化），否则需自定义哈希函数。

时间复杂度对比（平均 / 最坏）