【详解C语言】深度解剖分支语句和循环语句

文章目录

• 💖本文目标
• 💖1. 什么是语句？
• 💖2. 分支语句（选择结构）
• • 💌2.1 if语句
  • • 2.1.1 基本语法
    • 2.1.2 else的匹配问题
    • 2.1.2 if书写形式的对比
  • 💌2.2 switch语句
  • • 2.2.1 内容介绍
    • 2.2.2 switch case 组合
    • 2.2.3 switch 语句中的 case
    • 2.2.4 switch 语句中的 break
    • 2.2.5 default 子句
    • 2.2.6 相关练习
    • switch 语句总结
• 💖3 . 循环语句
• • 💌3.1 while循环
  • • 3.1.1 while 语句中的 break 和 continue
    • • break 介绍:
      • continue 介绍
  • 💌3.2 for循环
  • • 3.2.1 语法
    • 3.2.2 break 和continue在for循环中
    • 3.2.3 for语句的循环控制变量
    • 3.2.4 一些for循环的变式
  • 💌3.3 do...while()循环
  • • 3.3.1 do语句的语法：
    • 3.3.2 执行流程
    • 3.3.3 do语句的特点
    • 3.3.4 do while 循环中的 break 和 continue
• 💖4. goto语句
• • • 4.1 作用
    • 4.2 基本使用
• 💖5. 语句的相关练习
• • • 5.1 二分法查找算法
    • 5.2 猜数字游戏
    • 5.3 关机程序

💖本文目标

分支语句和循环语句

分支语句

• if
• switch

循环语句

• while
• for
• do while

goto语句

---

💖1. 什么是语句？

C语言中由一个分号; 隔开的就是一条语句。

比如：

printf("hehe"); 
1+2; 

什么是表达式?

C语言中，用各种 *** 作符把变量连起来，形成有意义的式子，就叫做表达式。

C语句可分为以下五类：

1. 表达式语句

2. 函数调用语句

3. 控制语句

4. 复合语句

5. 空语句

控制语句用于控制程序的执行流程，以实现程序的各种结构方式，它们由特定的语句定义符组成，C语言有九种控制语句。

可分成以下三类：

1. 条件判断语句也叫分支语句：if语句、switch语句；
2. 循环执行语句：do while语句、while语句、for语句；
3. 转向语句：break语句、goto语句、continue语句、return语句。

---

💖2. 分支语句（选择结构）

如果选择在学校好好学习，校招时就能拿到一个好offer，走上人生巅峰。 如果选择天天遨游在召唤师峡谷，毕业等于失业，回家卖红薯。这就是选择！

💌2.1 if语句

那么if语句的语法结构是怎么样的呢？

2.1.1 基本语法

//1 
if(表达式) 
    语句; 

//2 
if(表达式) 
	语句1; 
else
    语句2; 

//3.多分支
if(表达式1)
    语句1;
else if(表达式2)
    语句2; 
else
    语句3;

//4. 嵌套 
if(表达式1)
{ 
    语句1; 
    if(表示式x)
    { 
        语句x; 
    }
    else
    {
        语句y; 
    } 
}
else if(表达式2)
{ 
    语句2; 
}
else
{
    语句3; 
}

演示代码：

如果表达式的结果为真，则语句执行。

#include 

int main()
{
    int age = 0; 
    scanf("%d", &age); 
    if(age<18)
    {
        printf("少年\n");
    }
    else if(age>=18 && age<30)
    {
        printf("青年\n");
    }
    else if(age>=30 && age<50)
    {
        printf("中年\n");
    }
    else if(age>=50 && age<80)
    {
        printf("老年\n");
    }
    else
    {
        printf("寿星\n");
    }
}

那么，在C语言中如何表示真假？

结论：

1. C语言中0表示假，非0表示真。

2. if语句执行，先执行完成表达式的值，得到逻辑结果，再进行判定。

   • 先执行（）中的表达式or函数，得到真假结果(true，false，逻辑结果)
   • 对条件结果 判定功能
   • 对语句进行 分支功能

如果条件成立，要执行多条语句，应该怎么使用代码块？

#include 
int main()
{
    if(表达式)
    {
        语句列表1；
    }
    else
    {
        语句列表2；
    }
    return 0;
}

这里的一对 { } 就是一个代码块。

注意：if 表达式后面";"表示一条语句，若是跟多条语句，必须用花括号 {} 括起来。

2.1.2 else的匹配问题

当你第一次看到下面这个代码，你或许会对他它输出有所争议：

#include 
int main()
{
    int a = 0;  
    int b = 2;  
    if(a == 1)
        if(b == 2)
            printf("hehe\n");
    else
        printf("haha\n");  
    return 0;
}

• 或许你会觉得这里会打印haha，因为第一个if明显判断不成立，所以程序直接跳转到else;
• 又或者，你会觉得这里会打印hehe，因为你觉得程序会继续往下走，很显然第二个if语句判断成立，所以打印hehe。

但事实上，程序的最终结果是：什么都不打印！

这是因为else的匹配：else是和它离的最近的if匹配的。

上述代码的实际效果其实是这样的：

#include 
int main()
{
    int a = 0;  
    int b = 2;  
    if(a == 1)//不成立，直接跳到return
    {
        if(b == 2)
        { 
            printf("hehe\n");
        }
        else
        {  
            printf("haha\n");  
        }
    }
    return 0;
}

改正代码：

#include 
int main()
{
    int a = 0;  
    int b = 2;  
    if(a == 1)
    {
        if(b == 2)
        {
            printf("hehe\n");
        }
    }
    else
    {
        printf("haha\n");
    }
    return 0;
}

结论：

• 适当的使用{}可以使代码的逻辑更加清楚。
• 代码风格很重要

2.1.2 if书写形式的对比

//代码1
if (condition) 
{  
    return x;
}
return y;

// 代 码 2  
if(condition)
{
    return x;
}
else
{
    return y;
}

代码2更好，逻辑更加清晰，不容易出错。

//代码3
int num = 1;  
if(num == 5)
{
    printf("hehe\n");
}

//代码4
int num = 1;  
if(5 == num)
{
    printf("hehe\n");
}

更推荐使用代码4，将常量放在==左侧，这样写是因为，如果把==忘写成了=，编译器会有报错提示；如果将常量写在==右边，出现上述失误时，编译器仍能运行，但事实上是错误的代码。

💌2.2 switch语句 2.2.1 内容介绍

switch 语句的基本理解

case 的作用

break 的作用

switch case 推荐规则

2.2.2 switch case 组合

我们先提出一个问题，已经有if else为何还要switch case ？

switch语句也是一种分支语句，常常用于多分支的情况。这种多分支，一般指的是很多多分支，而且判定条件主要以整型为主。

比如：

输入1，输出星期一

输入2，输出星期二

输入3，输出星期三

输入4，输出星期四

输入5，输出星期五

输入6，输出星期六

输入7，输出星期日

如果写成if...else if ...else if的形式未免太过复杂，所以我们需要使用其他的语法。

这就是switch 语句。

switch(整型变量/常量/整型表达式)
{
        语句项；
}

而语句项是什么呢？

是一些case语句：

如下：

case 整形常量表达式: 
		语句;

基本语法结构

switch(整型变量/常量/整型表达式)
{
	case var1: 
        break; 
    case var2: 
        break; 
    case var3: 
        break; 
    default: 
        break; 
}

2.2.3 switch 语句中的 case

1. case 的作用：

• case本质是进行判定功能
• case和break之间写多条语句时建议带上{}（不带{}定义变量会报错），不推荐这种写法；建议将这些语句封装成函数

2. case后面的值有什么要求吗？

对于 switch(m) && case n ，其中 m 和 n 必须是 整型变量 / 常量 / 整型表达式。

case语句后面是否可以是const修饰的只读变量呢？不行! 必须用常量。

#include  
int main() 
{ 
    const int a = 10; //具有变量属性
    switch (a)
    { 
        case a: //不行 
            printf("hello\n"); 
            break; 
        default: 
            break; 
    }
    return 0; 
}

3. 对 case 语句的排列顺序问题的建议

1. 按字母或数字顺序排列各条case语句，容易找到相应的语句。

2. 把正常情况放在前面，而把异常情况放在后面。

3. 按执行频率排列case语句，把最常执行的情况放在前面，不常执行的情况放在后面。最长执行的代码可能也是调试的时候要单步执行最多的代码，放在前面方便查找。

2.2.4 switch 语句中的 break

在switch语句中，我们没办法直接实现分支，搭配break使用才能实现真正的分支。 比如：

#include  
int main() 
{ 
    int day = 1; 
    switch (day)
    { 
        case 1: //判断功能
            printf("星期一\n"); 
            break; //分支功能
        case 2: 
            printf("星期二\n"); 
            break; 
        case 3: 
            printf("星期三\n"); 
            break; 
        case 4: 
            printf("星期四\n"); 
            break; 
        case 5: 
            printf("星期五\n"); 
            break; 
        case 6: 
            printf("星期六\n"); 
            break; 
        case 7: 
            printf("星期日\n"); 
            break; 
        default: 
            printf("bug!\n"); 
            break; 
    }
    return 0; 
}

有时候我们的需求变了：

1. 输入1-5，输出的是“weekday”;

2. 输入6-7，输出“weekend”

所以我们的代码就应该这样实现：

#include  
int main() 
{ 
    int day = 1; 
    switch (day)
    { 
        case 1: 
        case 2:
        case 3:
        case 4:
        case 5:
            printf(("weekday\n");   
            break;
        case 6:
		case 7:
			printf("weekend\n");  
            break;
        default: 
            printf("bug!\n"); 
            break; 
    }
    return 0; 
}

结论：

1. case之后，如果没有break，则会依次执行后续有效语句，直到碰到break。
2. break语句的实际效果是把语句列表划分为不同的分支部分。

编程好习惯

在最后一个 case 语句的后面加上一条 break语句。

（之所以这么写，是可以避免之前出现的，最后一个 case 语句后面忘了添加 break语句）。

2.2.5 default 子句

如果表达的值与所有的case标签的值都不匹配怎么办？ 其实也没什么，结果只是所有的语句都被跳过而已。

程序并不会终止，也不会报错，因为这种情况在C中并不认为是个错误。 但是，如果我们并不想忽略不匹配所有标签的表达式的值时该怎么办呢？ 我们可以在语句列表中增加一条default子句，把下面的标签

default：

写在任何一个 case 标签可以出现的位置。

当 switch 表达式的值并不匹配所有 case 标签的值时，这个 default 子句后面的语句就会执行。 所以，每个switch语句中只能出现一条default子句。

但是它可以出现在switch语句列表的任何位置，而且语句流会像执行一个case标签一样执行default子句。

代码演示：

#include  
int main() 
{
    int day = 10; //改成10，到default 
    switch (day)
    {
        case 1: 
        case 2: 
        case 3: 
        case 4: 
        case 5: 
            printf("周内\n"); 
            break; 
        case 6: 
        case 7: 
            printf("周末\n"); 
            break; 
        default: 
            printf("日期有误!\n"); //输出该句
            break; 
    }
    return 0; 
}

编程好习惯

• 建议把 default 子句写在所有 case 语句项的最后面

• 在每个 switch 语句中都放一条 default 子句并且在后边再加一个 break ，即使程序真的不需要default处理，也应该保留以下语句： default: break;。

2.2.6 相关练习

#include  
int main()
{
    int n = 1;int m = 2;  
    switch (n)
    {
        case 1:
            m++;
        case 2:
            n++;
        case 3:
            switch (n)
            {
                    //switch允许嵌套使用  
                case 1:
                    n++;
                case 2:
                    m++;  
                    n++;
                    break;
            }
        case 4:
            m++;
            break;
        default:
            break;
    }
    printf("m = %d, n = %d\n", m, n);  
    return 0;
}

switch 语句总结

1. switch语法结构中，case完成的是判定功能，break完成的是分支功能，default处理异常情况
2. case：执行语句 == 1：n（1个case可以跟n条语句），case:多条语句 ; break;（不能定义变量，如果需要，建议使用{}，或者封装成函数）
3. case：执行语句 ==n：1（n个case接1条语句），多条case后续不写break。
4. default：可以出现在任何地方，推荐放在结尾
5. case：不能放const、普通的变量，建议要有好的布局case的顺序方式

---

💖3 . 循环语句

• while
• for
• do while

💌3.1 while循环

我们已经掌握了，if 语句

当条件满足的情况下，if语句后的语句执行，否则不执行。

但是这个语句只会执行一次。

但是生活中很多的实际例子是：同一件事情我们需要完成很多次。

那我们怎么做呢？

C语言中给我们引入了： while 语句，可以实现循环。

while 语法结构

循环条件初始化;
while(循环条件判定)
{ 
    //条件更新 
    循环条件更新;
}

while语句执行的流程：

比如我们实现：

在屏幕上打印1-10的数字。

#include   
int main()
{
    int i = 1;  
    while(i<=10)
    {
        printf("%d ", i);   
        i = i+1;
    }
    return 0;
}

//死循环写法
while(1)
{ 

}

上面的代码已经帮我们了解了 while 语句的基本语法，那我们再了解一下更多关于while语句的细节：

3.1.1 while 语句中的 break 和 continue break 介绍:

break 代码实例

#include   
int main()
{
    int i = 1;  
    while(i<=10)
    {
        if(i == 5)
            break;
            printf("%d ", i); 
        i = i+1;
    }
    return 0;
}

这里代码输出的结果是什么？

1 2 3 4 ✔

1 2 3 4 5

1 2 3 4 5 6 7 8 9 10

1 2 3 4 6 7 8 9 10

总结：

break在while循环中的作用：

其实在循环中只要遇到break，就停止后期的所有的循环，直接终止循环。

所以：while中的break是用于永久终止循环的

continue 介绍

代码实例：

#include  
int main()
{
    int i = 1;  
    while(i<=10)
    {
        if(i == 5)
            continue;  
        printf("%d ", i);   
        i = i+1;
    }
    return 0;
}

这里代码输出的结果是什么？

1 2 3 4…死循环 ✔

1 2 3 4 5

1 2 3 4 5 6 7 8 9 10

1 2 3 4 6 7 8 9 10

这里contine会跳过后面的条件更新语句 i = i+1;直接到while(条件判定)，故一直循环重复。

#include   
int main()
{
    int i = 1;  
    while(i<=10)
    {
        i = i+1;
        if(i == 5)
            continue;  
        printf("%d ", i);
    }
    return 0;
}

这里代码输出的结果是什么？

1 2 3 4

1 2 3 4 5

1 2 3 4 5 6 7 8 9 10

1 2 3 4 6 7 8 9 10

2 3 4 6 7 8 9 10 11 ✔

总结：

continue在while循环中的作用就是：

continue是用于终止本次循环的，也就是本次循环中continue后边的代码不会再执行， 而是直接跳转到while语句的判断部分。进行下一次循环的入口判断。

💌3.2 for循环

我们已经知道了while循环，但是我们为什么还要一个for循环呢？

首先来看看for循环的语法：

3.2.1 语法

for(条件初始化; 条件判定; 条件更新)
{ 
    循环语句;
}

• 条件初始化部分，用于初始化循环变量的。
• 条件判断部分，用于判断循环时候终止。
• 条件更新部分，用于循环条件的更新。

实际的问题：

使用for循环 在屏幕上打印1-10的数字。

#include   
int main()
{
    int i = 0;
    //for(i=1/*初始化*/; i<=10/*判断部分*/; i++/*更新部分*/)  
    for(i=1; i<=10; i++)
    {
        printf("%d ", i);
    }
    return 0;
}
//for 的死循环写法
for(;;)		//三个条件都省略
{ 

}

for循环的执行流程图：

现在我们对比一下for循环和while循环。

int i = 0;
//实现相同的功能，使用while
i=1;		//初始化部分
while(i<=10)//判断部分
{

    printf("hehe\n");  
    i = i+1;//调整部分
}

//实现相同的功能，使用for
for(i=1; i<=10; i++)
{
    printf("hehe\n");
}

可以发现在while循环中依然存在循环的三个必须条件，但是由于风格的问题使得三个部分很可能偏离较远，这样查找修改就不够集中和方便。所以，for循环的风格更胜一筹；for循环使用的频率也最高。

3.2.2 break 和continue在for循环中

我们发现在for循环中也可以出现break和continue，他们的意义和在while循环中是一样的。 但是还是有些差异：

遇到 break 直接跳出循环。

//代码1
#include   
int main()
{
    int i = 0;
    for(i=1; i<=10; i++)
    {
        if(i == 5)
            break;  
        printf("%d ",i);
    }
    return 0;
}//打印1 2 3 4

遇到 continue 会跳到i++，即条件更新部分。

//代码2
#include   
int main()
{
    int i = 0;
    for(i=1; i<=10; i++)
    {
        if(i == 5)
            continue;  
        printf("%d ",i);
    }
    return 0;
}//打印1 2 3 4 6 7 8 9 10

3.2.3 for语句的循环控制变量

建议：

1. 不在for循环体内修改循环变量，防止 for 循环失去控制。
2. for 语句的控制表达式不能包含任何浮点类型的对象，因为浮点类型有精度损失，判定时可能有些问题
3. 建议for语句的循环控制变量的取值采用“前闭后开区间”写法。因为循环次数明确，便于进行个数计算。
4. 在多重循环中，如果有可能，应该将最长的循环放在最内层，最短的循环放在最外层，以减少CPU跨且循环层的次数。

int i = 0;
//前闭后开的写法 
for(i=0; i<10; i++)
{}

//两边都是闭区间 
for(i=0; i<=9; i++)
{}

3.2.4 一些for循环的变式

#include   
int main()
{
    //代码1  
    for( ; ; )
    {
        printf("hehe\n"); //死循环
    }
    //for循环中的初始化部分，判断部分，调整部分是可以省略的。

    // 代码2  
    int i = 0;  
    int j = 0;
    //这里打印多少个hehe?  
    for(i=0; i<10; i++)
    {
        for(j=0; j<10; j++)
        {
            printf("hehe\n");//打印十个hehe
        }
    }

    // 代码3  
    int i = 0;  
    int j = 0;
    //如果省略掉初始化部分，这里打印多少个hehe?  
    for( ; i<10; i++)
    {
        for( ; j<10; j++)
        {
            printf("hehe\n");//打印十个hehe
        }
    }

    //代码4-使用多余一个变量控制循环  
    int x, y;
    for (x = 0, y = 0; x<2 && y<5; ++x, y++)
    {
        printf("hehe\n"); //打印两个hehe
    }
    return 0;
}

💌3.3 do…while()循环 3.3.1 do语句的语法：

do
	循环语句;
while(表达式);

3.3.2 执行流程

3.3.3 do语句的特点

循环内的语句至少执行一次，使用的场景有限，所以不是经常使用。

#include 
int main()
{
    int i = 10;  
    do
    {
        printf("%d\n", i);
    }while(i<10);  
    return 0;
}

3.3.4 do while 循环中的 break 和 continue

遇到break后跳出循环:

#include   
int main()
{
    int i = 10;
    //打印10 9 8 7 6
    do
    {
        if(5 == i)
            break; 
        printf("%d", i);
        i--;
    }while(i<10);

    return 0;
}

遇到continue，跳过后面的语句，条件更新被略过：

#include   
int main()
{
    int i = 10;
    //打印10 9 8 7 6...死循环
    do
    {
        if(5 == i)
            continue; 
        printf("%d", i);
        i--;
    }while(i<10);
    return 0;
}

---

💖4. goto语句 4.1 作用

C语言中提供了可以随意滥用的 goto语句和标记跳转的标号。

可以根据goto语句，直接跳转到goto后面所指的标签处。

4.2 基本使用

从理论上 goto 语句是没有必要的，实践中没有 goto 语句也可以很容易的写出代码。

int main()
{
again:
    printf("hehe\n");
    goto again;
    return 0;
}//死循环打印hehe

但是某些场合下goto语句还是用得着的，最常见的用法就是终止程序在某些深度嵌套的结构的处理过程。

例如：一次跳出两层或多层循环。

多层循环这种情况使用break是达不到目的的。它只能从最内层循环退出到上一层的循环。

goto语言真正适合的场景如下：

for(...)
    for(...)
    {
        for(...)
        {
            if(disaster)
                goto error;
        }
    }
		… 
error:
	if(disaster)
        // 处理错误情况

注：goto语句，不能跨函数跳转

---

💖5. 语句的相关练习 5.1 二分法查找算法

编写代码在一个整形有序数组中查找具体的某个数
找到了就打印数字所在的下标，找不到则输出：找不到。

#include
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int k = 9;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int left = 0;
	int right = sz - 1;
	while (left <= right)
	{
		//int mid = (left + right) / 2;//可能会有溢出的问题
		int mid = left + ((left - right) / 2);
		if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else
		{
			printf("找到了，下标是：%d", mid);
			break;
		}
	}
	if (left > right)
	{
		printf("找不到了");
	}
	return 0;
}

5.2 猜数字游戏

使用do while 语句实现：

#include
#include
#include

void menu()
{
	printf("**********************\n");
	printf("******** 1.play ******\n");
	printf("******** 0.exit ******\n");
	printf("**********************\n");
}

void game(int key,int sz)
{
	int num = 0;
	printf("请猜一个数字\n");
	scanf("%d", &num);
	while (num != key)
	{
		if (num < key)
		{
			printf("猜小了\n");
		}
		else if (num > key)
		{
			printf("猜大了\n");
		}
		printf("请重新猜\n");
		scanf("%d", &num);
	}
	if (key == num)
	{
		printf("猜对了，这个数是%d\n",key);
	}

}
int main()
{
	srand((unsigned int)time(null));
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int op = 0;
	do 
	{
		int k = (rand() % 10) + 1;
		menu();
		scanf("%d", &op);
		switch (op)
		{
		case 1:
			game(k,sz);
			break;
		case 0:
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (op);
	printf("游戏结束，已退出\n");
}

5.3 关机程序

关机程序

1. 电脑运行起来后，1min内关机

2. 如果输入：我是猪，就取消关机

下面是使用goto语句的一个例子：

#include
#include
#include

int main()
{
    char input[20] = {0};
    system("shutdown - s -t 60");
again:
    printf("请注意，你的电脑在60s内关机，如果输入：我是猪，就取消关机。");
    scanf("%s",input);
    if(strcmp(input,"我是猪") == 0)
    {
        system("shutdown -a");
        printf("取消成功!");
    }
    else
    {
        goto again;
    }
    return 0;
}