c++如何使用范围for循环_c++基于范围的for循环使用技巧-C++-PHP中文网

范围for循环通过简洁语法遍历容器，支持按值、常量引用或引用访问元素，提升代码可读性与安全性，底层由编译器转换为迭代器循环，效率接近传统方式；结合C++17结构化绑定可优雅处理键值对，但无法直接获取索引、安全修改容器大小或反向遍历，需借助计数器、std::views::enumerate、传统迭代器等替代方案。

c++如何使用范围for循环_c++基于范围的for循环使用技巧

C++中，范围for循环提供了一种极其简洁且直观的方式来遍历容器或数组的元素，无需手动管理迭代器或索引，大大提升了代码的可读性和编写效率。它的核心思想就是“对范围内的每一个元素执行某个操作”，让遍历操作变得前所未有的轻松。

解决方案

使用C++基于范围的for循环，语法结构非常直接：for (declaration : expression)。

这里的expression可以是一个数组、std::vector、std::list、std::map等任何具有begin()和end()成员函数或自由函数的类型（即满足Range概念的类型）。declaration则是用于接收expression中每个元素的类型声明。

通常，我们会根据需求选择以下几种declaration方式：

立即学习“C++免费学习笔记（深入）”；

按值拷贝 (by value): for (auto element : container) 这种方式会为container中的每个元素创建一个副本。如果你只需要读取元素且容器元素不大，或者希望在循环体内修改副本而不影响原容器，可以使用这种方式。但对于大对象，频繁拷贝会带来性能开销。

#include <iostream>
#include <vector>
#include <string>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::cout << "按值拷贝遍历 (不改变原容器): ";
    for (int num : numbers) { // num是numbers中元素的副本
        num += 10; // 改变的是副本，不影响原numbers
        std::cout << num << " ";
    }
    std::cout << std::endl;
    std::cout << "原容器内容: ";
    for (int num : numbers) {
        std::cout << num << " "; // 输出仍是 1 2 3 4 5
    }
    std::cout << std::endl;
    return 0;
}

登录后复制

按常量引用 (by const reference): for (const auto&amp; element : container) 这是最常用且推荐的方式，特别是在你只需要读取元素而不需要修改它们时。它避免了元素的拷贝，直接引用原容器中的元素，效率高，同时通过const关键字保证了元素的不可修改性，增强了代码的安全性。

#include <iostream>
#include <vector>

int main() {
    std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
    std::cout << "按常量引用遍历: ";
    for (const auto&amp;amp; name : names) { // name是names中元素的常量引用
        // name += "!"; // 编译错误：不能修改常量引用
        std::cout << name << " ";
    }
    std::cout << std::endl;
    return 0;
}

登录后复制

按引用 (by reference): for (auto& element : container) 当你需要在循环体内修改容器中的元素时，使用引用方式。它同样避免了拷贝，直接操作原容器的元素。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> scores = {85, 90, 78, 92};
    std::cout << "修改前分数: ";
    for (int score : scores) {
        std::cout << score << " ";
    }
    std::cout << std::endl;

    std::cout << "按引用修改分数 (全部加5): ";
    for (auto&amp; score : scores) { // score是scores中元素的引用
        score += 5; // 直接修改原容器中的元素
        std::cout << score << " ";
    }
    std::cout << std::endl;
    std::cout << "修改后分数: ";
    for (int score : scores) {
        std::cout << score << " "; // 输出 90 95 83 97
    }
    std::cout << std::endl;
    return 0;
}

登录后复制

我个人觉得，这玩意儿一出来，写代码的幸福感真是直线飙升，特别是告别了那些std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it的冗长写法，代码瞬间清爽了不少。

范围for循环背后的机制与效率考量

范围for循环之所以如此便捷，是因为它在编译时会被C++编译器“翻译”成我们熟悉的、基于迭代器的传统for循环。具体来说，对于一个形如for (declaration : expression)的范围for循环，编译器会大致将其展开为：

{
    auto&amp;& __range = expression;
    auto __begin = std::begin(__range);
    auto __end = std::end(__range);
    for (; __begin != __end; ++__begin) {
        declaration = *__begin;
        // 循环体
    }
}

登录后复制

这里std::begin和std::end是全局函数，它们会优先调用expression的成员begin()和end()，如果没有，则会尝试寻找全局的begin(expression)和end(expression)函数。这意味着，任何提供了有效begin()和end()函数的类型，都可以作为范围for循环的expression。

说实话，刚开始用的时候，我压根没想过它底层是怎么实现的，只觉得好用。后来深入了解，才发现它其实是编译器的一个语法糖，把那些繁琐的迭代器操作给封装起来了。这让我对C++的现代化改进又多了一分敬佩，它在保持底层控制力的同时，也努力让高层代码更具表现力。

效率考量：

与传统循环对比： 对于std::vector或C风格数组这类内存连续的容器，范围for循环的效率通常与基于索引的循环（for (size_t i = 0; i < vec.size(); ++i)）或基于迭代器的循环（for (auto it = vec.begin(); it != vec.end(); ++it)）相当。编译器优化做得好的话，甚至可能因为其意图更明确而得到更好的优化。
选择declaration类型：
- const auto& (常量引用): 这是效率最高且最安全的遍历方式，因为它避免了不必要的拷贝，并且防止了意外修改。在绝大多数只读遍历场景中，都应该优先使用它。
- auto& (引用): 当你需要修改容器元素时，它同样高效，因为它也是直接操作原元素。
- auto (值拷贝): 效率最低，因为每次迭代都会产生一个元素的副本。只有当你确实需要副本（比如，在循环体内修改副本而不影响原容器，或者容器元素很小且拷贝开销可以忽略）时才考虑使用。

总的来说，范围for循环在大多数情况下都是高效且安全的。它的主要优势在于代码的简洁性和可读性，而不会带来显著的性能损失。

范围for循环与结构化绑定：现代C++的强强联合

C++17引入的结构化绑定（Structured Bindings）与范围for循环结合使用时，能产生极其优雅且强大的代码，尤其是在处理std::pair、std::tuple或std::map这类键值对容器时。它允许你将一个复合类型（如std::pair或std::map::value_type）的成员直接解包到独立的变量中。

我记得第一次看到结构化绑定和范围for循环这么用的时候，简直是惊艳了。以前处理map的键值对，总得写std::pair<const int, std::string>& p，然后p.first、p.second地访问，现在直接[key, value]，代码瞬间清爽了好几个度。这感觉就像是C++终于学会了说人话，而且说得还挺优雅。

示例：遍历std::map

std::map的元素类型是std::pair<const Key, Value>。在没有结构化绑定之前，你需要这样遍历：

AppMall应用商店

AI应用商店，提供即时交付、按需付费的人工智能应用服务

查看详情

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

int main() {
    std::map<int, std::string> students = {{1, "Alice"}, {2, "Bob"}, {3, "Charlie"}};

    // 传统方式遍历 map
    for (const auto&amp;amp; pair : students) {
        std::cout << "ID: " << pair.first << ", Name: " << pair.second << std::endl;
    }
    return 0;
}

登录后复制

而有了结构化绑定，你可以直接将pair解包成key和value：

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

int main() {
    std::map<int, std::string> students = {{1, "Alice"}, {2, "Bob"}, {3, "Charlie"}};

    // 使用结构化绑定遍历 map (推荐)
    for (const auto&amp;amp; [id, name] : students) { // id和name直接绑定到pair的first和second
        std::cout << "ID: " << id << ", Name: " << name << std::endl;
    }

    // 如果需要修改值，可以使用非const引用
    for (auto&amp; [id, name] : students) {
        if (id == 2) {
            name = "Bobby"; // 修改了map中的值
        }
    }
    std::cout << "修改后:" << std::endl;
    for (const auto&amp;amp; [id, name] : students) {
        std::cout << "ID: " << id << ", Name: " << name << std::endl;
    }
    return 0;
}

登录后复制

这种写法不仅更简洁，而且变量名id和name更具描述性，提高了代码的可读性。结构化绑定同样适用于数组、结构体以及std::tuple等类型，只要它们满足特定的结构化绑定要求。

范围for循环的局限性与替代方案的思考

虽然范围for循环极大地简化了代码，但它并非万能，也存在一些局限性。理解这些局限性，并知道何时选择其他遍历方式，对于编写健壮且高效的C++代码至关重要。我们不能因为它好用就无脑用，任何工具都有它的边界。我曾经就犯过在范围for循环里删除元素的错误，结果程序直接崩了，或者行为异常，调试了半天才发现是迭代器失效的问题。所以，理解它的局限性，比单纯学会怎么用，可能更重要。

局限性：

无法直接获取元素索引： 范围for循环的设计哲学是关注元素本身，而非它们在容器中的位置。如果你在循环中需要知道当前元素的索引，范围for循环无法直接提供。

替代方案：

手动计数： 在循环外部维护一个计数器。

std::vector<int> data = {10, 20, 30};
int index = 0;
for (const auto&amp;amp; val : data) {
    std::cout << "Element at index " << index << ": " << val << std::endl;
    index++;
}

登录后复制

C++23 std::views::enumerate： 如果你使用C++23或更高版本，std::views::enumerate可以优雅地解决这个问题。

#include <iostream>
#include <vector>
#include <ranges> // For std::views::enumerate

int main() {
    std::vector<int> data = {10, 20, 30};
    for (const auto&amp;amp; [index, val] : std::views::enumerate(data)) {
        std::cout << "Element at index " << index << ": " << val << std::endl;
    }
    return 0;
}

登录后复制

不能在循环体内安全地修改容器大小（添加或删除元素）： 这是最常见且危险的陷阱。在范围for循环中添加或删除元素可能会导致迭代器失效，进而引发未定义行为（程序崩溃、数据损坏等）。范围for循环在内部使用了begin()和end()迭代器来确定循环范围，这些迭代器在容器大小改变时可能不再有效。

替代方案：

传统迭代器循环： 当需要删除元素时，使用传统的迭代器循环，并小心处理迭代器失效。

#include <iostream>
#include <vector>
#include <algorithm> // For std::remove_if

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6};
    // 错误示例：在范围for循环中删除元素
    // for (auto num : nums) {
    //     if (num % 2 == 0) {
    //         // nums.erase(std::remove(nums.begin(), nums.end(), num), nums.end()); // 错误！迭代器失效
    //     }
    // }

    // 正确方式1：使用传统迭代器循环进行删除
    for (auto it = nums.begin(); it != nums.end(); ) {
        if (*it % 2 == 0) {
            it = nums.erase(it); // erase返回下一个有效迭代器
        } else {
            ++it;
        }
    }
    std::cout << "删除偶数后: ";
    for (int n : nums) {
        std::cout << n << " "; // 输出 1 3 5
    }
    std::cout << std::endl;

    // 正确方式2：使用erase-remove idiom (通常结合std::remove_if)
    std::vector<int> more_nums = {1, 2, 3, 4, 5, 6};
    more_nums.erase(std::remove_if(more_nums.begin(), more_nums.end(),
                                   [](int n){ return n % 2 == 0; }),
                    more_nums.end());
    std::cout << "使用erase-remove idiom删除偶数后: ";
    for (int n : more_nums) {
        std::cout << n << " "; // 输出 1 3 5
    }
    std::cout << std::endl;
    return 0;
}

登录后复制

先收集要修改的元素/索引，再统一处理： 这种方式更安全，但可能需要额外的存储空间。

无法直接反向遍历： 范围for循环总是从begin()到end()正向遍历。
- 替代方案：
  - 传统反向迭代器循环： 使用rbegin()和rend()。
```
std::vector<int> data = {1, 2, 3, 4, 5};
for (auto it = data.rbegin(); it != data.rend(); ++it) {
    std::cout << *it << " "; // 输出 5 4 3 2 1
}
std::cout << std
```
    登录后复制