文章目录
1. 概述
有的时候，可能需要多次执行同一块代码。一般情况下，语句是顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。
循环语句允许我们多次执行一个语句或语句组，下面是大多数编程语言中循环语句的一般形式：
循环类型
| 循环类型 | 描述 |
|---|---|
| while 循环 | 当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。 |
| for 循环 | 多次执行一个语句序列，简化管理循环变量的代码。 |
| do...while 循环 | 除了它是在循环主体结尾测试条件外，其他与 while 语句类似。 |
| 嵌套循环 | 您可以在 while、for 或 do..while 循环内使用一个或多个循环。 |
循环控制语句
循环控制语句更改执行的正常序列。当执行离开一个范围时，所有在该范围中创建的自动对象都会被销毁。
| 控制语句 | 描述 |
|---|---|
| break 语句 | 终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。 |
| continue 语句 | 引起循环跳过主体的剩余部分，立即重新开始测试条件。 |
| goto 语句 | 将控制转移到被标记的语句。但是不建议在程序中使用 goto 语句。 |
2. 无限循环
如果条件永远不为假，则循环将变成无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，您可以将某些条件表达式留空来构成一个无限循环。
#include <iostream>
using namespace std;
int main ()
{
int start = 1; // 起始值
int end = 10; // 结束值
int sum = 0; // 累加和
for (int i = start; i <= end; ++i)
{
sum += i; // 累加每个数
}
cout << "从 " << start << " 到 " << end << " 的所有数字的和是 " << sum << endl;
return 0;
}当条件表达式不存在时，它被假设为真。也可以设置一个初始值和增量表达式，但是一般情况下，C++ 程序员偏向于使用 for(;;) 结构来表示一个无限循环。可以按 Ctrl + C 键终止一个无限循环。
3. while 循环
只要给定的条件为真，while 循环语句会重复执行一个目标语句。
在这里，while 循环的关键点是循环可能一次都不会执行。当条件被测试且结果为假时，会跳过循环主体，直接执行紧接着 while 循环的下一条语句。
代码示例：
#include <iostream>
using namespace std;
int main ()
{
// 局部变量声明
int number = 5; // 要计算阶乘的数
int factorial = 1; // 阶乘结果初始化
int i = 1; // 计数器初始化
// while 循环执行
while (i <= number)
{
factorial *= i; // 计算阶乘
i++; // 计数器递增
}
// 显示结果
cout << number << " 的阶乘是：" << factorial << endl;
return 0;
}
- 初始值：
factorial = 1- 第一次循环：
factorial *= 1，factorial = 1- 第二次循环：
factorial *= 2，factorial = 2- 第三次循环：
factorial *= 3，factorial = 6- 第四次循环：
factorial *= 4，factorial = 24- 第五次循环：
factorial *= 5，factorial = 120
4. for 循环
for 循环允许编写一个执行特定次数的循环的重复控制结构。
C++ 中 for 循环的语法：
for ( init; condition; increment )
{
statement(s);
}
下面是 for 循环的控制流：
- init 会首先被执行，且只会执行一次。这一步允许您声明并初始化任何循环控制变量。您也可以不在这里写任何语句，只要有一个分号出现即可。
- 接下来，会判断 condition。如果为真，则执行循环主体。如果为假，则不执行循环主体，且控制流会跳转到紧接着 for 循环的下一条语句。
- 在执行完 for 循环主体后，控制流会跳回上面的 increment 语句。该语句允许您更新循环控制变量。该语句可以留空，只要在条件后有一个分号出现即可。
- 条件再次被判断。如果为真，则执行循环，这个过程会不断重复（循环主体，然后增加步值，再然后重新判断条件）。在条件变为假时，for 循环终止。
代码示例：
#include <iostream>
using namespace std;
int main ()
{
// for 循环执行，打印 1 到 20 之间的所有奇数
for (int i = 1; i <= 20; i++)
{
if (i % 2 != 0)
{
cout << "奇数：" << i << endl;
}
}
return 0;
}奇数：1
奇数：3
奇数：5
奇数：7
奇数：9
奇数：11
奇数：13
奇数：15
奇数：17
奇数：19
5. do...while 循环
不像 for 和 while 循环，它们是在循环头部测试循环条件。do...while 循环是在循环的尾部检查它的条件。
do...while 循环与 while 循环类似，但是 do...while 循环会确保至少执行一次循环。
C++ 中 do...while 循环的语法：
do
{
statement(s);
}while( condition );
请注意，条件表达式出现在循环的尾部，所以循环中的 statement(s) 会在条件被测试之前至少执行一次。
如果条件为真，控制流会跳转回上面的 do，然后重新执行循环中的 statement(s)。这个过程会不断重复，直到给定条件变为假为止。
代码示例：
#include <iostream>
using namespace std;
int main ()
{
// 局部变量声明
int start;
int end;
// 输入范围
cout << "请输入起始值: ";
cin >> start;
cout << "请输入终止值: ";
cin >> end;
// do 循环执行，打印从 start 到 end 的所有数字
do
{
cout << "当前值：" << start << endl;
start = start + 1;
} while (start <= end);
return 0;
}请输入起始值: 5
请输入终止值: 10
当前值：5
当前值：6
当前值：7
当前值：8
当前值：9
当前值：10
6. 嵌套循环
一个循环内可以嵌套另一个循环。C++ 允许至少 256 个嵌套层次。
C++ 中 嵌套 for 循环 语句的语法：
for ( init; condition; increment )
{
for ( init; condition; increment )
{
statement(s);
}
statement(s); // 可以放置更多的语句
}C++ 中 嵌套 while 循环 语句的语法：
while(condition)
{
while(condition)
{
statement(s);
}
statement(s); // 可以放置更多的语句
}C++ 中 嵌套 do...while 循环 语句的语法：
do
{
statement(s); // 可以放置更多的语句
do
{
statement(s);
}while( condition );
}while( condition );关于嵌套循环有一点值得注意，可以在任何类型的循环内嵌套其他任何类型的循环。比如，一个 for 循环可以嵌套在一个 while 循环内。
代码示例：
下面的程序使用了一个嵌套的 for 循环来查找 2 到 100 中的质数：
#include <iostream>
using namespace std;
int main ()
{
int i, j;
// 使用嵌套的 for 循环打印乘法表
for (i = 1; i <= 9; i++) {
for (j = 1; j <= 9; j++) {
cout << i << " * " << j << " = " << i * j << "\t";
}
cout << endl; // 换行
}
return 0;
}
程序运行的输出结果将会打印 1 到 9 的乘法表：
1 * 1 = 1 1 * 2 = 2 1 * 3 = 3 1 * 4 = 4 1 * 5 = 5 1 * 6 = 6 1 * 7 = 7 1 * 8 = 8 1 * 9 = 9
2 * 1 = 2 2 * 2 = 4 2 * 3 = 6 2 * 4 = 8 2 * 5 = 10 2 * 6 = 12 2 * 7 = 14 2 * 8 = 16 2 * 9 = 18
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 3 * 4 = 12 3 * 5 = 15 3 * 6 = 18 3 * 7 = 21 3 * 8 = 24 3 * 9 = 27
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16 4 * 5 = 20 4 * 6 = 24 4 * 7 = 28 4 * 8 = 32 4 * 9 = 36
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 5 * 6 = 30 5 * 7 = 35 5 * 8 = 40 5 * 9 = 45
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36 6 * 7 = 42 6 * 8 = 48 6 * 9 = 54
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49 7 * 8 = 56 7 * 9 = 63
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64 8 * 9 = 72
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
7. break 语句
C++ 中 break 语句有以下两种用法：
- 当 break 语句出现在一个循环内时，循环会立即终止，且程序流将继续执行紧接着循环的下一条语句。
- 它可用于终止 switch 语句中的一个 case。
如果您使用的是嵌套循环（即一个循环内嵌套另一个循环），break 语句会停止执行最内层的循环，然后开始执行该块之后的下一行代码。
代码示例：
#include <iostream>
using namespace std;
int main ()
{
// 局部变量声明
int start;
int end;
int maxValue;
// 输入起始值、终止值和最大值
cout << "请输入起始值: ";
cin >> start;
cout << "请输入终止值: ";
cin >> end;
cout << "请输入最大值: ";
cin >> maxValue;
// do-while 循环执行，打印从 start 到 end 范围内的所有偶数
do
{
// 检查是否为偶数
if (start % 2 == 0)
{
cout << "偶数：" << start << endl;
}
start = start + 1;
// 如果超过最大值，则终止循环
if (start > maxValue)
{
cout << "已达到最大值，终止循环" << endl;
break;
}
} while (start <= end);
return 0;
}请输入起始值: 5
请输入终止值: 20
请输入最大值: 14
偶数：6
偶数：8
偶数：10
偶数：12
偶数：14
已达到最大值，终止循环
8. continue 语句
C++ 中的 continue 语句有点像 break 语句。但它不是强迫终止，continue 会跳过当前循环中的代码，强迫开始下一次循环。
对于 for 循环，continue 语句会导致执行条件测试和循环增量部分。对于 while 和 do...while 循环，continue 语句会导致程序控制回到条件测试上。
代码示例：
#include <iostream>
using namespace std;
int main ()
{
// 局部变量声明
int start = 10;
int end = 20;
int skip;
// 输入需要跳过的数字
cout << "请输入需要跳过的数字: ";
cin >> skip;
// do-while 循环执行，打印从 start 到 end 范围内的所有数字，但跳过用户指定的数字
do
{
if (start == skip)
{
// 跳过迭代
start = start + 1;
continue;
}
cout << "当前值：" << start << endl;
start = start + 1;
} while (start < end);
return 0;
}请输入需要跳过的数字: 15
当前值：10
当前值：11
当前值：12
当前值：13
当前值：14
当前值：16
当前值：17
当前值：18
当前值：19
9. goto 语句
goto 语句允许把控制无条件转移到同一函数内的被标记的语句。
注意：在任何编程语言中，都不建议使用 goto 语句。因为它使得程序的控制流难以跟踪，使程序难以理解和难以修改。任何使用 goto 语句的程序可以改写成不需要使用 goto 语句的写法。
#include <iostream>
using namespace std;
int main ()
{
// 局部变量声明
int i = 1, j = 1;
// do 循环执行
LOOP:do
{
do
{
if (i == 3 && j == 3)
{
// 跳到外层循环
j++;
goto LOOP;
}
cout << "i 的值：" << i << "，j 的值：" << j << endl;
j++;
} while (j <= 5);
i++;
j = 1; // 重置 j 为 1 以便下一次外层循环从头开始
} while (i <= 5);
return 0;
}i 的值：1，j 的值：1
i 的值：1，j 的值：2
i 的值：1，j 的值：3
i 的值：1，j 的值：4
i 的值：1，j 的值：5
i 的值：2，j 的值：1
i 的值：2，j 的值：2
i 的值：2，j 的值：3
i 的值：2，j 的值：4
i 的值：2，j 的值：5
i 的值：3，j 的值：1
i 的值：3，j 的值：2
i 的值：4，j 的值：1
i 的值：4，j 的值：2
i 的值：4，j 的值：3
i 的值：4，j 的值：4
i 的值：4，j 的值：5
i 的值：5，j 的值：1
i 的值：5，j 的值：2
i 的值：5，j 的值：3
i 的值：5，j 的值：4
i 的值：5，j 的值：5
在上述输出中，当i和j均为3时，程序跳过该情形，直接从标记LOOP:处继续执行。这展示了如何在嵌套循环中使用goto语句来控制程序流。
扫一扫
3207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
