# C++的程序流程结构

# 1. 程序流程结构

① C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构

1. 顺序结构：程序按顺序执行，不发生跳转
2. 选择结构：依据条件是否满足，有选择的执行相应功能
3. 循环结构：依据条件是否满足，循环多次执行某段代码

# 2. 选择结构

## 2.1 单行 if 语句

① 单行if语句，格式：if(条件){条件满足执行的语句}


```python
#include <iostream>
using namespace std;

int main()
{

    // 选择结构 单行if语句
    // 用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出

    //1、用户输入分数
    int score = 0;

    cout << "请输入一个分数：" << endl;  //在C++中除了0，都为真
    cin >> score;

    //2、打印用户输入的分数

    cout << "您输入的分数为 ：" << score << endl;

    //3、判断分数是否大于600，如果大于，那么输出
    //注意事项，if条件后面不要加分号。加了分号条件不管满足还是不满足，后面的都会运行
    if (score > 600)
    {
        cout << "恭喜您考上了一本大学" << endl;
    }

    system("pause");

    return 0;

}
```

运行结果：  
 - 请输入一个分数：  
 - 611  
 - 您输入的分数为 ：611  
 - 恭喜您考上了一本大学  
 - 请按任意键继续. . .

## 2.2 单行 else 语句

① 单行else语句，格式：if(条件){条件满足执行的语句} else{条件不满足执行的语句}


```python
#include <iostream>
using namespace std;

int main()
{

    // 选择结构 多行if语句
    // 输入考试分数，如果分数大于600，视为考上一本大学，在屏幕上输出
    // 如果没考上一本大学，打印未考上一本大学

    //1、输入考试分数
    int score = 0;
    cout << "请输入一个考试分数" << endl;
    cin >> score;

    //2、提示用户输入的分数
    cout << "您输入的分数为：" << score << endl;

    //3、判断 如果大于600，打印考上一本，否则打印未考上一本大学
    if (score > 600) //大于600分，执行下面大括号中内容
    {
        cout << "恭喜您考上了一本大学" << endl;
    }
    else //不大于600分，执行else后大括号中内容
    {
        cout << "未考上一本大学" << endl;
    }

    system("pause");

    return 0;

}
```

运行结果：  
 - 请输入一个考试分数  
 - 490  
 - 您输入的分数为：490  
 - 未考上一本大学  
 - 请按任意键继续. . .

## 2.3 多条件的 if 语句

① 多条件的if语句，格式：if(条件1){条件1满足执行的语句}else if(条件){条件2满足执行的语句}....else{都不满足时执行的语句}


```python
#include <iostream>
using namespace std;

int main()
{
    // 选择结构 多条件if语句
    // 输入一个考试分数，
    // 如果分数大于600，视为考上一本大学，在屏幕上输出
    // 如果分数大于500，视为考上二本大学，在屏幕上输出
    // 如果分数大于400，视为考上三本大学，在屏幕上输出
    // 如果小于等于400，视为未考上本科，屏幕上输出

    //1、输入考试分数
    int score = 0;
    cout << "请输入一个考试分数" << endl;
    cin >> score;

    //2、提示用户输入的分数
    cout << "您输入的分数为：" << score << endl;

    //3、判断 
    // 如果大于600，考上一本
    // 如果大于500，考上二本
    // 如果大于400，考上三本
    // 如果小于等于400，未考上本科
    if (score > 600) 
    {
        cout << "恭喜您考上了一本大学" << endl;
    }
    else if (score > 500) 
    {
        cout << "恭喜您考上了二本大学" << endl;
    }
    else if (score > 400) 
    {
        cout << "恭喜您考上了三本大学" << endl;
    }
    else 
    {
        cout << "未考上本科大学" << endl;
    }
    
    system("pause");
    
    return 0;

}
```

运行结果：  
 - 请输入一个考试分数  
 - 430  
 - 您输入的分数为：430  
 - 恭喜您考上了三本大学  
 - 请按任意键继续. . .

## 2.4 嵌套 if 语句

① 嵌套if语句，在if语句中可以嵌套使用if语句，达到更精确的条件判断。


```python
#include <iostream>
using namespace std;

int main()
{

    // 选择结构 嵌套if语句

    //1、提示高考分数
    int score = 0;
    cout << "请输入一个考试分数" << endl;
    cin >> score;

    //2、提示用户输入的分数
    cout << "您输入的分数为：" << score << endl;

    //3、判断 
    if (score > 600) 
    {
        cout << "恭喜您考上了一本大学" << endl;
        if (score > 700)
        {
            cout << "您能考上了北京大学" << endl;
        }
        else if (score > 650)
        {
            cout << "您能考上了清华大学" << endl;
        }
        else
        {
            cout << "您能考上了人名大学" << endl;
        }
    }
    else if (score > 500)
    {
        cout << "恭喜您考上了二本大学" << endl;
    }
    else if (score > 400)
    {
        cout << "恭喜您考上了三本大学" << endl;
    }
    else
    {
        cout << "未考上本科大学" << endl;
    }

    system("pause");

    return 0;

}
```

运行结果：  
 - 请输入一个考试分数  
 - 670  
 - 您输入的分数为：670  
 - 恭喜您考上了一本大学  
 - 您能考上了清华大学  
 - 请按任意键继续. . .

## 2.5 三目运算符

① 作用：通过三目运算符实现简单的判断。

② 语法：表达式1 ? 表达式2 : 表达式3

1. 如果表达式1的值为真，执行表达式2，并返回表达式2的结果。
2. 如果表达式1的值为假，执行表达式3，并返回表达式3的结果。

③ 三目运算符可以用在显示语句中，cout << "c = " << c == 1 ? "男" : "女" << endl。


```python
#include <iostream>
using namespace std;

int main()
{
    // 创建三个变量 a b c
    // 将a和b做比较，将变量大的值赋值给变量c

    int a = 10;
    int b = 20;
    int c = 0;

    c = (a > b ? a : b); //可以将运算的结果的变量的值赋值给变量

    cout << "c = " << c << endl;

    //在C++中三目运算符返回的是变量，可以继续赋值
    (a > b ? a : b) = 100;
    cout << "a = " << a << endl;  //可以将运算的结果右值作为变量来赋值
    cout << "b = " << b << endl;

    system("pause");

    return 0;

}
```

运行结果：  
 - c = 20  
 - a = 10  
 - b = 100  
 - 请按任意键继续. . .

## 2.6 switch 语句

① switch语句用于执行多条件分支语句。

② switch语句中表达式类型只能是整型或者字符型。

③ case里如果没有break，那么程序会一直向下执行。

④ 与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间。


```python
#include <iostream>
using namespace std;

int main()
{
    //1、提示用户给电影评分
    cout << "请给电影进行评分" << endl;

    //2、用户开始进行打分
    int score = 0;
    cin >> score;
    cout << "您打的分数为：" << score << endl;

    //3、根据用户输入的分数来提示用户最后的结果
    switch (score)
    {
    case 10:
        cout << "您认为是经典的电影" << endl; 
        break;
    case 9:
        cout << "您认为是经典的电影" << endl;
        break;
    case 8:
        cout << "您认为电影非常好" << endl;
        break;
    case 7:
        cout << "您认为电影还行" << endl;
        break;
    case 6:
        cout << "您认为电影一般" << endl;
        break;
    default:  //前面都不满足，就会执行default语句
        cout << "您认为电影是烂片" << endl;
        break;
    }

    //if 和 switch 区别：
    //switch 缺点，判断的时候只能是整型或者字符型，不可以是一个区间。
    //switch 优点，结构清晰，执行效率高。
    system("pause");

    return 0;

}
```

运行结果：  
 - 请给电影进行评分  
 - 8  
 - 您打的分数为：8  
 - 您认为电影非常好  
 - 请按任意键继续. . .

## 2.7 三只小猪称体重

题目：现有三只小猪ABC，请分别输入三只小猪的体重，并且判断哪只小猪最重。


```python
#include <iostream>
using namespace std;

int main()
{
    //三只小猪称体重，判断哪只最重

    //1、创建三只小猪的体重变量
    int num1 = 0;
    int num2 = 0;
    int num3 = 0;

    //2、让用户输入三只小猪的重量
    cout << "请输入小猪A的体重" << endl;
    cin >> num1;

    cout << "请输入小猪B的体重" << endl;
    cin >> num2;

    cout << "请输入小猪C的体重" << endl;
    cin >> num3;

    cout << "小猪A的体重为：" << num1 << endl;
    cout << "小猪B的体重为：" << num2 << endl;
    cout << "小猪C的体重为：" << num3 << endl;

    //3、判断哪只最重
    //先判断A和B重量
    if (num1 > num2)  //A比B重
    {
        if (num1 > num3)  //A比C重
        {
            cout << "小猪A最重" << endl;
        }
        else
        {
            cout << "小猪C最重" << endl;
        }
    }
    else  //B比A重
    {
        if (num2 > num3)  //B比C重
        {
            cout << "小猪B最重" << endl;
        }
        else //C比B重
        {
            cout << "小猪C最重" << endl;
        }
    }

    system("pause");
    
    return 0;

}
```

运行结果：  
 - 请输入小猪A的体重  
 - 100  
 - 请输入小猪B的体重  
 - 230  
 - 请输入小猪C的体重  
 - 300  
 - 小猪A的体重为：100  
 - 小猪B的体重为：230  
 - 小猪C的体重为：300  
 - 小猪C最重  
 - 请按任意键继续. . .

# 3. 循环结构

## 3.1 while 语句

① 作用：满足循环条件时，执行循环语句。

② 语法：while(循环条件) {循环语句}。

③ 解释：只要循环条件的结果为真，就执行循环语句。


```python
#include <iostream>
using namespace std;

int main()
{
    //while循环
    //在屏幕中打印 0~9 这10个数字
    int num = 0;

    //while()中填入循环条件
    //在写循环的时候，一定要避免死循环的出现
    while (num < 10)  //如果循环条件写1，为表示死循环，一直循环下去
    {
        cout << num << endl;
        num++;
    }

    // 在执行循环语句时候，程序必须提供跳出循环的出口，否则出现死循环。

    system("pause");

    return 0;

}
```

运行结果：  
 - 0  
 - 1  
 - 2  
 - 3  
 - 4  
 - 5  
 - 6  
 - 7  
 - 8  
 - 9  
 - 请按任意键继续. . .

## 3.2 do while 语句

① 满足循环条件，执行循环语句。

② 语法：do{循环语句} while(循环条件);

③ 与while的区别在于 do...while会先执行一次循环语句，再判断循环条件。


```python
#include <iostream>
using namespace std;

int main()
{
    //do...while语句
    //在屏幕中输出 0 到 9 这10个数字

    int num = 0;
    do
    {
        cout << num << endl;
        num++;
    } 
    while (num < 10);

    //do...while和while循环区别在于 do...while会先执行一次循环语句
    system("pause");

    return 0;

}
```

运行结果：  
 - 0  
 - 1  
 - 2  
 - 3  
 - 4  
 - 5  
 - 6  
 - 7  
 - 8  
 - 9  
 - 请按任意键继续. . .

## 3.3 for 语句

① for循环，满足循环条件，执行循环语句。

② for(起始表达式(①)；条件表达式②；末尾表达式③) { 循环语句④ }

1. 先执行①，初始化
2. 再执行②，进行判断
3. 再执行④，进行一次循环
4. 再执行③，执行一次末尾表达式

③ for循环中的表达式，要用分号进行分隔。

④ while、for...while、for都是开发中常用的循环语句，for循环结构比较清晰，比较常用。


```python
#include <iostream>
using namespace std;

int main()
{
    //for循环
    //从数字0 打印到 数字9

    for (int i = 0; i < 10; i++)
    {
        cout << i << endl;
    }

    /*
    第二种方式
    int i = 0
    for (; i < 10; i++)
    {
        cout << i << endl;
    }
    */


    /*
    第三种方式
    int i = 0
    for (; ; i++)
    {
        if(i >= 10)
        {
            break;
        }
        cout << i << endl;
    }
    */

    /*
    第四种方式
    int i = 0
    for (; ; )
    {
        if(i >= 10)
        {
            break;
        }
        cout << i << endl;
        i++;
    }
    */

    system("pause");

    return 0;

}
```

运行结果：  
 - 0  
 - 1  
 - 2  
 - 3  
 - 4  
 - 5  
 - 6  
 - 7  
 - 8  
 - 9  
 - 请按任意键继续. . .

## 3.4 for 嵌套

① 在循环体中再嵌套一层循环，可以解决一些实际问题，例如我们想在屏幕中打印十行十列的星图，就需要利用嵌套循环。


```python
#include <iostream>
using namespace std;

int main()
{
    //利用嵌套循环实现星图
    //外层执行一次，内层执行一周
    //外层循环
    for (int i = 0; i < 10; i++)
    {
        //内层循环
        for (int j = 0; j < 10; j++)
        {
            cout << "*";
        }
        cout << endl;
    }

    system("pause");
    return 0;

}
```

运行结果：  
     
    **********
    ********** 
    **********
    **********
    **********
    **********
    **********
    **********
    **********
    **********
    请按任意键继续. . .

## 3.5 猜数字

① 案例描述：系统随机生成一个1到100之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或过小，如果猜对恭喜玩家胜利，并且退出游戏。


```python
#include <iostream>
using namespace std;
#include<ctime> //time系统时间头文件

int main()
{
    //添加随机数种子，作用利用当前系统时间生成随机数，防止每次随机数都一样
    srand((unsigned int)time(NULL));

    //1、系统生成随机数
    int num = rand() % 100 + 1; //rand()%100 生成 0+1 ~ 99+1 随机数
    //cout << num << endl;      //不显示生成的随机数是多少

    //2、玩家进行猜测
    int val = 0;  //玩家输入的数据

    while (1)
    {
        cin >> val;

        //3、判断玩家的判断
        if (val > num)
        {
            cout << "猜测过大" << endl;
        }
        else if (val < num)
        {
            cout << "猜测过小" << endl;
        }
        else
        {
            cout << "猜测您猜对了" << endl;
            break;  //break在循环中，可以利用该关键字来退出当前循环
        }
    }
    

    system("pause");

    return 0;

}
```

运行结果：  
 - 32  
 - 猜测过小  
 - 60  
 - 猜测过大  
 - 54  
 - 猜测过大  
 - 40  
 - 猜测过大  
 - 38  
 - 猜测过大  
 - 35  
 - 猜测过大  
 - 33  
 - 猜测您猜对了  
 - 请按任意键继续. . .

## 3.6 水仙花数

案例描述：水仙花数是指一个3位数，它的每个位上的数字的3次幂之和等于它本身

例如：1^3 + 5^3 + 3^3 = 153

题目：请利用 do...while语句，求出所有3位数中的水仙花数


```python
#include <iostream>
using namespace std;

int main()
{
    //1、先打印所有的三位数字
    int num = 100;

    do
    {
        //2、从所有三位数中找到水仙花数
        int a = 0;  //个位
        int b = 0;  //十位
        int c = 0;  //百位

        a = num % 10; //获取数字的个位
        b = num / 10 % 10; //获取数字的十位
        c = num / 100; //获取数字的百位
        if (a * a * a + b * b * b + c*c*c== num) //如果是水仙花数，才打印
        {
            cout << num << endl;
        }
        num++;
    } while (num < 1000);

    system("pause");

    return 0;

}
```

运行结果：  
 - 153  
 - 370  
 - 371  
 - 407  
 - 请按任意键继续. . .

## 3.7 敲桌子

案例分析：从1开始数到数字100，如果数字个位含有7，或者数字十位含有7，或者该数字是7的倍数，我们打印敲桌子，其余数字直接打印输出。


```python
#include <iostream>
using namespace std;

int main()
{
    //敲桌子案例
    for (int i = 1; i <= 100; i++)
    {
        //2、从100个数字中找到特殊数字，打印“敲桌子”
        //如果是7的倍数、个位有7、或者十位有7，打印敲桌子
        if (i % 7 == 0 || i % 10 == 7 || i/10 == 7) //如果是特殊数字，打印敲桌子
        {
            cout << "敲桌子" << endl;
        }
        else //如果不是特殊数字，才打印数字
        {
            cout << i << endl;
        }
    }

    system("pause");
    return 0;

}
```

运行结果：  
 - 1  
 - 2  
 - 3  
 - 4  
 - 5  
 - 6  
 - 敲桌子  
 - 8  
 - 9  
 - 10  
 - 11  
 - 12  
 - 13  
 - 敲桌子  
 - 15  
 - 16  
 - 敲桌子  
 - 18  
 - 19  
 - 20  
 - 敲桌子  
 - 22  
 - 23  
 - 24  
 - 25  
 - 26  
 - 敲桌子  
 - 敲桌子  
 - 29  
 - 30  
 - 31  
 - 32  
 - 33  
 - 34  
 - 敲桌子  
 - 36  
 - 敲桌子  
 - 38  
 - 39  
 - 40  
 - 41  
 - 敲桌子  
 - 43  
 - 44  
 - 45  
 - 46  
 - 敲桌子  
 - 48  
 - 敲桌子  
 - 50  
 - 51  
 - 52  
 - 53  
 - 54  
 - 55  
 - 敲桌子  
 - 敲桌子  
 - 58  
 - 59  
 - 60  
 - 61  
 - 62  
 - 敲桌子  
 - 64  
 - 65  
 - 66  
 - 敲桌子  
 - 68  
 - 69  
 - 敲桌子  
 - 敲桌子  
 - 敲桌子  
 - 敲桌子  
 - 敲桌子  
 - 敲桌子  
 - 敲桌子  
 - 敲桌子  
 - 敲桌子  
 - 敲桌子  
 - 80  
 - 81  
 - 82  
 - 83  
 - 敲桌子  
 - 85  
 - 86  
 - 敲桌子  
 - 88  
 - 89  
 - 90  
 - 敲桌子  
 - 92  
 - 93  
 - 94  
 - 95  
 - 96  
 - 敲桌子  
 - 敲桌子  
 - 99  
 - 100  
 - 请按任意键继续. . .

## 3.8 乘法口诀

案例描述：利用嵌套循环，实现九九乘法表。


```python
#include <iostream>
using namespace std;

int main()
{
    //乘法口诀表
    for (int i = 1; i <= 9; i++)
    {
        for (int j = 1; j <= i; j++)
        {
            cout << j << "*" << i << "=" << j * i << " ";
        }
        cout << endl;
    }

    system("pause");
    return 0;

}
```

运行结果：
       
       1*1=1
       1*2=2 2*2=4
       1*3=3 2*3=6  3*3=9
       1*4=4 2*4=8  3*4=12 4*4=16 
       1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
       1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36  
       1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
       1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64       
       1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81          
       请按任意键继续. . .

# 4. 跳转语句

## 4.1 break 语句

① 用于跳出选择结构或者循环结构。

② break使用时机：

1. 出现在switch条件语句中，作用是终止case并跳出switch。
2. 出现在循环语句中，作用是跳出当前的循环语句。
3. 出现在嵌套循环中，跳出最近的内层循环语句。

③ break如果使用在switch-case中，并且case前面有一大段代码，就会报错，把前面一大堆代码用括号括起来{}，编译器认为是一段代码，就不会报错了。


```python
#include <iostream>
using namespace std;

int main()
{
    //break的使用时机

    //1、出现在switch语句中
    cout << "请选择副本难度" << endl;
    cout << "1、普通" << endl;
    cout << "2、中等" << endl;
    cout << "3、困难" << endl;

    int select = 0; 
    cin >> select; //等待用户输入

    switch (select)
    {
    case 1:
        cout << "您选择的是普通难度" << endl;
        break; //退出switch语句
    case 2:
        cout << "您选择的是中等难度" << endl;
        break;
    case 3:
        cout << "您选择的是困难难度" << endl;
        break;
    }

    //2、出现在循环语句中
    for (int i=0; i < 10; i++)
    {
        //如果i等于5，退出循环，不再打印
        if (i == 5)
        {
            break; //退出循环
        }
        cout << i << endl;
    }
    
    //3、出现在嵌套循环语句中
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            if (j == 5)
            {
                break; //退出内存循环
            }
            cout << "*";
        }
        cout << endl;
    }
    system("pause");
    return 0;

}
```

运行结果：  
 - 请选择副本难度  
 - 1、普通  
 - 2、中等  
 - 3、困难  
 - 2  
 - 您选择的是中等难度  
 - 0  
 - 1  
 - 2  
 - 3  
 - 4  
 - $*****$  
 - $*****$  
 - $*****$  
 - $*****$  
 - $*****$  
 - $*****$  
 - $*****$  
 - $*****$  
 - $*****$  
 - 请按任意键继续. . .

## 4.2 continue 语句

① 在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环。


```python
#include <iostream>
using namespace std;

int main()
{
    //continue的使用时机
    
    for (int i = 0; i <= 100; i++)
    {
        // 如果是奇数就输出，如果是偶数就不输出
        if (i % 2 == 0) 
        {
            continue; //continue可以筛选条件，执行到此就不再向下执行了，直接执行下一次循环
        }
        cout << i << endl;
        
    }

    system("pause");

    return 0;

}
```

运行结果：  
 - 1  
 - 3  
 - 5  
 - 7  
 - 9  
 - 11  
 - 13  
 - 15  
 - 17  
 - 19  
 - 21  
 - 23  
 - 25  
 - 27  
 - 29  
 - 31  
 - 33  
 - 35  
 - 37  
 - 39  
 - 41  
 - 43  
 - 45  
 - 47  
 - 49  
 - 51  
 - 53  
 - 55  
 - 57  
 - 59  
 - 61  
 - 63  
 - 65  
 - 67  
 - 69  
 - 71  
 - 73  
 - 75  
 - 77  
 - 79  
 - 81  
 - 83  
 - 85  
 - 87  
 - 89  
 - 91  
 - 93  
 - 95  
 - 97  
 - 99  
 - 请按任意键继续. . .

## 4.3 goto 语句

① 可以无条件跳转语句。

② 语法：goto 标记；

1. 如果标记名称存在，执行到goto语句时，会跳转到标记的位置。

③ 在程序中不建议使用goto语句，以免造成程序流程混乱。


```python
#include <iostream>
using namespace std;

int main()
{
    //continue的使用时机
    
    cout << "1" << endl;
    
    goto FLAG;  //这里是分号
    
    cout << "2" << endl;

    cout << "3" << endl;

    cout << "4" << endl;

    FLAG:  //这里是冒号

    cout << "5" << endl;

    cout << "6" << endl;

    system("pause");

    return 0;

}
```

运行结果：  
 - 1  
 - 5  
 - 6  
 - 请按任意键继续. . .