C++ 控制流语句示例

功能描述

本示例程序展示了 C++ 中各种控制流语句的使用方法，包括条件语句、循环语句、跳转语句等。控制流语句是编程中用于控制程序执行流程的重要工具，它们使得程序能够根据不同的条件执行不同的代码块，或者重复执行特定的代码块。

代码解析

1. if-else 语句

1
2
3
4
5
6
7
8
9
10
11
12
13
int score = 85;

if (score >= 90) {
    std::cout << "Grade: A" << std::endl;
} else if (score >= 80) {
    std::cout << "Grade: B" << std::endl;
} else if (score >= 70) {
    std::cout << "Grade: C" << std::endl;
} else if (score >= 60) {
    std::cout << "Grade: D" << std::endl;
} else {
    std::cout << "Grade: F" << std::endl;
}

说明：if-else 语句用于根据条件执行不同的代码块。如果条件为真，则执行 if 后面的代码块；否则，执行 else 后面的代码块。可以使用 else if 来检查多个条件。

2. switch 语句

1
2
3
4
5
6
7
8
9
10
11
12
int day = 3;
switch (day) {
    case 1:
        std::cout << "Monday" << std::endl;
        break;
    case 2:
        std::cout << "Tuesday" << std::endl;
        break;
    // 其他 case...
    default:
        std::cout << "Invalid day" << std::endl;
}

说明：switch 语句用于根据表达式的值选择执行不同的代码块。每个 case 标签对应一个可能的值，当表达式的值与某个 case 标签匹配时，执行该 case 后面的代码。break 语句用于跳出 switch 语句，防止执行后续的 case。default 标签用于处理所有未明确指定的情况。

3. for 循环

1
2
3
for (int i = 1; i <= 5; ++i) {
    std::cout << i << " ";
}

说明：for 循环用于重复执行一段代码指定的次数。它包含三个部分：初始化表达式、条件表达式和更新表达式。初始化表达式在循环开始前执行一次，条件表达式在每次循环前检查，如果为真则执行循环体，更新表达式在每次循环后执行。

4. while 循环

1
2
3
4
5
int count = 0;
while (count < 5) {
    std::cout << count << " ";
    count++;
}

说明：while 循环在条件为真时重复执行循环体。条件表达式在每次循环前检查，如果为真则执行循环体。

5. do-while 循环

1
2
3
4
5
int num = 0;
do {
    std::cout << num << " ";
    num++;
} while (num < 5);

说明：do-while 循环先执行一次循环体，然后在条件为真时重复执行。条件表达式在每次循环后检查，如果为真则继续执行循环体。

6. range-based for 循环 (C++11+)

1
2
3
4
int arr[] = {10, 20, 30, 40, 50};
for (int x : arr) {
    std::cout << x << " ";
}

说明：range-based for 循环用于遍历容器或数组中的所有元素。它会自动迭代容器中的每个元素，并将当前元素赋值给循环变量。

7. break 和 continue 语句

1
2
3
4
5
6
7
8
9
for (int i = 0; i < 10; ++i) {
    if (i == 3) {
        continue;
    }
    if (i == 7) {
        break;
    }
    std::cout << i << " ";
}

说明：

  • continue 语句用于跳过当前循环的剩余部分，直接开始下一次循环。
  • break 语句用于跳出当前循环，不再执行循环的剩余部分。

8. 嵌套循环

1
2
3
4
5
6
for (int i = 1; i <= 3; ++i) {
    for (int j = 1; j <= 3; ++j) {
        std::cout << "(" << i << "," << j << ") ";
    }
    std::cout << std::endl;
}

说明：嵌套循环是指在一个循环内部包含另一个循环。外层循环执行一次，内层循环执行完整的一轮。

编译和运行

在 Windows 上编译（使用 g++）：

1
g++ -std=c++11 -fexec-charset=GBK -o control_flow control_flow.cpp

运行程序：

1
.\control_flow.exe

输出结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
=== 1. if-else 语句 ===
Grade: B

=== 2. 嵌套的 if-else 语句 ===
You can drive.

=== 3. switch 语句 ===
Wednesday

=== 4. 使用枚举的 switch 语句 ===
It's summer time!

=== 5. for 循环 ===
基本 for 循环:
1 2 3 4 5 
for 循环遍历数组:
1 2 3 4 5 

=== 6. while 循环 ===
0 1 2 3 4 

=== 7. do-while 循环 ===
0 1 2 3 4 

=== 8. range-based for 循环 ===
10 20 30 40 50 
使用 auto 的 range-based for 循环:
100 200 300 400 500 

=== 9. break 和 continue 语句 ===
0 1 2 Continue at i=3
4 5 6 Break at i=7

=== 10. 嵌套循环 ===
乘法表:
1×1=1    1×2=2    1×3=3    1×4=4    1×5=5    
2×1=2    2×2=4    2×3=6    2×4=8    2×5=10    
3×1=3    3×2=6    3×3=9    3×4=12    3×5=15    
4×1=4    4×2=8    4×3=12    4×4=16    4×5=20    
5×1=5    5×2=10    5×3=15    5×4=20    5×5=25    

=== 11. goto 语句 ===
0 1 2 3 4 

=== 12. 条件运算符 ===
Max of 10 and 20 is 20

=== 13. 逻辑运算符 ===
It's a nice day!
You don't need sunscreen.

=== 14. 随机数和循环 ===
生成 10 个 1-100 之间的随机数:
42 76 33 12 58 91 67 23 85 47 

=== 15. 无限循环和 break ===
Guess: 5
Guess: 3
Guess: 7
Found 7 in 3 attempts!

技术要点

1. 条件语句的使用场景

  • if-else：适用于需要根据多个条件进行不同处理的场景，尤其是当条件之间有逻辑关系时。
  • switch：适用于根据单个表达式的值进行多个分支选择的场景，尤其是当分支较多时，代码结构更清晰。

2. 循环语句的选择

  • for：适用于已知循环次数的场景，如遍历数组或执行固定次数的操作。
  • while：适用于循环次数未知，但有明确结束条件的场景。
  • do-while：适用于至少需要执行一次循环体的场景。
  • range-based for：适用于遍历容器或数组的所有元素，代码更简洁。

3. 跳转语句的使用

  • break：用于跳出循环或 switch 语句。
  • continue：用于跳过当前循环的剩余部分，开始下一次循环。
  • goto：用于无条件跳转到指定的标签，尽量避免使用，因为它会使代码结构混乱。

4. 循环控制技巧

  • 嵌套循环：用于处理多维数据，如二维数组或矩阵。
  • 无限循环：使用 while (true) 创建无限循环，通过 break 语句在适当的条件下跳出。
  • 循环优化：尽量减少循环内部的计算，将不变的表达式移到循环外部。

5. C++11 新特性

  • range-based for 循环：提供了更简洁的遍历语法。
  • auto 关键字：在 range-based for 循环中可以自动推导元素类型。

常见问题

1. 无限循环

问题：循环条件始终为真，导致程序陷入无限循环。
解决方案：确保循环条件最终会变为假，或在循环体内使用 break 语句跳出循环。

2. 循环变量未初始化

问题：使用未初始化的变量作为循环条件或循环变量。
解决方案：始终初始化循环变量。

3. 缺少 break 语句

问题：在 switch 语句中缺少 break 语句，导致执行多个 case。
解决方案：在每个 case 结束时添加 break 语句。

4. 数组越界

问题：在循环中访问数组元素时超出了数组的范围。
解决方案：确保循环变量的范围在数组的有效索引范围内。

5. 浮点数比较错误

问题：使用浮点数作为循环条件，由于精度问题导致循环次数不正确。
解决方案：使用整数作为循环计数器，或使用一个小的epsilon值进行比较。

代码优化建议

  1. 使用合适的循环类型：根据具体场景选择最合适的循环类型，使代码更清晰。

  2. 避免使用 goto：尽量使用结构化的控制流语句（if-else、循环）代替 goto，使代码结构更清晰。

  3. 使用 range-based for 循环：对于遍历容器或数组的场景，使用 range-based for 循环使代码更简洁。

  4. 循环不变式外提：将循环内部不变的表达式移到循环外部，提高性能。

  5. 使用 constexpr 和 const：对于编译时常量，使用 constexpr 或 const 关键字。

  6. 避免在循环中创建大对象：尽量在循环外部创建大对象，或使用移动语义。

  7. 使用标准算法：对于常见的算法操作（如查找、排序），使用 STL 提供的算法函数。

  8. 添加适当的注释：对于复杂的控制流逻辑，添加注释说明其目的和工作原理。

总结

C++ 提供了丰富的控制流语句，包括：

  • 条件语句：if-else、switch
  • 循环语句：for、while、do-while、range-based for
  • 跳转语句：break、continue、goto

这些控制流语句使得程序能够：

  • 根据不同的条件执行不同的代码块
  • 重复执行特定的代码块
  • 在适当的时机改变程序的执行流程

通过合理使用这些控制流语句，可以编写出结构清晰、逻辑正确、执行高效的 C++ 程序。

control_flow.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>
#include <ctime>

int main() {
    // 1. if-else 语句
    std::cout << "=== 1. if-else 语句 ===" << std::endl;
    int score = 85;

    if (score >= 90) {
        std::cout << "Grade: A" << std::endl;
    } else if (score >= 80) {
        std::cout << "Grade: B" << std::endl;
    } else if (score >= 70) {
        std::cout << "Grade: C" << std::endl;
    } else if (score >= 60) {
        std::cout << "Grade: D" << std::endl;
    } else {
        std::cout << "Grade: F" << std::endl;
    }

    // 嵌套的 if-else 语句
    std::cout << "\n=== 2. 嵌套的 if-else 语句 ===" << std::endl;
    int age = 25;
    bool hasLicense = true;

    if (age >= 18) {
        if (hasLicense) {
            std::cout << "You can drive." << std::endl;
        } else {
            std::cout << "You need a license to drive." << std::endl;
        }
    } else {
        std::cout << "You are too young to drive." << std::endl;
    }

    // 3. switch 语句
    std::cout << "\n=== 3. switch 语句 ===" << std::endl;
    int day = 3;
    switch (day) {
        case 1:
            std::cout << "Monday" << std::endl;
            break;
        case 2:
            std::cout << "Tuesday" << std::endl;
            break;
        case 3:
            std::cout << "Wednesday" << std::endl;
            break;
        case 4:
            std::cout << "Thursday" << std::endl;
            break;
        case 5:
            std::cout << "Friday" << std::endl;
            break;
        case 6:
            std::cout << "Saturday" << std::endl;
            break;
        case 7:
            std::cout << "Sunday" << std::endl;
            break;
        default:
            std::cout << "Invalid day" << std::endl;
    }

    // 使用枚举的 switch 语句
    std::cout << "\n=== 4. 使用枚举的 switch 语句 ===" << std::endl;
    enum Season { SPRING, SUMMER, AUTUMN, WINTER };
    Season currentSeason = SUMMER;

    switch (currentSeason) {
        case SPRING:
            std::cout << "It's spring time!" << std::endl;
            break;
        case SUMMER:
            std::cout << "It's summer time!" << std::endl;
            break;
        case AUTUMN:
            std::cout << "It's autumn time!" << std::endl;
            break;
        case WINTER:
            std::cout << "It's winter time!" << std::endl;
            break;
    }

    // 5. for 循环
    std::cout << "\n=== 5. for 循环 ===" << std::endl;
    std::cout << "基本 for 循环:" << std::endl;
    for (int i = 1; i <= 5; ++i) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    // for 循环遍历数组
    std::cout << "for 循环遍历数组:" << std::endl;
    int numbers[] = {1, 2, 3, 4, 5};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    for (int i = 0; i < size; ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // 6. while 循环
    std::cout << "\n=== 6. while 循环 ===" << std::endl;
    int count = 0;
    while (count < 5) {
        std::cout << count << " ";
        count++;
    }
    std::cout << std::endl;

    // 7. do-while 循环
    std::cout << "\n=== 7. do-while 循环 ===" << std::endl;
    int num = 0;
    do {
        std::cout << num << " ";
        num++;
    } while (num < 5);
    std::cout << std::endl;

    // 8. range-based for 循环 (C++11+)
    std::cout << "\n=== 8. range-based for 循环 ===" << std::endl;
    int arr[] = {10, 20, 30, 40, 50};
    for (int x : arr) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

    // 使用 auto 的 range-based for 循环
    std::cout << "使用 auto 的 range-based for 循环:" << std::endl;
    std::vector<int> vec = {100, 200, 300, 400, 500};
    for (auto value : vec) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    // 9. break 和 continue 语句
    std::cout << "\n=== 9. break 和 continue 语句 ===" << std::endl;
    for (int i = 0; i < 10; ++i) {
        if (i == 3) {
            std::cout << "Continue at i=" << i << std::endl;
            continue;
        }
        if (i == 7) {
            std::cout << "Break at i=" << i << std::endl;
            break;
        }
        std::cout << i << " ";
    }
    std::cout << std::endl;

    // 10. 嵌套循环
    std::cout << "\n=== 10. 嵌套循环 ===" << std::endl;
    std::cout << "乘法表:" << std::endl;
    for (int i = 1; i <= 5; ++i) {
        for (int j = 1; j <= 5; ++j) {
            std::cout << i << "×" << j << "=" << i * j << "\t";
        }
        std::cout << std::endl;
    }

    // 11. goto 语句 (尽量避免使用)
    std::cout << "\n=== 11. goto 语句 ===" << std::endl;
    int counter = 0;
loop_start:
    std::cout << counter << " ";
    counter++;
    if (counter < 5) {
        goto loop_start;
    }
    std::cout << std::endl;

    // 12. 条件运算符 (三元运算符)
    std::cout << "\n=== 12. 条件运算符 ===" << std::endl;
    int a = 10, b = 20;
    int max = (a > b) ? a : b;
    std::cout << "Max of " << a << " and " << b << " is " << max << std::endl;

    // 13. 逻辑运算符
    std::cout << "\n=== 13. 逻辑运算符 ===" << std::endl;
    bool isSunny = true;
    bool isWarm = true;

    if (isSunny && isWarm) {
        std::cout << "It's a nice day!" << std::endl;
    }

    bool hasUmbrella = false;
    if (!isSunny || hasUmbrella) {
        std::cout << "You don't need sunscreen." << std::endl;
    }

    // 14. 随机数和循环
    std::cout << "\n=== 14. 随机数和循环 ===" << std::endl;
    srand(time(0));
    std::cout << "生成 10 个 1-100 之间的随机数:" << std::endl;
    for (int i = 0; i < 10; ++i) {
        int randomNum = rand() % 100 + 1;
        std::cout << randomNum << " ";
    }
    std::cout << std::endl;

    // 15. 无限循环和 break
    std::cout << "\n=== 15. 无限循环和 break ===" << std::endl;
    int attempts = 0;
    while (true) {
        int guess = rand() % 10 + 1;
        std::cout << "Guess: " << guess << std::endl;
        attempts++;
        if (guess == 7) {
            std::cout << "Found 7 in " << attempts << " attempts!" << std::endl;
            break;
        }
        if (attempts > 5) {
            std::cout << "Gave up after " << attempts << " attempts." << std::endl;
            break;
        }
    }

    return 0;
}