C++学习之程序流程结构-阿里云开发者社区

程序流程结构分类

C++程序的流程结构主要由顺序结构、选择结构和循环结构组成。下面是每种结构的简单介绍：

顺序结构：顺序结构是程序中最简单的结构，按照代码在源文件中的顺序依次执行，没有任何条件或控制语句来改变程序的执行路径。
选择结构：选择结构根据某个条件的真假情况选择不同的执行路径。在C++中，常见的选择结构有if语句、if-else语句和switch语句。根据条件的判断结果，程序会按照不同的代码块来执行。
循环结构：循环结构用于重复执行一段代码块，直到满足某个条件后结束循环。在C++中，常见的循环结构有while循环、do-while循环和for循环。这些结构根据条件的真假情况决定是否重复执行循环体。

除了上述基本的流程结构，C++还提供了一些其他的控制结构，如break语句和continue语句。break语句用于中断当前循环或switch语句的执行，跳出循环体或选项执行流程。而continue语句用于终止当前迭代的循环，并开始下一次循环迭代。

顺序结构

C++的顺序结构简单来说就是按照代码的顺序一行一行地执行，没有分支和循环。下面是一个简单的C++程序示例，展示了顺序结构的应用：

#include <iostream>
int main() {
    int num1, num2, sum;
    std::cout << "Enter two numbers: ";
    std::cin >> num1 >> num2;
    sum = num1 + num2;
    std::cout << "The sum is: " << sum << std::endl;
    return 0;
}

在这个示例中，程序首先向用户请求输入两个数字，然后将这两个数字相加，并将结果输出到控制台。整个程序按照代码的顺序从上到下依次执行，没有分支或循环的干涉。

具体的执行过程如下：

程序运行后，首先打印出提示信息："Enter two numbers: "。
接着，程序等待用户输入两个数字，并将这两个数字分别赋值给变量num1和num2。
程序执行sum = num1 + num2;语句，将num1和num2的和赋值给变量sum。
最后，程序通过std::cout将计算得到的和打印到屏幕上，输出形如"The sum is: XXX"的信息。
程序执行到return 0;时，表示程序成功结束。

C++的顺序结构基本上就是按照代码的顺序依次执行各个语句，以完成特定的任务。

选择结构

C++提供了几种常见的选择结构，用于根据不同的条件选择不同的执行路径。以下是一些常见的C++选择结构和举例：

if语句：if语句根据给定的条件来判断是否执行某段代码。

int num = 10;
if (num > 0) {
    std::cout << "The number is positive." << std::endl;
}

在这个示例中，如果num大于0，则会执行if语句块内的代码，并输出"The number is positive."。

if-else语句：if-else语句扩展了if语句的功能，允许在给定条件为true或false时执行不同的代码块。

int num = 10;
if (num > 0) {
    std::cout << "The number is positive." << std::endl;
} else {
    std::cout << "The number is non-positive." << std::endl;
}

在这个示例中，如果num大于0，则执行if语句块内的代码；否则，执行else语句块内的代码。输出结果取决于条件的真假情况。

if-else if-else语句：通过嵌套多个if-else语句，可以在多个条件之间进行选择。

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

在这个示例中，根据不同的成绩范围给出不同的评级。根据变量score的值，程序会按照条件从上到下依次判断，并输出相应的评级。

switch语句：switch语句允许根据一个表达式的值在多个选项之间进行选择。

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;
    default:
        std::cout << "Invalid day" << std::endl;
}

在这个示例中，根据变量day的值，程序将进入相应的case分支，并执行相应的代码块。如果没有匹配的case，程序将执行default分支的代码块。

选择结构嵌套

各种选择结构可以相互嵌套，以实现更复杂的逻辑判断和流程控制。以下是几个选择结构嵌套的例子：

if-else语句嵌套：

int num = 10;
if (num > 0) {
    std::cout << "The number is positive." << std::endl;
} else {
    if (num < 0) {
        std::cout << "The number is negative." << std::endl;
    } else {
        std::cout << "The number is zero." << std::endl;
    }
}

在这个例子中，首先判断num是否大于0，如果是，则输出"The number is positive.“；如果不是，则判断num是否小于0，如果小于0，则输出"The number is negative.”；否则，输出"The number is zero."。

if-else if-else语句嵌套：

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

在这个例子中，首先判断score是否大于等于90，如果是，则输出"A"；否则，判断score是否大于等于80，如果是，则输出"B"；否则，判断score是否大于等于70，如果是，则输出"C"；否则，输出"D"。

switch语句嵌套：

int day = 3;
int month = 2;
switch (month) {
    case 1:
        std::cout << "January " << day << std::endl;
        break;
    case 2:
        switch (day) {
            case 28:
                std::cout << "February (28 days)" << std::endl;
                break;
            case 29:
                std::cout << "February (29 days)" << std::endl;
                break;
            default:
                std::cout << "Invalid day for February" << std::endl;
        }
        break;
    default:
        std::cout << "Invalid month" << std::endl;
}

在这个例子中，首先判断month的值是不是1，如果是，则输出"January"加上具体的day值；否则，如果month的值是2，再根据day的值来确定是输出"February (28 days)“还是"February (29 days)”；如果month的值既不是1也不是2，则输出"Invalid month"。

循环结构

C++提供了几种常见的循环结构，用于重复执行一段代码块。以下是C++中常用的循环结构和举例：

while循环：while循环会在给定条件为true时重复执行一段代码块。

int count = 0;
while (count <= 5) {
    std::cout << "Count: " << count << std::endl;
    count++;
}

在这个示例中，循环将持续执行，直到count变量的值大于5。每次循环，程序输出当前count的值，并将count递增1。

do-while循环：do-while循环与while循环类似，但是它会先执行一次循环体，然后再根据给定条件来判断是否继续执行。

int num = 1;
do {
    std::cout << "Number: " << num << std::endl;
    num++;
} while (num <= 5);

在这个示例中，循环体首先执行一次，然后检查条件。如果条件为真，则继续执行循环体，直到num的值大于5。

for循环：for循环提供了一种简洁的方式来重复执行一段代码块，它包含了初始化、条件和更新三个部分。

for (int i = 0; i < 5; i++) {
    std::cout << "Iteration: " << i << std::endl;
}

在这个示例中，循环通过初始化i为0，然后在每次循环迭代时检查i是否小于5，并在每次迭代结束后将i递增1。循环将执行5次，从0到4。

这些是C++中常见的循环结构。根据需要和实际情况，可以使用这些结构来实现重复执行特定代码块的需求。

循环结构嵌套

各种循环结构可以嵌套在彼此之中，以实现更复杂的重复执行和控制流程。以下是几个常见的循环结构嵌套的例子：

while循环嵌套：

int i = 1;
int j = 1;
while (i <= 5) {
    while (j <= i) {
        std::cout << j << " ";
        j++;
    }
    std::cout << std::endl;
    i++;
    j = 1;
}

在这个例子中，外层的while循环每次执行一行，内层的while循环负责输出一行中的数字。循环嵌套会依次输出如下结果：

for循环嵌套：

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

在这个例子中，外层的for循环定义了变量i，内层的for循环定义了变量j。循环嵌套会输出如下结果：

(1, 1)
(1, 2)
(1, 3)
(2, 1)
(2, 2)
(2, 3)
(3, 1)
(3, 2)
(3, 3)

do-while循环嵌套：

int i = 1;
int j = 1;
do {
    do {
        std::cout << i * j << " ";
        j++;
    } while (j <= 5);
    std::cout << std::endl;
    i++;
    j = 1;
} while (i <= 5);

在这个例子中，外层的do-while循环每次执行一行，内层的do-while循环负责输出一行中的乘积。循环嵌套会输出如下结果：

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

这些例子展示了循环结构的嵌套使用，可以通过多层次的循环来实现复杂的循环逻辑和控制流程。

特殊的选择结构和循环结构

除了常见的选择结构和循环结构之外，还有一些特殊的选择结构和循环结构，用于解决特定的问题或实现特定的逻辑。以下是几个特殊的选择结构和循环结构：

特殊的选择结构：

三元运算符（Ternary operator）：它是一种简洁的条件选择结构，形式为条件 ? 表达式1 : 表达式2，根据条件的真假选择不同的表达式执行。

int num = (score >= 60) ? 1 : 0;

在这个例子中，如果score大于等于60，则num被赋值为1，否则赋值为0。

特殊的循环结构：

foreach循环：用于遍历容器（如数组、集合等）中的元素，不需要事先指定结束条件，可以自动遍历容器中的每个元素。

int arr[] = {1, 2, 3, 4, 5};
for (int element : arr) {
    std::cout << element << " ";
}

在这个例子中，foreach循环会依次遍历数组arr中的元素，并输出每个元素的值。

range-based for循环：类似于foreach循环，用于遍历序列容器（如数组、容器类等）中的元素，可以自动遍历序列容器中的每个元素，并且可以通过引用修改元素的值。

std::vector<int> nums = {1, 2, 3, 4, 5};
for (int& num : nums) {
    num *= 2;
}

在这个例子中，range-based for循环会遍历向量nums中的元素，并将每个元素的值乘以2。

这些特殊的选择结构和循环结构提供了在某些情况下更方便和高效的方式来处理特定的需求。

跳转结构

跳转结构是一种特殊的控制结构，用于在程序中实现非顺序执行的流程。主要有以下几种类型的跳转结构：

break语句：在循环或者switch语句中使用，用于立即终止循环或者跳出switch语句。

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

在这个例子中，当i等于3时，break语句会跳出循环，输出结果为：

1 2

continue语句：在循环中使用，用于跳过当前迭代并继续下一次迭代。

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

在这个例子中，当i等于3时，continue语句会跳过当前迭代，输出结果为：

1 2 4 5

goto语句：可以直接跳转到程序中指定的标签处，它可以使代码执行从goto语句的位置无条件地转移到目标标签所在的位置。

goto跳转知道就行了，最好少用或者别用；

goto my_label;
std::cout << "This will not be executed." << std::endl;
my_label:
std::cout << "Jumped to the label." << std::endl;

在这个例子中，goto语句会直接跳转到标签my_label处，输出结果为：

Jumped to the label.

虽然跳转结构在某些情况下可以帮助控制程序的流程，但过度使用跳转结构可能会导致代码难以理解和维护。因此，在实际编程中应谨慎使用跳转结构，并确保合理、清晰地组织代码逻辑。

#include <iostream>
int main() {
    std::cout << "程序流程结构其实都是大同小异，除了个别的：例如goto !" << std::endl;
    return 0;
}

关注我，不迷路，共学习，同进步

关注我，不迷路，同学习，同进步

C++学习之程序流程结构