4.C++中的循环语句

C++中的循环语句

for 循环

for 循环是一种最常用的循环结构，通常用于已知循环次数的情况。

基本语法：

for (初始化表达式; 条件表达式; 更新表达式) {
    // 循环体，当条件表达式为真时执行
}

例如：

#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 5; i++) {
        cout << i << " ";
    }
    return 0;
}

代码解释：

• int i = 0：初始化表达式，用于初始化循环变量 i 的值。
• i < 5：条件表达式，当此表达式为 true 时，循环继续执行。
• i++：更新表达式，每次循环结束后更新循环变量的值。

范围 for 循环（C++11 引入）：

用于遍历容器（如 vector、array 等）或数组。

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {1, 2, 3, 4, 5};
    for (int num : v) {
        cout << num << " ";
    }
    return 0;
}

代码解释：

• for (int num : v)：将 v 中的每个元素依次赋值给 num，并执行循环体。

while 循环

while 循环用于在条件为真时执行循环，适用于不确定循环次数的情况。

基本语法：

while (条件表达式) {
    // 循环体，当条件表达式为真时执行
}

例如：

#include <iostream>
using namespace std;

int main() {
    int i = 0;
    while (i < 5) {
        cout << i << " ";
        i++;
    }
    return 0;
}

代码解释：

• i < 5：只要 i 小于 5，循环就会继续执行。
• 循环体内需要手动更新循环变量 i，否则可能导致死循环。

do-while 循环

do-while 循环至少会执行一次，然后根据条件决定是否继续执行。

基本语法：

do {
    // 循环体
} while (条件表达式);

例如：

#include <iostream>
using namespace std;

int main() {
    int i = 0;
    do {
        cout << i << " ";
        i++;
    } while (i < 5);
    return 0;
}

代码解释：

• 首先执行一次循环体，然后检查 i < 5 的条件，如果为 true，则继续执行循环。

嵌套循环

可以将循环嵌套使用，用于处理二维数组、矩阵等复杂结构。

#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cout << i << "," << j << " ";
        }
        cout << endl;
    }
    return 0;
}

代码解释：

• 外层 for 循环控制行，内层 for 循环控制列，可用于遍历二维数组或打印矩阵。

循环控制语句

1. break 语句：

• 用于立即终止最内层的循环。

#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 10; i++) {
        if (i == 5) {
            break;
        }
        cout << i << " ";
    }
    return 0;
}

2. continue 语句：

• 用于跳过当前循环的剩余部分，继续下一次循环。

#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 5; i++) {
        if (i == 2) {
            continue;
        }
        cout << i << " ";
    }
    return 0;
}

循环的应用场景

1. for 循环：

• 适合处理已知迭代次数的情况，如遍历数组、计算数列等。

2. while 循环：

• 适用于条件驱动的循环，例如文件读取，当文件未结束时继续读取。

3. do-while 循环：

• 适用于需要先执行一次操作，再根据条件判断是否继续的场景，如用户输入验证。

性能考虑

• 在性能方面，对于已知迭代次数的简单迭代，for 循环通常是最直观的选择。
• 对于复杂条件的迭代，while 或 do-while 可能更适合，可根据具体情况灵活使用。

注意事项

1. 无限循环：

• 要注意避免无限循环，确保循环条件会在一定情况下变为 false。

2. 循环变量更新：

• 在 while 和 do-while 循环中，要记得在循环体内更新循环变量，否则可能导致死循环。

C++ 的循环语句提供了强大的程序控制能力，可以根据不同的场景和需求选择合适的循环结构，配合循环控制语句，可以编写出简洁高效的程序。

使用 auto 关键字（C++11 引入）

在范围 for 循环中，可以使用 auto 关键字自动推导元素类型。

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<string> v = {"hello", "world", "cpp"};
    for (auto str : v) {
        cout << str << " ";
    }
    return 0;
}

代码解释：

• for (auto str : v)：根据 v 中的元素类型自动推导 str 的类型，简化代码编写。

循环语句是 C++ 程序控制流的重要组成部分，通过合理使用不同的循环语句和控制语句，可以实现各种复杂的逻辑和算法。

拓展知识：

一、基于范围的 for 循环（Range-based for loop）的更多细节

1. 遍历自定义容器

对于自定义的容器，只要容器提供了 begin() 和 end() 成员函数，返回迭代器，就可以使用范围 for 循环。

#include <iostream>
#include <vector>

class MyContainer {
public:
    class Iterator {
    public:
        using value_type = int;
        Iterator(int* ptr) : ptr_(ptr) {}
        int& operator*() const { return *ptr_; }
        Iterator& operator++() { ++ptr_; return *this; }
        bool operator!=(const Iterator& other) const { return ptr_!= other.ptr_; }
    private:
        int* ptr_;
    };

    MyContainer(int* begin, int* end) : begin_(begin), end_(end) {}
    Iterator begin() const { return Iterator(begin_); }
    Iterator end() const { return Iterator(end_); }
private:
    int* begin_;
    int* end_;
};

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    MyContainer container(arr, arr + 5);
    for (int num : container) {
        std::cout << num << " ";
    }
    return 0;
}

2. 修改容器元素

使用引用可以修改容器元素：

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {1, 2, 3, 4, 5};
    for (int& num : v) {
        num = num * 2;
    }
    for (int num : v) {
        cout << num << " ";
    }
    return 0;
}

二、并行 for 循环（C++17 引入）

使用 <execution> 头文件中的 std::for_each 结合执行策略，可以实现并行 for 循环，利用多线程加速处

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::for_each(std::execution::par, v.begin(), v.end(), [](int& num) {
        num = num * num;
    });
    for (int num : v) {
        std::cout << num << " ";
    }
    return 0;
}

三、迭代器适配器和范围库（C++20 引入）

C++20 引入了范围库，可以更方便地处理范围操作。

1. 使用 std::views::iota 创建范围

#include <iostream>
#include <ranges>

int main() {
    for (int i : std::views::iota(0, 10)) {
        std::cout << i << " ";
    }
    return 0;
}

2. 使用 std::views::filter 和 std::views::transform 进行过滤和转换

#include <iostream>
#include <vector>
#include <ranges>
#include <algorithm>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    auto result = v | std::views::filter([](int i) { return i % 2 == 0; })
                   | std::views::transform([](int i) { return i * i; });
    for (int num : result) {
        std::cout << num << " ";
    }
    return 0;
}

四、goto 语句（不推荐，但有时有用）

goto 语句可以跳转到程序中的标记位置，但它会使程序结构混乱，通常不推荐使用。

#include <iostream>
using namespace std;

int main() {
    int i = 0;
    loop:
    if (i < 5) {
        cout << i << " ";
        i++;
        goto loop;
    }
    return 0;
}

五、使用 while(true) 实现无限循环

在某些情况下，可能需要一个无限循环，可以使用 while(true) 或 for(;;) 来实现。

#include <iostream>
using namespace std;

int main() {
    int i = 0;
    while (true) {
        if (i >= 5) break;
        cout << i << " ";
        i++;
    }
    return 0;
}

六、性能优化

• 循环展开：
  手动展开循环可以减少循环控制的开销，但可能会使代码更难维护。

#include <iostream>
using namespace std;

int main() {
    int sum = 0;
    for (int i = 0; i < 100; i += 5) {
        sum += i;
        sum += (i + 1);
        sum += (i + 2);
        sum += (i + 3);
        sum += (i + 4);
    }
    cout << sum << endl;
    return 0;
}

• 编译器优化：
  现代编译器通常会对循环进行优化，如自动向量化、循环展开、强度削减等，可以使用编译器选项（如 -O3）开启更高级的优化。

七、异常处理和循环

在循环中可以使用异常处理机制，例如在文件读取循环中：

#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>

int main() {
    std::ifstream file("test.txt");
    if (!file.is_open()) {
        throw std::runtime_error("Could not open file");
    }
    std::string line;
    while (std::getline(file, line)) {
        try {
            // 处理文件内容
            std::cout << line << std::endl;
        } catch (const std::exception& e) {
            std::cerr << "Error: " << e.what() << std::endl;
        }
    }
    return 0;
}

八、递归作为循环的替代

对于一些复杂问题，递归可以作为循环的替代方案，特别是涉及树状结构或分治算法时。

#include <iostream>
using namespace std;

int factorial(int n) {
    if (n == 0) return 1;
    return n * factorial(n - 1);
}

int main() {
    cout << factorial(5) << endl;
    return 0;
}

九、循环和函数式编程

使用函数式编程风格可以简化循环代码，例如使用 std::accumulate 计算数组元素的和。

#include <iostream>
#include <vector>
#include <numeric>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    int sum = std::accumulate(v.begin(), v.end(), 0);
    std::cout << sum << std::endl;
    return 0;
}

十、循环和 Lambda 表达式

可以使用 Lambda 表达式增强循环的功能，例如排序。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> v = {3, 1, 4, 1, 5, 9};
    std::sort(v.begin(), v.end(), [](int a, int b) {
        return a < b;
    });
    for (int num : v) {
        std::cout << num << " ";
    }
    return 0;
}

这些拓展内容涵盖了 C++ 循环的高级用法，包括 C++11 及以上标准引入的新特性，能让你更灵活、高效地使用循环语句，根据不同的场景选择合适的技术可以提高代码的性能和可读性。