C++容器遍历全指南：从基础到实战优化

1. C++容器遍历全指南：从基础到实战

在C++开发中，容器遍历是最基础也是最频繁的操作之一。掌握各种容器的遍历方式不仅能提高代码效率，还能避免许多常见的陷阱。本文将深入解析vector、list、set、map等常用容器的遍历方法，并分享我在实际项目中的使用经验和性能优化技巧。

2. vector遍历详解

2.1 基于范围的for循环（C++11推荐）

现代C++中最简洁的遍历方式，编译器会自动优化为迭代器模式：

cpp复制std::vector<int> vec = {1, 2, 3, 4, 5};
for (const auto& element : vec) {
    std::cout << element << " ";
}

经验之谈：对于自定义类对象，务必使用const auto&避免不必要的拷贝构造。我在一个图像处理项目中，忘记加引用导致性能下降30%。

2.2 迭代器遍历（通用模式）

标准迭代器模式适用于所有STL容器：

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

2.3 下标访问（仅连续容器）

vector特有的随机访问方式：

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

避坑指南：size()返回size_t类型，与int比较会产生警告。建议统一使用size_t类型作为索引变量。

2.4 二维vector遍历实战

处理矩阵数据时的两种推荐方式：

方法1：范围for嵌套

cpp复制std::vector<std::vector<int>> matrix(3, std::vector<int>(3, 1));
for (const auto& row : matrix) {
    for (const auto& elem : row) {
        std::cout << elem << " ";
    }
    std::cout << "\n";
}

方法2：迭代器嵌套

cpp复制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";
}

3. deque遍历技巧

3.1 基本遍历方式

deque支持vector的所有遍历方式，还支持高效的双端操作：

cpp复制std::deque<int> dq = {10, 20, 30, 40};
// 正向遍历
for (const auto& elem : dq) {
    std::cout << elem << " ";
}

// 反向遍历
for (auto rit = dq.rbegin(); rit != dq.rend(); ++rit) {
    std::cout << *rit << " ";
}

3.2 deque性能特点

实战心得：在实现滑动窗口算法时，deque比vector更合适。但要注意频繁中间插入会导致性能下降。

4. list遍历方法

4.1 标准遍历模式

list作为双向链表，不支持随机访问，但插入删除高效：

cpp复制std::list<int> mylist = {10, 20, 30, 40};
// 范围for
for (const auto& elem : mylist) {
    std::cout << elem << " ";
}

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

4.2 list的特殊优势

• 迭代器永不失效（除非元素被删除）
• 任意位置插入删除都是O(1)
• 支持splice高效转移元素

典型案例：LRU缓存实现中，list+unordered_map是经典组合。list维护访问顺序，map提供快速查找。

5. set/map遍历要点

5.1 set遍历（自动排序）

cpp复制std::set<int> mySet = {3, 1, 4, 1, 5};
for (const auto& elem : mySet) {
    std::cout << elem << " ";  // 输出: 1 3 4 5
}

重要特性：set元素是const的，遍历时不能修改key值，否则会破坏红黑树结构。

5.2 map遍历（键值对处理）

传统方式：

cpp复制std::map<std::string, int> scores = {{"Alice", 95}, {"Bob", 87}};
for (const auto& pair : scores) {
    std::cout << pair.first << ": " << pair.second << "\n";
}

C++17结构化绑定：

cpp复制for (const auto& [name, score] : scores) {
    std::cout << name << ": " << score << "\n";
}

5.3 性能对比

6. 容器选择与性能优化

6.1 选择决策树

1. 需要随机访问？→ 选vector或deque
2. 频繁在两端操作？→ 选deque
3. 需要自动排序？→ 选set/map
4. 需要频繁中间插入？→ 选list
5. 追求极致性能？→ 优先考虑vector

6.2 实际项目经验

• 游戏开发中，实体组件系统(ECS)通常用vector存储组件，利用缓存局部性
• 网络框架中，连接管理常用list，因为要频繁插入删除
• 配置系统多用map，方便按键查找

6.3 高级技巧

利用移动语义减少拷贝：

cpp复制std::vector<BigObject> bigVec;
// 传统方式会有拷贝
for (const auto& obj : bigVec) { ... }

// C++11后可以用移动迭代器
for (auto&& obj : bigVec) { 
    process(std::move(obj));
}

并行遍历(C++17)：

cpp复制#include <execution>
std::vector<int> vec(1000);
std::for_each(std::execution::par, vec.begin(), vec.end(), [](auto& x) {
    x = process(x);
});

7. 常见问题排查

7.1 迭代器失效问题

典型场景：

cpp复制std::vector<int> vec = {1, 2, 3, 4};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    if (*it == 2) {
        vec.erase(it);  // 错误！迭代器失效
    }
}

正确做法：

cpp复制for (auto it = vec.begin(); it != vec.end(); ) {
    if (*it == 2) {
        it = vec.erase(it);  // erase返回下一个有效迭代器
    } else {
        ++it;
    }
}

7.2 性能陷阱

• 避免在vector遍历中频繁调用size()：

cpp复制// 不好
for (size_t i = 0; i < vec.size(); ++i) 

// 更好
const size_t size = vec.size();
for (size_t i = 0; i < size; ++i)

• list的遍历比vector慢2-3倍，仅在需要频繁插入删除时使用

8. 现代C++遍历新特性

8.1 C++20范围库

cpp复制#include <ranges>
std::vector<int> vec = {1, 2, 3, 4, 5};

// 过滤偶数
for (int i : vec | std::views::filter([](int x){ return x%2==0; })) {
    std::cout << i << " ";
}

// 转换元素
for (double d : vec | std::views::transform([](int x){ return x*1.5; })) {
    std::cout << d << " ";
}

8.2 结构化绑定增强

C++17开始支持嵌套结构化绑定：

cpp复制std::map<std::string, std::pair<int, double>> complexMap;
for (const auto& [key, value] : complexMap) {
    const auto& [count, ratio] = value;
    std::cout << key << ": " << count << ", " << ratio << "\n";
}

经过多年C++项目实践，我发现容器遍历看似简单，实则暗藏许多优化空间。理解各种容器的底层实现，才能写出既高效又安全的遍历代码。特别是在性能敏感的场景，选择正确的遍历方式可能带来数倍的性能提升。