分支，调用函数，break,continue

r囧r小猫 2022-11-25 00:44 129阅读 0赞

一、分支。  
分支：if-else switch

1、if分支  
用法一：if单独使用，只有if语句,没有else语句。

1）基本框架。  
if(判定条件)  
\{ -> 复合语句

2）处理流程  
判断判定条件 -> 真 -> 执行复合语句  
判断判定条件 -> 假 -> 不执行复合语句

3）省略\{\}写法。  
====================================  
if(判定条件)  
xxxx; -> 如果条件为真，则执行xxxx;如果条件为假，就不执行xxxx;  
yyyy; -> 不属于if语句的响应范围，无论条件真假，这个yyyy;都会执行。

等价于  
if(判定条件)  
\{  
xxxx;  
\}  
yyyy;

=====================================  
if(判定条件); -> 无论条件真假，xxxx;与yyyy;都会被执行  
xxxx;  
yyyy;

等价于  
if(判断条件)  
\{

\}  
xxxx;  
yyyy;

用法二： if-else配合使用。  
1）基本框架  
if(判定条件) -> 如果为真，就执行复合语句1  
\{ -> 复合语句1

\}  
else\{ -> 复合语句2 -> 不满足判定条件的情况，就会执行复合语句2

注意：复合语句1与复合语句2中肯定有一个会被执行。

2）省略\{\}情况。  
=====================================  
if(判定条件)  
xxxx;  
else  
yyyy; -> 可以

等价于  
if(判定条件)  
\{  
xxxx;  
\}  
else  
\{  
yyyy;  
\}

=====================================  
if(判定条件1) -> 如果条件1为真，则执行xxxx;如果条件为假，就不执行xxxx;  
xxxx;  
if(判定条件2) -> 如果条件2为真，则执行yyyy;如果条件为假，就执行zzzz;  
yyyy;  
else  
zzzz;

等价于  
if(判定条件1) -> 如果条件1为真，则执行xxxx;如果条件为假，就不执行xxxx;  
\{  
xxxx;  
\}  
if(判定条件2) -> 如果条件2为真，则执行yyyy;如果条件为假，就执行zzzz;  
\{  
yyyy;  
\}  
else  
\{  
zzzz;  
\}

============================================  
if(判定条件)  
xxxx;  
else  
yyyy;  
else -> 编译报错： 找不到if与这个else匹配。  
zzzz;

=============================================

用法三：多种情况判定：else if  
1）基本框架  
if(判定条件1) -> 如果判定条件1为真，则执行复合语句1，然后结束整个分支。  
\{ -> 复合语句1

\}  
else if(判定条件2) -> 如果判定条件1为假，则进行判断判定条件2，如果判定条件2为真，则执行复合语句2，然后结束整个分支。  
\{ -> 复合语句2

\}  
else if(判定条件3) -> 如果判定条件2为假，则进行判断判定条件3，如果判定条件3为真，则执行复合语句3，然后结束整个分支。  
\{ -> 复合语句3

\}  
else -> 如果判定条件3为假，就会执行复合语句4，然后结束整个分支。  
\{ -> 复合语句4

区分好以下的情况：  
if(判定条件1) -> 无论条件1是真是假，都要执行判定条件2  
\{ -> 复合语句1

\}  
if(判定条件2) -> 无论条件2是真是假，都要执行判定条件3  
\{ -> 复合语句2

\}  
if(判定条件3) -> 如果判定条件3为真，就执行复合语句3  
\{ -> 复合语句3

\}  
else\{ -> 复合语句4 -> 如果判定条件3为假，就执行复合语句4

练习1： 分别使用以上的三种办法，完成该题。  
从键盘中获取一个数字  
0~100 -> 打印small  
101~200 -> 打印middle  
201~300 -> 打印large  
其他 -> 打印error

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
/\* 1. 单独使用 \*/  
/\*  
int x;  
while(1)  
\{  
scanf("%d",&x);  
if(x >= 0 && x <= 100)  
printf("small!\\n");  
if(x >= 101 && x <= 200)  
printf("middle!\\n");  
if(x >= 201 && x <= 300)  
printf("large!\\n");  
if(x < 0 || x > 300)  
printf("error!\\n");  
\}  
\*/  
  
/\* 2. if-else配合使用 \*/  
/\*  
int x;  
while(1)  
\{  
scanf("%d",&x);  
if(x >= 0 && x <= 100)  
printf("small!\\n");  
else\{  
if(x >= 101 && x <= 200)  
printf("middle!\\n");  
else\{  
if(x >= 201 && x <= 300)  
printf("large!\\n");  
else\{  
printf("error!\\n");  
\}  
\}  
\}  
\}  
\*/  
  
/\* 3. else if多路分支 \*/  
int x;  
while(1)  
\{  
scanf("%d",&x);  
if(x >= 0 && x <= 100)  
printf("small!\\n");  
else if(x >= 101 && x <= 200)  
printf("middle!\\n");  
else if(x >= 201 && x <= 300)  
printf("large!\\n");  
else  
printf("error!\\n");  
\} -> "ctrl + C"可以退出程序。  
  
return 0;  
\}

总结三大循环与if分支：  
1）如果循环的次数确定的，一般使用for循环。  
2）如果是死循环，就会使用while循环。  
3）无论如何都要先执行一遍，就会使用do-while循环。

4）只是判断一个条件而已，一般就使用if单独使用。  
5）如果是真假情况，一般就是if-else配合使用。  
6）如果多种情况判定，一般就是else if。

2、switch分支。  
特点：针对if/else分支代码累赘的问题进行解决。

1）基本框架  
aaaa;  
switch(判断的值) -> 整型，字符型，枚举类型 -> 不可以填字符串、浮点型  
\{  
case 结果1: -> 如果判断的值等于结果1，那么就会执行xxxx;  
xxxx;  
break; -> 有break就会结束switch分支，没有break就会继续运行yyyy;哪怕这个判断的值不等于结果2

case 结果2: -> 如果判断的值等于结果2，那么就会执行yyyy;  
yyyy;  
break; -> 有break就会结束switch分支，没有break就会继续运行zzzz;

default: -> 不满足以上的所有结果，就会执行default中的zzzz;  
zzzz;  
break;  
\}  
bbbb;

2）处理流程。  
aaaa; -> 判断的值是否与下面case后面的结果一致，例如，判断的值等于结果2 -> yyyy; -> bbbb;

例题1：从键盘中获取一个值，存放在变量x中。  
数字1，打印one。  
数字10，打印ten。  
如果都不是，则打印error。

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int x;  
scanf("%d",&x);  
  
switch(x)  
\{  
case 1:  
printf("one!\\n");  
break;  
  
case 10:  
printf("ten!\\n");  
break;  
  
default:  
printf("error!\\n");  
break;  
\}  
  
return 0;  
\}

例题2： 从键盘中获取一个数字 (switch分支)  
0~100 -> 打印small  
101~200 -> 打印middle  
201~300 -> 打印large  
其他 -> 打印error

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int x;  
scanf("%d",&x);  
  
switch(x)  
\{  
case 0 ... 100: //等价于 0<=x<=100  
printf("small!\\n");  
break;  
  
case 101 ... 200:  
printf("middle!\\n");  
break;  
  
case 201 ... 300:  
printf("large!\\n");  
break;  
  
default:  
printf("error!\\n");  
break;  
\}  
  
return 0;  
\}

总结：  
1）判断的值必须是整型。  
2）每一个case语句后面记住写break;除非你有意去执行后面的语句。  
3）记得写default，即使default永远都不会执行。  
4）break语句在switch语句中作用就是跳出switch语句，与循环无关。  
5）进行范围判断时候，记得"..."两边必须有空格，包含两端的数据 0 ... 100 等价于 x>=0 && x<=100

练习2：

int main(int argc,char \*argv\[\])  
\{  
int c = 1;  
switch(c)  
\{  
case 1:  
c++; //2  
case 2:  
c+=5; //7  
default:  
c+=4; //11  
\}  
printf("c = %d\\n",c); //11

二、两个影响着控制流的语句。 -> break语句和continue语句。  
1、break语句。  
1）作用对象： switch分支、 for循环、while循环、do-while循环。  
2）作用： 跳出switch分支 跳出循环

2、作用场景：  
1）当break语句作用于switch分支时：  
switch(x)  
\{  
case 1:  
xxx;  
break; -> 仅仅是跳出switch语句而已。

2）当break语句作用与循环时，一般都是与if分支连用。  
aaaa;  
while(1)  
\{  
xxxx;  
yyyx;  
if(判定条件)  
\{  
break;  
\}  
\}  
bbbb;

处理流程：  
aaaa; -> xxxx; -> yyyy; -> 判定条件 -> 假 -> xxxx;  
\-> yyyy; -> 判定条件 -> 真 -> break语句 -> 跳出循环 -> bbbb;

3、几个特殊的例子。  
例子1：  
int main(int argc,char \*argv\[\])  
\{  
while(1)  
\{  
swtich()  
\{  
break; -> 这句话执行后，会运行哪句话？  
xxxx;  
\}  
yyyy; -> 跳到这里。  
\}  
zzzz;

return 0  
\}

例子2：  
int main(int argc,char \*argv\[\])  
\{  
while(1)  
\{  
while(1)  
\{  
while(1)  
\{  
break; -> 这句话执行后，会运行哪句话？  
xxxx;  
\}  
yyyy; -> 跳到这里。  
\}  
zzzz;  
\}  
kkkk;  
return 0;  
\}

练习3：在全校的1000名学生中征集捐款，当总数到达10万元时就结束捐款。  
统计此时已经捐款的人数以及平均每人捐款的金额。

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int i; //人数  
float money; //每一个人捐款的金额。  
float sum = 0; //总金额  
float aver; //平均数  
  
for(i=1;i<=1000;i++)  
\{  
printf("pls input your money:");  
scanf("%f",&money); //个人捐款  
if(money <= 0)  
\{  
i--;  
continue;  
\}  
  
sum += money; //将这个人捐款的钱累计到总数上  
  
if(sum >= 100000) //如果到达10万，则结束捐款。  
\{  
break;  
\}  
\}  
  
if(i == 1001)  
\{  
i--;  
\}  
  
aver = sum/i;  
printf("i = %d\\n",i);  
printf("aver = %f\\n",aver);  
  
return 0;  
\}

4、 continue语句。  
1）作用对象：for循环、while循环、do-while循环  
2）作用：立即结束当次循环、马上开始下一次循环。

3）场景：  
aaaa;  
while(1)  
\{  
xxxx;  
if(判定条件)  
\{  
continue;  
\}  
yyyy;  
\}  
zzzz;

处理流程：  
aaaa; -> xxxx; -> 判定条件 -> 真 -> continue; -> xxxx; -> 判定条件 -> 假 -> yyyy; -> xxxx;

练习4：要求输出100~200之间不能被3整除的数，要求使用continue语句来完成。

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int num;  
for(num=100;num<=200;num++)  
\{  
if(num%3 == 0)  
continue;  
  
printf("%d\\n",num);  
\}  
  
return 0;  
\}

三、函数概念。  
1、在C语言中，什么是函数？  
C语言是一种面向过程的语言，任何一个小过程都可以封装成一个函数。  
C语言程序是用函数堆出来。 -> C语言称为函数式语言。

函数就是一个模块的封装。

面包店\_fun()  
\{  
//摘小麦  
//洗东西  
//面粉  
....  
//做出一个面包  
\}

地铁\_fun()  
\{  
//采购铁  
//修铁路  
//修电梯  
...  
//搭地铁  
\}

面包店\_fun() -> 我们需要调用这个函数即可，不需要理会过程。  
地铁\_fun() -> 我们需要调用这个函数即可，不需要理会过程。

2、封装成函数意义？  
1）可以让你的代码变成一个个独立的模块，简化你的代码。

如果不封装，代码是这样：  
int main()  
\{  
//摘小麦  
//洗东西  
//面粉  
....  
//做出一个面包

//采购铁  
//修铁路  
//修电梯  
...  
//搭地铁 -> 全部内容实现过程都在main函数中，这样代码非常累赘的，所以说我们需要适当封装函数。  
\}

如果封装，代码是这样：

面包店\_fun()  
\{  
//摘小麦  
//洗东西  
//面粉  
....  
//做出一个面包  
\}

地铁\_fun()  
\{  
//采购铁  
//修铁路  
//修电梯  
...  
//搭地铁  
\}

int main()  
\{  
面包店\_fun();

地铁\_fun();  
\}

2）方便工程师后期维护项目。  
3）对于调用者，不需要关心实现过程，只需要关心如何调用函数即可。

四、函数书写规则？  
1、在linux下，有哪些函数种类？  
main函数：主函数，在程序中有且仅有一个，在main函数中开始执行，从main函数结束。  
系统函数：在man手册中第2手册，用户只需要调用，不需要知道函数的实现过程。  
库函数： 在man手册中第3手册，用户只需要调用，不需要知道函数的实现过程。  
自定义函数： 不能通过man手册去查询，用户必须写清楚实现过程。

例如：  
\#include<stdio.h>

int fun() -> 必须写清楚这个函数的实现过程，否则编译出错。  
\{

int main(int argc,char \*argv\[\]) -> main函数  
\{  
printf("helloworld!\\n"); -> 库函数  
fun(); -> 自定义函数  
return 0;  
\}

2、如何书写自定义函数？  
1）确定函数的函数名  
必须：命名规则与变量一致。 例如：my\_fun  
选择：函数名最好能体现出函数的功能。 例如： play\_music

2）确定函数的形式参数。 -> 写在函数名的后面  
什么是形式参数？  
就是你调用这个函数时，需要给这个函数传递什么参数。

有形式参数：my\_fun(形式参数1,形式参数2,.....形式参数n)  
无形式参数：my\_fun()

面包店\_fun(一些钱，哪个面包)  
你想吃面包，就必须先准备好一些钱和想好吃射什么面包。

my\_fun(int a)  
你想调用my\_fun这个函数，就必须先准备好一个整型的数据给我。

my\_fun()  
你想调用my\_fun这个函数,什么都不用准备，直接调用就可以。

3）函数体  
my\_fun(int a)  
\{ -> 函数体  
\-> 写清楚这个函数的实现过程。

4）确定函数返回值类型。 -> 写在函数名的前面  
有返回值 -> 必须确定好类型  
int -> 无论这个函数成功还是失败，都会返回一个int类型的数据。  
char -> 无论这个函数成功还是失败，都会返回一个char类型的数据。

int my\_fun(int a)  
\{  
.....;  
return 0; -> 0就是返回值的结果，必须与类型匹配。  
\}

无返回值 -> void -> 代表这个函数没有返回值  
void my\_fun(int a)  
\{  
return; -> 代表这个函数返回，但是没有返回值。  
\}

总结自定义函数的框架：  
返回值类型 函数名(形式参数列表)  
\{

return ?;  
\}

3、举例子。  
写一个函数，要求接收2个int类型数据，函数就他们的和返回。

int add\_fun(int x,int y)  
\{  
return x+y;  
\}

五、如何调用函数？  
1、确保调用的函数的实现过程已经写好了

int add\_fun(int x,int y)  
\{  
return x+y;  
\}

2、在函数体内，直接写函数名字，后面紧跟着一个圆括号，圆括号中写实际参数。

int main(int argc,char \*argv\[\])  
\{  
int a = 10;  
int b = 20;  
add\_fun(a,b); ->10/20就是实际参数，调用这个函数时直接将10赋值给x，20赋值y。  
\}

结论： 形式参数的值直接由实际参数初始化，这个过程不可逆。

什么是不可逆？  
x的值是由a来初始化，但是x的值修改了，不会影响a的值。

\------------------到目前为止，代码如下------------------

\#include <stdio.h>

int add\_fun(int x,int y)  
\{  
return x+y;  
\}

int main(int argc,char \*argv\[\])  
\{  
int a=10,b=20;  
add\_fun(a,b) -> 你只是调用了这个函数，但是没有保存这个函数的返回值。  
\}

3、往往在调用函数时，都会保存函数的返回值，就可以知道函数的结果是多少。  
关心返回值是多少：

int ret;  
ret = add\_fun(a,b); -> 函数的返回值，会返回到它调用的地方。  
printf("ret = %d\\n",ret);

不关心返回值是多少：

add\_fun(a,b);

作业1：写一个函数，实现接收3个int类型数据的参数，要求函数经过约定的运算后，得到结果并打印出来。  
前面2个参数用于计算，最后一个参数运算方式。  
1 -> +  
2 -> -  
3 -> \*  
4 -> /

fun(3,4,1); -> 7  
fun(3,4,3); -> 12

作业2：求出以下程序的结果，原因是什么？

int swap(int x,int y)  
\{  
int t;  
t = x;  
x = y;  
y = t;  
return 0;  
\}

int main(int argc,char \*argv\[\])  
\{  
int a,b;  
scanf("%d %d",&a,&b); //假设输入5和3

swap(a,b);  
printf("a = %d,b = %d\\n",a,b);  
return 0;  
\}

作业3：求出以下程序的结果？

int fun(int a,int b)  
\{  
if(a > b)  
return a;  
else  
return b;  
\}

int main(int argc,char \*argv\[\])  
\{  
int x = 3,y=8,z=6,r;  
r = fun(3,fun(z,2\*y));  
printf("r = %d\\n",r);  
return 0;  
\}

作业4：写一个自定义函数，实现要求用户输入两个int类型的数据，求出两个数字的最大值，分别使用if-else/三目运算来完成。  
作业5：连续从键盘中获取4个数字，求出其中的最大值，要求使用函数嵌套的方式来完成。

函数嵌套：在一个自定义函数A中调用另外一个函数B。

分支，调用函数，break,continue

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关条件分支和循环机制、标志寄存器及函数调用机制

相关 breakContinue标签使用

相关 matlab怎么调用主函数,matlab函数调用 matlab主函数如何调用子函数？

相关分支，调用函数，break,continue

相关 php 字符串中调用函数调用函数,php通过字符串调用函数示例

相关 java调用javascript函数_Java调用javascript函数

相关函数调用

相关函数调用

相关函数调用

相关函数 --- 调用函数