C++ 控制流结构 | 掌握 if-else、switch 和循环

介绍

在本实验中，你将学习如何在 C++ 中实现各种控制流结构，包括单分支和多分支的 if-else 语句、switch 语句、计数器控制的 for 循环、入口控制的 while 循环、出口控制的 do-while 循环以及嵌套循环。你还将探索如何使用 break 和 continue 语句来控制循环的执行。这些基础的编程结构对于在 C++ 中构建更复杂和动态的应用程序至关重要。

本实验涵盖了一系列主题，从编写条件语句到创建具有不同执行逻辑的循环。通过本实验的学习，你将深入了解如何使用这些控制流结构，使你的 C++ 程序更加灵活，并能够适应不同的场景。

编写单分支和多分支 if-else 语句

在这一步中，你将学习如何在 C++ 中编写单分支和多分支的 if-else 语句。条件语句允许你的程序根据特定条件做出决策并执行不同的代码块。

首先，导航到项目目录并为本实验创建一个新的 C++ 文件：

cd ~/project
touch conditional_statements.cpp

在 WebIDE 中打开 conditional_statements.cpp 文件，并添加以下代码以探索单分支和多分支的 if-else 语句：

#include <iostream>

int main() {
    // 单分支 if 语句
    int number = 10;
    if (number > 5) {
        std::cout << "Number is greater than 5" << std::endl;
    }

    // if-else 语句
    int age = 20;
    if (age >= 18) {
        std::cout << "You are an adult" << std::endl;
    } else {
        std::cout << "You are a minor" << std::endl;
    }

    // 多分支 if-else 语句
    int score = 75;
    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;
    }

    return 0;
}

编译并运行程序：

g++ conditional_statements.cpp -o conditional_statements
./conditional_statements

示例输出：

Number is greater than 5
You are an adult
Grade: C

让我们分解不同类型的 if-else 语句：

单分支 if 语句：
- 如果条件为真，则执行代码块
- 如果条件为假，则不执行任何操作
if-else 语句：
- 提供两条执行路径
- 如果条件为真，则执行一个代码块
- 如果条件为假，则执行另一个代码块
多分支 if-else 语句：
- 允许检查多个条件
- 使用 else if 添加更多条件
- else 块作为默认情况

关于 if-else 语句的关键点：

条件从上到下依次评估
只会执行一个代码块
使用花括号 { } 定义代码块
在条件中使用比较运算符，如 >、>=、<、<=、==、!=

创建带有多个 case 标签的 switch 语句

在这一步中，你将学习如何在 C++ 中使用 switch 语句来处理基于单个变量的多个条件。当需要将一个变量与不同的常量值进行比较时，switch 语句可以替代多个 if-else 语句。

首先，导航到项目目录并创建一个新的 C++ 文件：

cd ~/project
touch switch_statement.cpp

在 WebIDE 中打开 switch_statement.cpp 文件，并添加以下代码以探索 switch 语句：

#include <iostream>

int main() {
    // 带有多个 case 标签的基本 switch 语句
    int dayNumber = 3;

    switch (dayNumber) {
        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 number" << std::endl;
    }

    // 多个 case 共享同一代码块的 switch 语句
    char grade = 'B';

    switch (grade) {
        case 'A':
        case 'B':
            std::cout << "Excellent performance!" << std::endl;
            break;
        case 'C':
        case 'D':
            std::cout << "Good performance" << std::endl;
            break;
        case 'F':
            std::cout << "Need improvement" << std::endl;
            break;
        default:
            std::cout << "Invalid grade" << std::endl;
    }

    return 0;
}

编译并运行程序：

g++ switch_statement.cpp -o switch_statement
./switch_statement

示例输出：

Wednesday
Excellent performance!

关于 switch 语句的关键点：

用于选择多个代码块中的一个来执行
适用于整型类型（int、char、enum）
每个 case 代表一个可能的值
break 语句防止执行流落入下一个 case
default 用于处理未匹配到其他 case 的值
多个 case 可以共享同一代码块

switch 语句的重要规则：

每个 case 必须以 break 或 return 结束
case 必须是常量表达式
只会执行一个代码块
default 是可选的，但建议使用

初始化计数器控制的 for 循环

在这一步中，你将学习如何在 C++ 中使用计数器控制的 for 循环。for 循环对于执行特定次数的代码块至关重要，非常适合需要已知迭代次数的重复任务。

首先，导航到项目目录并创建一个新的 C++ 文件：

cd ~/project
touch for_loops.cpp

在 WebIDE 中打开 for_loops.cpp 文件，并添加以下代码以探索初始化和使用 for 循环的不同方式：

#include <iostream>

int main() {
    // 基本的计数器控制 for 循环
    std::cout << "Counting from 1 to 5:" << std::endl;
    for (int i = 1; i <= 5; i++) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    // 在初始化中包含多个语句的 for 循环
    std::cout << "Counting even numbers from 0 to 10:" << std::endl;
    for (int j = 0, k = 10; j <= k; j += 2) {
        std::cout << j << " ";
    }
    std::cout << std::endl;

    // 用于乘法表的 for 循环
    std::cout << "Multiplication table for 5:" << std::endl;
    for (int m = 1; m <= 10; m++) {
        std::cout << "5 x " << m << " = " << (5 * m) << std::endl;
    }

    return 0;
}

编译并运行程序：

g++ for_loops.cpp -o for_loops
./for_loops

示例输出：

Counting from 1 to 5:
1 2 3 4 5
Counting even numbers from 0 to 10:
0 2 4 6 8 10
Multiplication table for 5:
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

for 循环的关键组成部分：

初始化：int i = 1 - 设置计数器的初始值
条件：i <= 5 - 定义循环何时继续
递增/递减：i++ - 每次迭代后更改计数器

for 循环的重要特性：

适用于已知迭代次数的场景
可以包含多个初始化语句
每次迭代可以修改多个变量
灵活控制循环执行

创建带有入口控制逻辑的 while 循环

在这一步中，你将学习如何在 C++ 中使用 while 循环。while 循环是一种入口控制循环，只要指定条件为真，就会重复执行代码块。每次迭代前都会检查条件，这意味着如果初始条件为假，循环可能根本不会执行。

首先，导航到项目目录并创建一个新的 C++ 文件：

cd ~/project
touch while_loops.cpp

在 WebIDE 中打开 while_loops.cpp 文件，并添加以下代码以探索使用 while 循环的不同方式：

#include <iostream>

int main() {
    // 基本的 while 循环计数
    std::cout << "Counting from 1 to 5:" << std::endl;
    int count = 1;
    while (count <= 5) {
        std::cout << count << " ";
        count++;
    }
    std::cout << std::endl;

    // 带有用户输入验证的 while 循环
    int userNumber;
    std::cout << "Enter a number between 1 and 10: ";
    std::cin >> userNumber;

    while (userNumber < 1 || userNumber > 10) {
        std::cout << "Invalid input. Enter a number between 1 and 10: ";
        std::cin >> userNumber;
    }
    std::cout << "You entered a valid number: " << userNumber << std::endl;

    // 计算阶乘的 while 循环
    int number = 5;
    int factorial = 1;
    int i = 1;

    std::cout << "Calculating factorial of " << number << ":" << std::endl;
    while (i <= number) {
        factorial *= i;
        i++;
    }
    std::cout << number << "! = " << factorial << std::endl;

    return 0;
}

编译并运行程序：

g++ while_loops.cpp -o while_loops
./while_loops

示例输出：

Counting from 1 to 5:
1 2 3 4 5
Enter a number between 1 and 10: 15
Invalid input. Enter a number between 1 and 10: 7
You entered a valid number: 7
Calculating factorial of 5:
5! = 120

while 循环的关键特性：

每次迭代前检查条件
如果初始条件为假，循环可能不会执行
需要手动递增/更新循环变量
适用于迭代次数事先未知的情况

while 循环的重要组件：

在循环前初始化循环变量
控制循环执行的条件
在循环体内更新循环变量

实现带有出口控制逻辑的 do-while 循环

在这一步中，你将学习 C++ 中的 do-while 循环。与 while 循环不同，do-while 循环是出口控制的，这意味着在执行循环体后会检查条件。这确保了无论初始条件如何，循环体至少会执行一次。

首先，导航到项目目录并创建一个新的 C++ 文件：

cd ~/project
touch do_while_loops.cpp

在 WebIDE 中打开 do_while_loops.cpp 文件，并添加以下代码以探索使用 do-while 循环的不同方式：

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // 用于用户输入验证的基本 do-while 循环
    int userNumber;
    do {
        std::cout << "Enter a number between 1 and 10: ";
        std::cin >> userNumber;
    } while (userNumber < 1 || userNumber > 10);
    std::cout << "You entered a valid number: " << userNumber << std::endl;

    // 模拟掷骰子游戏
    srand(time(0));  // 随机数生成种子
    int attempts = 0;
    int targetNumber = 6;
    int diceRoll;

    std::cout << "Dice Rolling Game:" << std::endl;
    do {
        diceRoll = rand() % 6 + 1;  // 生成 1 到 6 之间的随机数
        attempts++;
        std::cout << "Roll " << attempts << ": You rolled " << diceRoll << std::endl;
    } while (diceRoll != targetNumber);

    std::cout << "Congratulations! You rolled the target number "
              << targetNumber << " in " << attempts << " attempts." << std::endl;

    return 0;
}

编译并运行程序：

g++ do_while_loops.cpp -o do_while_loops
./do_while_loops

示例输出：

Enter a number between 1 and 10: 15
Enter a number between 1 and 10: 7
You entered a valid number: 7
Dice Rolling Game:
Roll 1: You rolled 1
Roll 2: You rolled 5
Roll 3: You rolled 2
Roll 4: You rolled 5
Roll 5: You rolled 5
Roll 6: You rolled 3
Roll 7: You rolled 4
Roll 8: You rolled 2
Roll 9: You rolled 2
Roll 10: You rolled 2
Roll 11: You rolled 2
Roll 12: You rolled 2
Roll 13: You rolled 1
Roll 14: You rolled 1
Roll 15: You rolled 6
Congratulations! You rolled the target number 6 in 15 attempts.

do-while 循环的关键特性：

在执行循环体后检查条件
确保循环体至少执行一次
适用于输入验证和游戏场景
语法与 while 循环不同，条件在末尾检查

do-while 循环的重要组件：

do 关键字开始循环体
循环体至少执行一次
while 条件在每次迭代后评估
while 条件后需要分号 ;

使用 break 提前退出循环

在这一步中，你将学习如何在 C++ 中使用 break 语句提前退出循环。break 语句允许你立即终止循环，并将控制权转移到循环后的第一条语句。

首先，导航到项目目录并创建一个新的 C++ 文件：

cd ~/project
touch break_statement.cpp

在 WebIDE 中打开 break_statement.cpp 文件，并添加以下代码以探索使用 break 语句的不同方式：

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // 当满足条件时从 for 循环中退出
    std::cout << "Finding the first even number:" << std::endl;
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            std::cout << "First even number found: " << i << std::endl;
            break;
        }
    }

    // 模拟数字猜测游戏
    srand(time(0));  // 随机数生成种子
    int targetNumber = rand() % 10 + 1;  // 生成 1 到 10 之间的随机数
    int guess;
    int attempts = 0;

    std::cout << "\nNumber Guessing Game:" << std::endl;
    while (true) {
        std::cout << "Enter your guess (1-10): ";
        std::cin >> guess;
        attempts++;

        if (guess == targetNumber) {
            std::cout << "Congratulations! You guessed the number in "
                      << attempts << " attempts." << std::endl;
            break;
        } else if (guess < targetNumber) {
            std::cout << "Too low. Try again." << std::endl;
        } else {
            std::cout << "Too high. Try again." << std::endl;
        }
    }

    return 0;
}

编译并运行程序：

g++ break_statement.cpp -o break_statement
./break_statement

示例输出：

Finding the first even number:
First even number found: 2

Number Guessing Game:
Enter your guess (1-10): 5
Too low. Try again.
Enter your guess (1-10): 8
Too high. Try again.
Enter your guess (1-10): 6
Congratulations! You guessed the number in 3 attempts.

break 语句的关键特性：

立即终止最内层的循环
将控制权转移到循环后的第一条语句
可以在 for、while 和 do-while 循环中使用
适用于基于条件的提前循环终止

break 语句的重要用途：

当满足特定条件时退出循环
实现搜索算法
创建具有用户输入的交互式程序
防止不必要的迭代

使用 continue 语句跳过循环迭代

在这一步中，你将学习如何在 C++ 中使用 continue 语句跳过当前循环迭代并进入下一次迭代。continue 语句允许你根据特定条件选择性地跳过循环的某些部分。

首先，导航到项目目录并创建一个新的 C++ 文件：

cd ~/project
touch continue_statement.cpp

在 WebIDE 中打开 continue_statement.cpp 文件，并添加以下代码以探索使用 continue 语句的不同方式：

#include <iostream>

int main() {
    // 在循环中跳过偶数
    std::cout << "Printing odd numbers between 1 and 10:" << std::endl;
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            continue;  // 跳过偶数
        }
        std::cout << i << " ";
    }
    std::cout << std::endl;

    // 在求和计算中过滤掉负数
    int sum = 0;
    int numbers[] = {5, -3, 10, -7, 8, -2, 15};
    int arraySize = sizeof(numbers) / sizeof(numbers[0]);

    std::cout << "\nCalculating sum of positive numbers:" << std::endl;
    for (int j = 0; j < arraySize; j++) {
        if (numbers[j] < 0) {
            continue;  // 跳过负数
        }
        sum += numbers[j];
        std::cout << "Added: " << numbers[j] << ", Current Sum: " << sum << std::endl;
    }
    std::cout << "Final Sum of Positive Numbers: " << sum << std::endl;

    return 0;
}

编译并运行程序：

g++ continue_statement.cpp -o continue_statement
./continue_statement

示例输出：

Printing odd numbers between 1 and 10:
1 3 5 7 9

Calculating sum of positive numbers:
Added: 5, Current Sum: 5
Added: 10, Current Sum: 15
Added: 8, Current Sum: 23
Added: 15, Current Sum: 38
Final Sum of Positive Numbers: 38

continue 语句的关键特性：

跳过当前循环迭代的剩余部分
将控制权转移到循环的下一次迭代
可以在 for、while 和 do-while 循环中使用
适用于过滤或条件处理

continue 语句的重要用途：

根据条件跳过特定迭代
在循环中过滤数据
避免不必要的计算
简化循环逻辑

创建嵌套循环以进行矩阵操作

在这一步中，你将学习如何使用嵌套循环在 C++ 中对二维数组（矩阵）执行操作。嵌套循环允许你遍历矩阵的行和列，从而实现复杂的数据操作和计算。

首先，导航到项目目录并创建一个新的 C++ 文件：

cd ~/project
touch nested_loops.cpp

在 WebIDE 中打开 nested_loops.cpp 文件，并添加以下代码以探索使用嵌套循环进行矩阵操作：

#include <iostream>
#include <iomanip>

int main() {
    // 定义一个 3x3 矩阵
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // 打印原始矩阵
    std::cout << "Original Matrix:" << std::endl;
    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 3; col++) {
            std::cout << std::setw(4) << matrix[row][col];
        }
        std::cout << std::endl;
    }

    // 计算行和
    std::cout << "\nRow Sums:" << std::endl;
    for (int row = 0; row < 3; row++) {
        int rowSum = 0;
        for (int col = 0; col < 3; col++) {
            rowSum += matrix[row][col];
        }
        std::cout << "Row " << row + 1 << " Sum: " << rowSum << std::endl;
    }

    // 创建并打印乘法表
    std::cout << "\nMultiplication Table:" << std::endl;
    for (int i = 1; i <= 5; i++) {
        for (int j = 1; j <= 5; j++) {
            std::cout << std::setw(4) << (i * j);
        }
        std::cout << std::endl;
    }

    return 0;
}

编译并运行程序：

g++ nested_loops.cpp -o nested_loops
./nested_loops

示例输出：

Original Matrix:
   1   2   3
   4   5   6
   7   8   9

Row Sums:
Row 1 Sum: 6
Row 2 Sum: 15
Row 3 Sum: 24

Multiplication Table:
   1   2   3   4   5
   2   4   6   8  10
   3   6   9  12  15
   4   8  12  16  20
   5  10  15  20  25

嵌套循环的关键特性：

内层循环在外层循环的每次迭代中完成所有迭代
适用于处理多维数组
可用于创建复杂模式和执行矩阵操作
通常用于二维数组（矩阵）和多维数据结构

嵌套循环的重要概念：

外层循环控制内层循环的执行次数
每个循环都有自己的计数器变量
适用于基于行和列的操作
可用于生成模式、执行计算和操作数据

处理无限循环的预防措施

在这一步中，你将学习如何通过实现适当的循环控制机制来防止 C++ 中的无限循环。当循环的条件永远不会变为假时，就会发生无限循环，导致程序无限运行。

首先，导航到项目目录并创建一个新的 C++ 文件：

cd ~/project
touch infinite_loop_prevention.cpp

在 WebIDE 中打开 infinite_loop_prevention.cpp 文件，并添加以下代码以探索防止无限循环的不同策略：

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // 示例 1：通过最大迭代次数限制防止无限循环
    std::cout << "Example 1: Iteration Limit Prevention" << std::endl;
    int counter = 0;
    const int MAX_ITERATIONS = 5;

    while (true) {
        std::cout << "Iteration: " << counter + 1 << std::endl;
        counter++;

        if (counter >= MAX_ITERATIONS) {
            std::cout << "Maximum iterations reached. Breaking the loop." << std::endl;
            break;
        }
    }

    // 示例 2：用户控制的循环与输入验证
    std::cout << "\nExample 2: User-Controlled Loop" << std::endl;
    char continueChoice;
    int attempts = 0;
    const int MAX_ATTEMPTS = 3;

    do {
        std::cout << "Enter a number (1-10): ";
        int userNumber;
        std::cin >> userNumber;

        if (userNumber >= 1 && userNumber <= 10) {
            std::cout << "Valid number entered: " << userNumber << std::endl;
            break;
        }

        attempts++;
        std::cout << "Invalid input. Attempts left: " << MAX_ATTEMPTS - attempts << std::endl;

        if (attempts >= MAX_ATTEMPTS) {
            std::cout << "Maximum attempts reached. Exiting." << std::endl;
            break;
        }

        std::cout << "Do you want to try again? (y/n): ";
        std::cin >> continueChoice;
    } while (continueChoice == 'y' || continueChoice == 'Y');

    // 示例 3：带有控制迭代次数的随机数游戏
    std::cout << "\nExample 3: Random Number Game" << std::endl;
    srand(time(0));  // 随机数生成种子
    int targetNumber = rand() % 10 + 1;
    int guess;
    int gameAttempts = 0;
    const int MAX_GAME_ATTEMPTS = 4;

    std::cout << "Guess the number between 1 and 10" << std::endl;
    while (gameAttempts < MAX_GAME_ATTEMPTS) {
        std::cout << "Attempt " << gameAttempts + 1 << ": Enter your guess: ";
        std::cin >> guess;

        if (guess == targetNumber) {
            std::cout << "Congratulations! You guessed the number." << std::endl;
            break;
        }

        gameAttempts++;

        if (gameAttempts >= MAX_GAME_ATTEMPTS) {
            std::cout << "Sorry, you've run out of attempts. The number was "
                      << targetNumber << std::endl;
            break;
        }
    }

    return 0;
}

编译并运行程序：

g++ infinite_loop_prevention.cpp -o infinite_loop_prevention
./infinite_loop_prevention

示例输出：

Example 1: Iteration Limit Prevention
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4
Iteration: 5
Maximum iterations reached. Breaking the loop.

Example 2: User-Controlled Loop
Enter a number (1-10): 1
Valid number entered: 1

Example 3: Random Number Game
Guess the number between 1 and 10
Attempt 1: Enter your guess: 2
Attempt 2: Enter your guess: 3
Attempt 3: Enter your guess: 4
Attempt 4: Enter your guess: 5
Sorry, you've run out of attempts. The number was 8

防止无限循环的关键策略：

设置最大迭代次数限制
使用 break 语句退出循环
实现输入验证
添加条件检查以控制循环执行
提供用户控制机制

重要的无限循环预防技术：

始终确保循环条件可以变为假
使用计数器变量限制迭代次数
在循环内实现退出条件
验证用户输入
在需要时使用 break 退出循环

总结

在本实验中，你学习了如何在 C++ 中实现各种控制流结构，包括单分支和多分支的 if-else 语句、switch 语句、计数器控制的 for 循环、入口控制的 while 循环、出口控制的 do-while 循环以及嵌套循环。你探索了如何使用 break 和 continue 语句来控制循环的执行，并学习了处理无限循环的技术。这些控制流结构是 C++ 编程的基础，使你能够编写更复杂和动态的程序，这些程序可以根据特定条件做出决策并执行不同的代码路径。

本实验通过动手编码练习涵盖了这些控制流结构的实际应用，使你能够更深入地理解它们的用法，并能够在自己的 C++ 项目中有效地应用它们。