C语言初阶(2) -- 初识分支语句和循环语句

dream wings

已于 2024-04-24 21:59:16 修改

阅读量765

点赞数 23

文章标签： c语言开发语言

于 2023-12-30 23:36:56 首次发布

本文链接：https://blog.csdn.net/Speechless_f/article/details/135258315

版权

前言：

前面介绍了C语言的相关内容，这篇博客开始将正式对C语言每一个章节进行深入学习，这篇主要讲解分支语句和循环语句。。。

计算机科学家通过观察，将世界万物变化的规律归纳为顺序、选择与循环三种逻辑结构，并用代码的形式演绎它们，开发出了包括if语句、switch语句、for循环语句等计算机语言结构，又称分支和循环。通过上述结构的排列组合，程序员能借助计算机解决生活中的许多问题。

1. 什么是语句？

C 语句可分为以下五类：

        1. 表达式语句

        2. 函数调用语句

        3. 控制语句

        4. 复合语句

        5. 空语句

本文简要了解控制语句。

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

可分成以下三类：

1. 条件判断语句也叫分支语句： if语句、switch语句；

2. 循环执行语句： while语句、for语句、do while语句；

3. 转向语句： break语句、continue语句、goto语句、return语句。

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

什么是分支语句？

如果条件满足才能做某件事情，如果条件不满足就做另外一件事情，或者什么也不做。分支语句又被称为"判断语句"，正因为有了判断才让程序有了很多的分支。

如果你好好学习，校招时拿一个好 offer ，走上人生巅峰，赢取白富美。

如果你不学习，毕业等于失业，回家卖红薯。

这就是选择！

2.1 if语句

2.1.1语法结构：

单分支语句

if(表达式) //表达式为真则执行
    语句;

双分支语句

if(表达式){  //表达式为真则执行
    语句1;
    }
else{
    语句2;
    }

多分支语句

if(表达式1){
    语句1;
    }
else if(表达式2){
    语句2;
    }
else{
    语句3;
    }

注：当只有一条执行语句时可以省略语句体的大括号{}，但一般建议写上，使代码可读性更高。

eg1: 判断是否是未成年

#include <stdio.h>
//代码1
int main()
{
    int age = 0;
    scanf("%d", &age);
    if(age<18)
    {
        printf("未成年\n");
    }
}

eg2: 判断是否是成年

//代码2
#include <stdio.h>
int main()
{
    int age = 0;
    scanf("%d", &age);
    if(age<18)
    {
        printf("未成年\n");
    }
    else
    {
        printf("成年\n");
    }
}

eg3: 判断年纪

//代码3
#include <stdio.h>
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");
   }
}

注意：其中在写else if中的条件时，一定要用&&这个操作符，假设你写成(18<age<30)，此时程序的执行过程是18如果<age，左边就会为真，此时18<age的运算结果为1(C语言默认为1)，然后执行1<30这个语句。

解释：

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

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

         0表示假，非0表示真。

（1）语句中大括号的使用

如果条件成立，要执行多条语句，怎应该使用代码块。
#include <stdio.h>
int main()
{
    if(表达式)
   {
        语句列表1；
   }
    else
   {
        语句列表2；
   }
    return 0;
}
这里的一对 { } 就是一个代码块。若不加大括号，在该条件下只能控制紧跟着if或者else的那一条语句，没被控制的语句会在不满足条件的情况下执行。

2.1.2 悬空的else语句

当你写成了这样的代码：

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

打印结果：

该打印无结果是因为else就近匹配原则，else和if(b==2)结合，第一层if(a==1)为假，则不执行后面的语句，故无打印。

修改如下：

//适当的使用{}可以使代码的逻辑更加清楚。
//代码风格很重要
#include <stdio.h>
int main()
{
    int a = 0;
    int b = 2;
    if(a == 1)
   {
        if(b == 2)
       {
            printf("hehe\n");
       }
   }
    else
   {
         printf("haha\n");
   }       
    return 0;
}

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

《高质量c/c++编程》

2.1.3 if 书写形式的对比

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

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

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

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

2.1.4 练习

1.判断一个数是否为奇数

#include<stdio.h>
int main()
{
    int i = 0;
    scanf("%d", &i);//输入一个数
    if (i % 2 == 1)
        printf("i是奇数\n");
    else
        printf("i是偶数\n");
    return 0;
}

2.输出1-100之间的奇数

#include<stdio.h>
int main()
{
    int i = 0;
    for (i = 1; i < 100; i++)
    {
        if (i % 2 == 1)
        {
            printf("%d ", i);
        }
    }
    return 0;
}

2.2 switch语句

switch 语句也是一种分支语句，常常用于多分支的情况。

比如：

输入 1 ，输出星期一

输入 2 ，输出星期二

输入 3 ，输出星期三

输入 4 ，输出星期四

输入 5 ，输出星期五

输入 6 ，输出星期六

输入 7 ，输出星期日

那我没写成 if...else if ...else if 的形式太复杂，那我们就得有不一样的语法形式。

这就是 switch 语句。

语法结构

switch(整型表达式)
{
        case 整形常量表达式:

语句;

        case 整形常量表达式:

语句;

        case 整形常量表达式:

语句;

.......
}

2.2.1 在switch语句中的break

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

比如：

题目要求：输入一个数字，打印对应的星期几。

#include <stdio.h>
int main()
{
    int day = 0;
    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;
   }
    return 0;
}

如果题目要求改变

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

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

#include <stdio.h>
int main()
{
    int day = 0;
    switch(day)
   {
        case 1：
        case 2:
        case 3:
        case 4:
        case 5:
            printf("weekday\n");
            break;
        case 6:
        case 7:
            printf("weekend\n");
            break;
   }
    return 0;
}

break 语句的实际效果是把语句列表划分为不同的分支部分。

养成一个好的习惯：

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

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

2.2.2 default子句

如果表达的值与所有的 case 标签的值都不匹配怎么办？

其实也没什么，结构就是所有的语句都被跳过而已。

程序并不会终止，也不会报错，因为这种情况在 C 中并不认为是个错误。

但是，如果你并不想忽略不匹配所有标签的表达式的值时该怎么办呢？

你可以在语句列表中增加一条 default 子句，把下面的标签

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

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

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

一个好习惯：

在每个 switch 语句中都放一条default子句是个好习惯，甚至可以在后边再加一个 break 。

//在上面代码的最后加上

default:

printf("选择错误\n");

break;

2.2.3 switch 如何嵌套使用

#include <stdio.h>
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;
}

执行结果：

让我们来研究下代码的执行过程：

1.首先初始化整型变量n=1,m=2;

2.进入switch(n), n=1, 因此进入case 1分支;

3.在case 1中，m的值增加为3，因为没有brerak语句，所以继续执行下一个case;

4.进入case 2中，n的值增加为2，同样因为没有break语句,继续执行case 3;

5.此时，进入case 3, 里面嵌套了一个switch(n), 此时n=2, 进入case 2中;

6.进入case 2语句，n增加到3，m增加到4，遇到break 跳出里面的switch循环;

7.进入外部switch循环的case 4，m增加到5，遇到break结束此次循环;

8. switch遇到break跳出循环，没有执行default分支;

9.最后打印m和n的值，即m=5,n=3.

所以，代码的执行结果为：m=5, n=3.

3. 循环语句

循环语句可以为以下几类：

        while 循环
         for 循环

         do while 循环

3.1 while循环

我们已经掌握了if语句：

if(表达式)

语句1;

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

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

如果遇到某种情况：需要重复执行一件事情，我们需要怎么做？

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

//while 语法结构

while(表达式)

循环语句；

while语句的执行流程：

如果我们要实现：

在屏幕上打印1-10个数字

#include <stdio.h>
int main()
{
     int i = 1;
     while(i<=10)
     {
         printf("%d ", i);
         i++;
     }
     return 0;
}
//打印结果
//1 2 3 4 5 6 7 8 9 10

3.1.1 while 语句中的break 和 continue

break介绍

//break 代码实例
#include <stdio.h>
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 //答案是第一个

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 介绍

//continue 代码实例1
#include <stdio.h>
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 //第一个正确

1 2 3 4 5

1 2 3 4 5 6 7 8 9 10

1 2 3 4 6 7 8 9 10

//continue 代码实例2
#include <stdio.h>
int main()
{
     int i = 1;
     while(i<=10)
     {
         i = i+1;
         if(i == 5)
         continue;
         printf("%d ", i);
     }
     return 0;
}

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

//1 2 3 4 6 7 8 9 10

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

continue是用于终止本次循环的，也就是本次循环中continue后边的代码不会再执行，

而是直接跳转到while语句的判断部分。进行下一次循环的入口判断。

再来看以下代码：

//代码什么意思？
//代码1
#include <stdio.h>
int main()
{
 int ch = 0;
 while ((ch = getchar()) != EOF)
       putchar(ch);
    return 0;
}

这里的代码适当的修改是可以用来清理缓冲区的.

C语言中的getchar()函数：

         getchar()是一个标准库函数，它用于从标准输入流(通常是键盘)获取一个字符。

        当程序执行getchar()时，他会等待用户在键盘上输入一个字符，并且该字符会存储在输入缓冲区中。输入缓存区是一个临时的存储区域，用于存储等待处理的输入数据。

当用户按下回车键时，输入缓冲区中的字符会被传递给getchar()函数。

如果输入缓冲区为空（没有待处理的字符），getchar()会等待用户的输入，直到一个字符被键入。

如果用户输入了文件结束符（通常是Ctrl+D或者Ctrl+Z，具体取决于操作系统），则getchar()返回EOF，这会导致循环终止，程序结束执行。

        需要注意的是，getchar()函数每次只能读取一个字符，如果需要读取多个字符，可以使用循环来连续调用getchar()函数。同时，getchar()在读取字符后，光标会自动向后移动一个位置，指向下一个字符或者换行符。如果需要读取下一个字符，可以再次调用getchar()函数。

putchar()打印字符。

为什么getchar()使用int接受字符。

EOF(End of File) ：getchar()通常返回一个数，而不是char,是为了能够区分正常字符和文件结束符(EOF)。EOF是一个表示输入流的特殊值，通常被定义为一个负数，如常见的-1，如果使用char来接收字符，就无法清晰的表示EOF。

// 代码 2
#include <stdio.h>
int main()
{
    char ch = '\0';
    while ((ch = getchar()) != EOF)
    {
        if (ch < '0' || ch > '9')
            continue;
        putchar(ch);
    }
    return 0;
}
// 这个代码的作用是：只打印数字字符，跳过其他字符的、

getchar - > stdin 标准输入 - 键盘

outchar - > stdout 标准输出 - 屏幕

getchar --- 获取（输入）一个字符

putchar --- 输出一个字符

3.2 for 循环

3.2.1 语法

for ( 表达式 1 ; 表达式 2 ; 表达式 3 )

循环语句 ;

表达式 1

表达式 1 为 初始化部分 ，用于初始化循环变量的。

表达式 2

表达式 2 为 条件判断部分 ，用于判断循环时候终止。

表达式 3

表达式 3 为 调整部分 ，用于循环条件的调整。

实际问题：

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

#include <stdio.h>
int main()
{
     int i = 0;
     //for(i=1/*初始化*/; i<=10/*判断部分*/; i++/*调整部分*/)
     for(i=1; i<=10; i++)
     {
         printf("%d ", i);
     }    
     return 0;
}

for循环的执行流程图：

现在可以来对比下for循环和while循环。

int i = 0;
//实现相同的功能，使用while
i=1;//初始化部分
while(i<=10)//判断部分
{
     printf("hehe\n");
     i = i+1;//调整部分
}
//实现相同的功能，使用while
for(i=1; i<=10; i++)
{
     printf("hehe\n");
}

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

3.2.2 break 和continue在for循环中

我们发现在for 循环中也可以出现 break 和 continue ，他们的意义和在 while 循环中是一样的。

但是还是有些差异：

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

//代码2
#include <stdio.h>
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语句的循环控制变量的取值采用“前闭后开区间”写法。

int i = 0;
//前闭后开的写法
for(i=0; i<10; i++)
{}
//两边都是闭区间
for(i=0; i<=9; i++)
{}
  3.2.4 一些for循环的变形

        1. for的初始化，判断，调整三个部分可以省略；

        2 . 中间的判断部分如果省略，意味着恒为真，就构成了死循环；
3. 如果条件允许，不建议省略for循环的三个表达式；

#include <stdio.h>
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");
       }
   }//输出： 100

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

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

3.2.5 一道笔试题

//请问循环要循环多少次？
#include <stdio.h>
int main()
{
 int i = 0;
 int k = 0;
 for(i =0,k=0; k=0; i++,k++)
        k++;
 return 0;
}

答案： 0 次

3.3 do ... while () 循环

3.3.1 do 语句的语法

do

循环语句；

while(表达式)；

3.3.2 执行流程

使用do ...while 打印1-10

#include<stdio.h>
int i = 1;
do
{
    printf("%d ", i);
    i++;
}while(i<=10);

3.3.3. do语句的特点

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

3.3.4 do while循环中的brerak 和 continue

#include <stdio.h>
int main()
{
     int i = 10;
    
     do
     {
          if(5 == i)
              break;
          printf("%d\n", i);
     }while(i<10);
    
     return 0;
}
//打印： 1 2 3 4

#include <stdio.h>
int main()
{
     int i = 10;
    
     do
     {
          if(5 == i)
              continue;
          printf("%d\n", i);
     }while(i<10);  

     return 0;
}
//打印： 1 2 3 4 ----死循环

3.4.1 练习

//代码1
//编写代码，演示多个字符从两端移动，向中间汇聚
#include <stdio.h>
int main()
{
     char arr1[] = "welcome to bit...";
     char arr2[] = "#################";
     int left = 0;
     int right = strlen(arr1)-1;
     printf("%s\n", arr2);
     //while循环实现
     while(left<=right)
     {
         Sleep(1000);
         arr2[left] = arr1[left];
         arr2[right] = arr1[right];
         left++;
         right--;
         printf("%s\n", arr2);
     }
     //for循环实现
     for (left=0, right=strlen(src)-1; 
         left <= right; 
         left++, right--)
       {
            Sleep(1000);
            arr2[left] = arr1[left];
            arr2[right] = arr1[right];
            printf( "%s\n", target);
       }
       retutn 0;
}

//代码2
int main()
{
    char psw[10] = "" ;
    int i = 0;
    int j = 0;
    for (i = 0; i < 3 ; ++i)
    {
        printf( "please input:");
        scanf("%s", psw);
        if (strcmp(psw, "password" ) == 0)
            break;
    }
    if (i == 3)
        printf("exit\n");
    else
        printf( "log in\n");
}

3.4.2 折半查找算法

实现在主函数内：
int main()
{
     int arr[] = {1,2,3,4,5,6,7,8,9,10};
     int left = 0;
     int right = sizeof(arr)/sizeof(arr[0])-1;
     int key = 7;
     int mid = 0;
     while(left<=right)
     {
         mid = (left+right)/2;
         if(arr[mid]>key)
         {
             right = mid-1;
         }
         else if(arr[mid] < key)
         {
             left = mid+1;
         }
         else
             break;
     }
     if(left <= right)
         printf("找到了,下标是%d\n", mid);
     else
         printf("找不到\n");
}

如果实现一个二分查找函数：
int bin_search(int arr[], int left, int right, int key)
{
     int mid = 0;
     while(left<=right)
     {
         mid = (left+right)>>1;
         if(arr[mid]>key)
         {
             right = mid-1;
         }
         else if(arr[mid] < key)
         {
             left = mid+1;
         }
         else
             return mid;//找到了，返回下标
     }
     return -1;//找不到
}

3.4.3 猜数字游戏实现

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void menu()
{
     printf("**********************************\n");
     printf("*********** 1.play     **********\n");
     printf("*********** 0.exit     **********\n");
     printf("**********************************\n");
}
//RAND_MAX--rand函数能返回随机数的最大值。
void game()
{
     int random_num = rand()%100+1;
     int input = 0;
     while(1)
     {
         printf("请输入猜的数字>:");
         scanf("%d", &input);
         if(input > random_num)
         {
             printf("猜大了\n");
         }
         else if(input < random_num)
         {
             printf("猜小了\n");
         }
         else
         {
             printf("恭喜你，猜对了\n");
             break;
         }
     }
}
int main()
{
     int input = 0;
     srand((unsigned)time(NULL));
     do
     {
         menu();
         printf("请选择>:");
         scanf("%d", &input);
         switch(input)
         {
             case 1:
             game();
             break;
             case 0:
             break;
             default:
             printf("选择错误,请重新输入!\n");
             break;
         }
     }while(input);
     return 0;
}

4. goto语句

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

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

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

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

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

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

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

4.1 一个关机程序：

#include <stdio.h>
int main()
{
    char input[10] = {0};
    system("shutdown -s -t 60");//关机
again:
    printf("电脑将在1分钟内关机，如果输入：我是猪，就取消关机!\n请输入:>");
    scanf("%s", input);
    if(0 == strcmp(input, "我是猪"))
   {
        system("shutdown -a");//取消关机
   }
    else
   {
        goto again;
   }
    return 0;
}

而如果不适用goto语句，则可以使用循环；

#include <stdio.h>
#include <stdlib.h>
int main()
{
    char input[10] = {0};
    system("shutdown -s -t 60");
    while(1)
   {
        printf("电脑将在1分钟内关机，如果输入：我是猪，就取消关机!\n请输入:>");
        scanf("%s", input);
        if(0 == strcmp(input, "我是猪"))
       {
            system("shutdown -a");
            break;
       }
   }
    return 0;
}

若想将其做成一个小程序，可在release下运行编译，在存放代码的文件中打开release文件夹，在其中找到应用程序，点击应用程序就可以在非编译器下执行该段代码。

结尾：推荐一本C语言的书《高质量C/C++编程》，写代码养成良好习惯。

dream wings

关注

23
点赞
踩
23

收藏

觉得还不错? 一键收藏
打赏
0
评论
C语言初阶(2) -- 初识分支语句和循环语句

学习C语言，贵在坚持。C语言是一门结构化的语言，有顺序结构，分支结构，循环结构。1.什么是语句？C语句可分为以下五类：1. 表达式语句2. 函数调用语句3. 控制语句4. 复合语句5. 空语句本文简要了解控制语句。
复制链接

扫一扫