for循环的认识与使用

for 循环是 C++ 中最灵活的循环结构，核心适用于「已知循环次数」或「有明确迭代范围」的场景。以下从 基础语法→核心用法→进阶特性→避坑指南 全面梳理，不依赖任何特定业务代码，纯通用知识点讲解。

一、for 循环的核心语法（必记）

标准结构包含 3 个用分号分隔的表达式（均可省略，但分号不能少），执行流程清晰：

for (表达式1; 表达式2; 表达式3) {
    循环体;  // 条件满足时执行
}

执行流程：

1. 执行「表达式 1」（初始化操作），仅执行 1 次；
2. 判断「表达式 2」（条件判断）：
   • 若为 true，执行循环体；
   • 若为 false，退出循环；
3. 执行「表达式 3」（更新操作）； 
4. 回到步骤 2，重复判断，直到条件不满足。

二、for 循环的 6 种核心用法（附通用示例）

1. 基础用法：固定次数循环（最常用）

表达式 1 定义迭代变量，表达式 2 控制循环次数，表达式 3 更新迭代变量（递增 / 递减）。

示例 1：正向递增（从 0 到 n-1）

// 循环5次，输出0~4
for (int i = 0; i < 5; i++) {
    cout << i << " ";  // 输出：0 1 2 3 4
}

示例 2：反向递减（从 n-1 到 0）

// 循环5次，输出4~0
for (int i = 4; i >= 0; i--) {
    cout << i << " ";  // 输出：4 3 2 1 0
}

示例 3：自定义步长（非 1 递增 / 递减）

// 步长为2，输出0、2、4（跳步循环）
for (int i = 0; i < 5; i += 2) {
    cout << i << " ";  // 输出：0 2 4
}

// 步长为-3，输出9、6、3（反向跳步）
for (int i = 9; i >= 3; i -= 3) {
    cout << i << " ";  // 输出：9 6 3
}

2. 灵活用法：省略部分表达式

for 循环的 3 个表达式均可省略，根据场景调整，核心是「保留分号」。

示例 1：省略表达式 1（变量已在循环外定义）

int i = 0;
// 省略初始化（i已提前定义）
for (; i < 5; i++) {
    cout << i << " ";  // 输出：0 1 2 3 4
}

示例 2：省略表达式 2（无限循环，需手动 break 退出）

// 省略条件判断，需在循环体内控制退出
for (int i = 0;; i++) {
    if (i >= 5) break;  // 当i=5时退出
    cout << i << " ";  // 输出：0 1 2 3 4
}

示例 3：省略表达式 3（循环体内更新迭代变量）

// 省略更新操作，在循环内修改i
for (int i = 0; i < 5;) {
    cout << i << " ";
    i += 2;  // 循环体内步长更新（输出：0 2 4）
}

示例 4：省略所有表达式（纯粹无限循环）

// 无初始化、无判断、无更新，需手动退出
int count = 0;
for (;;) {
    if (count >= 3) break;
    cout << "循环" << count << "次" << endl;
    count++;
}
// 输出：
// 循环0次
// 循环1次
// 循环2次

3. 高级用法：多变量迭代（逗号分隔）

表达式 1 和表达式 3 可通过「逗号运算符」包含多个操作，适合同时控制多个迭代变量（如双指针、多计数器场景）。

示例 1：同时控制两个递增变量

// 表达式1：初始化i=0、j=10；表达式3：i递增、j递减
for (int i = 0, j = 10; i < 5; i++, j--) {
    cout << "i=" << i << ", j=" << j << endl;
}
// 输出：
// i=0, j=10
// i=1, j=9
// i=2, j=8
// i=3, j=7
// i=4, j=6

示例 2：多变量不同步更新

// i每次+1，k每次+3
for (int i = 0, k = 0; i < 4; i++, k += 3) {
    cout << "i=" << i << ", k=" << k << endl;
}
// 输出：
// i=0, k=0
// i=1, k=3
// i=2, k=6
// i=3, k=9

4. 容器遍历：C++11 增强型 for 循环（范围 for）

专门用于遍历「连续存储的集合」（如数组、vector、string 等），语法简洁，无需手动控制迭代变量，适合简单遍历场景。

语法：

for (元素类型 变量名 : 容器/数组) {
    循环体;  // 变量名是容器元素的拷贝（只读不修改）
}

// 若需修改容器元素，变量名前加&（引用）
for (元素类型& 变量名 : 容器/数组) {
    循环体;  // 直接操作原容器元素
}

示例 1：遍历数组（只读）

int arr[] = {10, 20, 30, 40};
// 增强型for循环遍历数组
for (int num : arr) {
    cout << num << " ";  // 输出：10 20 30 40
}

示例 2：遍历 vector（修改元素）

#include <vector>
vector<double> vec = {1.1, 2.2, 3.3};
// 加&表示引用，修改原元素
for (double& num : vec) {
    num *= 2;  // 所有元素翻倍
    cout << num << " ";  // 输出：2.2 4.4 6.6
}

示例 3：遍历字符串

string str = "hello";
// 遍历字符串的每个字符
for (char c : str) {
    cout << c << " ";  // 输出：h e l l o
}

5. 嵌套用法：多层 for 循环

多个 for 循环嵌套，外层控制「轮次」，内层控制「每轮的操作」，适用于多维数据（如二维数组）、复杂逻辑（如矩阵运算）。

示例 1：遍历二维数组

int matrix[2][3] = {{1,2,3}, {4,5,6}};
// 外层循环：控制行（2行）
for (int i = 0; i < 2; i++) {
    // 内层循环：控制列（3列）
    for (int j = 0; j < 3; j++) {
        cout << matrix[i][j] << " ";
    }
    cout << endl;  // 每行结束换行
}
// 输出：
// 1 2 3 
// 4 5 6 

示例 2：打印直角三角形（星号图案）

int n = 5;
// 外层控制行数，内层控制每行星号数
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= i; j++) {
        cout << "* ";
    }
    cout << endl;
}
// 输出：
// * 
// * * 
// * * * 
// * * * * 
// * * * * * 

6. 特殊用法：循环变量作用域与类型灵活定义

示例 1：循环变量作用域（C++11+）

C++11 及以上标准中，for 循环内定义的变量（如 int i）作用域仅限于循环内，避免变量污染：

cpp

运行

for (int i = 0; i < 3; i++) {
    cout << i << " ";  // 合法：i在循环内可见
}
// cout << i << endl;  // 错误：i超出作用域（未定义）

示例 2：自定义类型的循环变量

循环变量可是任意合法类型（如 char、double、自定义结构体等）：

// 循环变量为char类型（ASCII码遍历）
for (char c = 'A'; c <= 'E'; c++) {
    cout << c << " ";  // 输出：A B C D E
}

// 循环变量为double类型（浮点数遍历，注意精度）
for (double d = 0.0; d <= 1.0; d += 0.2) {
    cout << fixed << setprecision(1) << d << " ";  // 输出：0.0 0.2 0.4 0.6 0.8 1.0
}

三、for 循环的关键特性与注意事项

1. 逗号运算符的优先级

表达式 1 和表达式 3 中，逗号是「运算符」而非分隔符，优先级最低，若需组合复杂逻辑需加括号：

// 错误：表达式3会被解析为 (i++), (j += 2)（虽结果正确，但需注意逻辑）
for (int i=0, j=0; i<3; i++, j+=2) {}

// 正确：若需复杂逻辑，加括号明确优先级
for (int i=0; i<3; i++, (j = i*2)) {}

2. 与 while 循环的选择逻辑

场景	推荐用 for 循环	推荐用 while 循环
已知循环次数（如遍历数组）	✅ 3 个表达式集中管理，语法简洁	❌ 需手动定义、更新迭代变量
未知循环次数（如输入 0 终止）	❌ 需省略表达式，逻辑不直观	✅ 条件判断更灵活
多层嵌套（如二维数组遍历）	✅ 迭代变量作用域隔离，不易出错	❌ 迭代变量需定义在循环外，易污染
简单遍历容器 / 数组	✅ 增强型 for 循环语法极简	❌ 无优势

3. 常见坑与避坑指南

坑 1：循环条件边界错误（数组越界）

int arr[5] = {1,2,3,4,5};
// 错误：i <= 5 会访问arr[5]（超出数组范围，未定义行为）
for (int i=0; i <= 5; i++) {
    cout << arr[i] << " ";
}
// 正确：数组下标范围是0~4，条件为i < 5
for (int i=0; i < 5; i++) {}

坑 2：增强型 for 循环修改元素未加引用

vector<int> vec = {1,2,3};
// 错误：num是拷贝，修改不影响原容器
for (int num : vec) {
    num = 10;
}
// 正确：加&引用原元素
for (int& num : vec) {
    num = 10;
}

坑 3：浮点数循环条件的精度问题

// 风险：浮点数精度误差可能导致循环多执行/少执行1次
for (double d = 0.0; d <= 1.0; d += 0.1) {
    cout << d << " ";  // 可能输出：0 0.1 0.2 ... 1.0 或 0 0.1 ... 0.9
}
// 解决方案：用整数计数转换为浮点数
for (int i=0; i <= 10; i++) {
    double d = i * 0.1;  // 无精度问题
}

坑 4：循环变量重定义（C++98 兼容问题）

C++98 中，for 循环内定义的变量作用域是整个函数，可能导致重定义错误：

// C++98中错误：i被重复定义
for (int i=0; i<3; i++) {}
for (int i=0; i<3; i++) {}

// 解决方案：使用C++11及以上标准，或在循环外定义变量
int i;
for (i=0; i<3; i++) {}
for (i=0; i<3; i++) {}

四、总结

for 循环的核心优势是「灵活可控」：

• 基础场景：用标准结构实现固定次数、自定义步长的循环；
• 进阶场景：用多变量迭代、嵌套循环处理复杂逻辑；
• 现代场景：用增强型 for 循环简化容器 / 数组遍历。