第7章 函数及其应用.docx
《第7章 函数及其应用.docx》由会员分享，可在线阅读，更多相关《第7章 函数及其应用.docx（19页珍藏版）》请在冰豆网上搜索。
第7章函数及其应用
第7章函数及其应用
7.1函数种类
1．命令函数，例如：
printf（）,scanf（）,getchar（）,putchar（）等。
2．库函数，fabs（）,pow（）,rand（）,srand（）sin（x）,sqrt（）,fexp（）等。
3．自定义函数
7.2自定义函数的概念及使用方法
例1：
求两个数的最大数
voidmain（）
{inta=9,b=6;
intimax（inta,intb）；
clrscr（）;
printf（“max=%d\n”,imax（a,b））;
}
intimax（inta,intb）
{return（a>b?
a:
b）;}
练习：
编写计算m,n两数和的函数子程序（子过程）
方法：
1．起函数名字
2．确定形参类型和个数
3．返回的值是什么
练习：
计算n！
的函数子程序（子过程）
longFactorial（intn）
{longi,k=1;
for（i=1;i<=n;i++）
k=k*i;
return（k）;}
练习：
编写求x的n次方
main（）
{longnpow（floatx,intn）；
clrscr（）;
printf（“npow=%ld\n”,npow（3,3））;
}
longnpow（floata,intn）
{longi,k=1;
for（i=1;i<=n;i++）
k=k*a;
return（k）;}
7.3自定义函数的三种形式
7.3.1无参函数，例如main（）,clrscr（）,getchar（）等。
主函数与子函数之间不传输数据
例：
输出字符四方形
************
************
************
************
voidprint（）
{inti;
for（i=1;i<5;i++）
printf（“************”）;
}
7.3.2空函数
例：
null（）
{}
7.3.3有参函数
如例1，例2
说明：
1．C语言程序由一个主函数和若干个子函数（模块、过程）组成。
2．子函数也有类型和函数值。
3．子函数程序体可以放在主函数后边，也可以放在主函数前边。
如果放在后边，应在主函数中进行说明（说明的函数称原型函数），说明时参数可以出现变量名，也可以不出现变量名。
如果是整型函数或字符函数可以不说明。
注意句未用“；”。
main（）
{longf（int）;
printf（“%ld”,f（10））;
}
longf（intn）
{intk;
longff=1;
for（k=1;k<=n;k++）
ff=ff*k;
returnff;
}
4．子函数程序体可以作为单独的文件存放，如果单独存放，应在主函数中作为头文件进行说明。
5．函数如果返回值，应使用return语句，注意使用（）和；。
6．子函数中有两个变量，一个是传递变量，此变量称做形参、一个是子函数内部使用的变量。
传递变量的类型说明要放在{}外边或放在函数名字右边的（）内。
如果放在函数名字右边的（）内，每一个实参要分别说明。
7．使用函数时，自变量位置的表达式称做实参，实参可以是变量、常量或表达式。
8．实参的值传递给形参，这叫实哑结合，而且只能将实参传给形参，这叫值传递，又叫单向传递，单向传递时，形参的值改变，不会影响实参的值，
例：
交换两个变量的值（在函数中完成、分别在子函数和主函数中输出，观察结果）
main（）
{inta=3,b=5;
swap（a,b）;
printf（“%d%d”,a,b）;
}
voidswap（intm,n）
{intk;
k=m;m=n;n=k;}
9．实参和形参的个数、类型位置要一致。
10．用return返回的值只有一个。
11．一个函数程序，可以出现多个return语句。
intsgn（floatx）
if（x>=0）return1;elsereturn–1;
12．当函数不返回值时，return可以省略。
13．函数的类型一定与retuen返回的值的类型一致。
14．当函数不返回值时，应在函数名字前加void，又叫无类型。
15．使用函数有三种使用方法：
（1）作为语句：
print（）;
（2）作为表达式：
A=max（x,y）+npow（x,n）
（3）作为实参：
A=max（max（a,b）,c）
16．函数程序中不允许在定义函数。
例：
将作过的一些编程题编写成函数程序
1．求三个数的最大数（可以求多个数的最大数）
2．求两个正整数的最大公约数（可以求多个数的最大数）
gys（intm,intn）
{intr;
r=m%n;
while（r!
=0）
{m=n;n=r;r=m%n;}
returnn;
}
3．求n+（n+1）+（n+2）+……（n+k）
intsum（intn,intk）
{ints=0,i;
for（i=0;i<=k;i++）
s+=n+i;
returns;
}
4．求ex
main（）
{floatx,
scanf（“%f”,&x）;
printf（“%f”,exe（x））;
}
floatexe（floatx）
{floats,k=1;
inti=1;
longf;
do
{t=t*x;
f=f*i;
s=s+t/f;
i++;
}while（1/f>1e-3）;
returnx;
}
5．用子函数完成排序（绘制流程图）
例：
对n个数据排序。
#definen10
main（）
{intk,a[n]={67,89,78,67,87,98,56,90,85,87};
sort（a）;
for（k=0;kprintf（"%d\n",a[k]）;
}
sort（inta[]）
{intk,j,t;
for（k=0;kfor（j=k+1;jif（a[k]}
6．用子函数完成x,x2,x3,…..,xn
floatpowm（floatx,intn）
{floats=1;
inti=1;
for（i=1;i<=n;i++）
s=s*x
returnx;
}
main（）{
intn,k;
floatx;
scanf（“%f%d”,&x,%n）;
for（k=1;k<=n;k++）
printf（“%f\n”,powm（x,k））;
}
7.4函数用数组做实参的应用
说明：
1．函数中使用数组仍要进行类型说明。
2．函数中实参只给数组名。
而形参要说明维数、类型和下标。
3．数组作为实参和形参，有一方改变了其元素值，双方的数组的元素值句均改变。
4．使用数组做实参和形参，可以函数程序中带回多个值。
例：
有n个学生，每个学生3门课程成绩，求每人的平均成绩。
main（）
{intk;
floata[3][4]={1,78,98,88,2,78,67,77,3,66,98,89},r[3];
sum（a,r）;
for（k=0;k<3;k++）
printf（"%d%f\n",a[k][0],r[k]）;
}
sum（floatb[3][4],floatc[3]）
{
intk;
for（k=0;k<3;k++）
c[k]=b[k][1]+b[k][2]+b[k][3];
}
例：
对n个数据排序（绘制流程图）。
#definen10
main（）
{intk,a[n]={67,89,78,67,87,98,56,90,85,87};
sort（a）;
for（k=0;kprintf（"%d\n",a[k]）;
}
sort（inta[]）
{intk,j,t;
for（k=0;kfor（j=k+1;jif（a[k]}
例：
求主对角线元素值的平方和。
main（）
{intk;
floata[3][3]={78,98,88,78,67,77,66,98,89},s;
s=asum（a,3）;
printf（"%d%f\n",s）;
}
floatasum（floatb[][],intn）
{floats=0;
intk;
for（k=0;ks+=b[k][k]+b[k][n-k];
returns;}
7.5局部变量和全局变量
7.5.1局部变量及其概念
1．形参是局部变量。
2．在一个复合语句中定义的变量。
3．在一个函数中定义的变量。
7.5.2全局变量及其概念
1.函数外部定义的变量。
2.用extern说明的变量。
例：
全局变量，一方变化，都变化
intm,n;
main（）
{m=3,n=5;
printf（"%d%d\n",m,n）;
abc（）;
}
abc（）
{
printf（"%d%d",m,n）;
}
例：
有全局变量与局部变量相同，局部变量优先
给出下列程序的运行结果：
intm=3,n=5;
main（）
{intm=30,n=50;/*无此句，一方变化都变化,有此句，局部优先
clrscr（）;
abc（）;
printf（"%d%d\n",m,n）;
abc（）;
}
abc（）
{
m=15,n=17;
printf（"%d%d\n",m,n）;
}
7.6动态存储变量及静态存储变量
7.6.1动态变量
1．程序运行期间，分配内存单元，运行结束，内存单元就释放。
2．形参、局部变量都是动态变量。
3．动态变量用auto说明或省略。
7.6.2静态变量
1．调用函数结束，变量值保留，下次调用值仍存在。
2．静态变量用static说明。
3．数组只有定义成静态时，才能初始化。
4．静态变量自动赋0值。
5．何时需要定义静态数组：
保留函数的变量值和数组初始化。
例：
读程序，给出运行结果
main（）
{intk;
clrscr（）;
for（k=1;k<5;k++）
printf（"%d\n",f（k））;
}
intf（intn）
{intk;
staticintf=1;/*静态变量f，保留上次计算结果
for（k=1;k<=n;k++）
f=f*k;
returnf;
}
7.7寄存器变量
作用：
存取速度快。
特点：
只允许使用三个寄存器变量，且必须是形参和局部变量才能使用。
用法：
用register说明。
intf（intn）
{registerk，f=1;
for（k=1;k<=n;k++）
f=f*k;
returnf;
}
7.8内部函数
放在一个文件中的函数称为内部函数。
7.9外部函数
文件独立存放，能被其他文件中调用的函数称为外部函数。
外部函数在调用程序中要用头文件说明。
7.10函数递归
函数自身调用自身
举例：
1.计算年龄
程序：
main（）
{printf（“age=%d\n”,age（4））;
}
intage（intn）
{intc;
if（n==1）c=16;
elsec=age（n-1）+2;
returnc;
}
2.计算1+2+3+……+100
main（）
{printf（"age=%d\n",age（100））;
}
intsum（intn）
{intc;
if（n==1）c=1;
elsec=sum（n-1）+n;
returnc;
}
3.计算n!
（c=f（n-1）*n）
4.计算0,1,1,2,3,5,8,…..第前20项（return（f（n-1）+f（n-2））;）
main（）
{printf（"age=%d\n",num（19））;
}
intnum（intn）
{intc;
if（n==1）c=0;
elseif（n==2）c=1;
elsec=num（n-1）+num（n-2）;
returnc;
}
函数递归的两个基本条件
（1）边界条件
（2）递归表达式
5.求两个正整数的最大公约数
intgys（intm,intn）
{intr;
r=m%n;
if（r==0）returnn;
gys（n,r）;
}
main（）
{printf（“%d”,gys（24,16））;
}
设计一个过程：
能产生Fibonacci序列数的N个数,即01123581321...。
用主调函数过程调用这个过程并完成：
找出所有是偶数的Fibonacci数，计算这些偶数的平均值。
任务：
设计子过程，产生序列数。
设计主过程，找偶数，统计，求平均值
longfib（inta,b）
{return（a+b）;}
main（）
{longn=18,a=0,b=1;k;
longp=0,num=0
For（k=1;k<=n；k++）
{=fib（a,b）;
if（a%2==0）p+=a;num+=1;
}
Printf（“average=%f\n”,（float）num/n）;
}
设计一个过程：
求两个正整数的最小公倍数。
在主调函数过程中调用这个过程并求m,n的最小公倍数
设计一个过程：
判定任意正整数是否素数。
在主调函数过程中调用这个过程并求出[100，200]范围内的素数的个数。
intprimes（intm）
（intk;
For（k=2;kIf（m%k==0）break;
If（k==m）return1elsereturn0;
}
main（）
{intj,n=0;
for（j=100;j<200,j++）
if（primes（j））n++;
printf（“primesisin100-200=%d”,n）
}
7.11多文件程序的运行
方法一：
建立多个*.c文件（说明型，项目文件型），按顺序放在#include中。
例：
f1.c输出“11111”
f2.c输出“22222”
f3.c调用f1.c,f2.c,再输出“33333”
例：
方法一
/*f3*/
#include“f1.c”/*文件名*/
#include“f2.c”
main（）
{p1（）;p2（）;/*函数名*/
clrscr（）;
printf（“33333\n”）;}
/*f1.c*//*文件名*/
p1（）/*函数名*/
{printf（“11111”\n）;}
/*f2.c*/
p2（）
{prinf（“22222”）;}
方法二、
1.分别建立子函数文件：
f1.c,f2.c,f3.c
2.建立项目文件,文件名后缀一定是*.prj
/*a.prj*/
f1.cf2.cf3.c
或
/*a.prj*/
f1.c
f2.c
f3.c
用save保存为a.prj
将project菜单项中的*.prj改为a.prj
3.编译连接（f9）
4.运行（Ctrlf9）
/*f3*/
main（）
{externp1（）,p2（）;
clrscr（）;
printf（“33333\n”）;}
/*f1.c*/
p1（）
{printf（“11111”\n）;}
/*f2.c*/
p2（）
{prinf（“22222”）;}
方法三:
用extern说明函数为外部函数
例：
求m的n次方（使用方法一）
/*ncf.c*/
#include“ncf.c”
main（）
{
externlongnpow（floata,intn）
clrscr（）;
printf（“npow=%ld\n”,npow（3,3））;
}
/*ncf.c*/
externlongnpow（floata,intn）
{longi,k=1;
for（i=1;i<=n;i++）
k=k*a;
return（k）;}
例：
统计英文句子中L出现的次数（绘制流程图）。
main（）
{chara[80];
intk,n=0;
scanf（“%s”,a）;
for（k=0;a[k];k++）
if（a[k]==’l’||a[k]==’L’）n++;
printf（“%d\n”,n）;
}
数值算法应用举例;
题1:
用普通迭代法求方程f（x）=x+lnx-1.56=0的近似实根r，迭代初值为2，精确到0.0001。
说明:
将f（x）=0转换成x=g（x）形式
x=1.56-lnx
#include“math.h”
main（）
{floatx0,x1=2;
do
{x0=x1;
x1=1.56-log（x0）;}
while（fabs（x1-x0）>1e-3）;
printf（“%f”,x1）;
}
题2:
用牛顿迭代法求方程2x3-4x2+3x-6=0在1.5附近的根
（2）。
f（x）=2x3-4x2+3x-6=0
f’（x）=6x2-8x+3=0
#include“math.h”
main（）
{floatx0,x1=1.5;
floatf（floatx）
floatf1（floatx）
do
{x0=x1;x1=x0-f（x0）/f1（x0）;}
while（fabs（x1-x0）>0.0001）;}
printf（“%f\n”,x1）;}
floatf（floatx）
{return（2*x*x*x-4*x*x+3*x-6）;}
floatf1（floatx）
{return（6*x*x-8*x+3）;}
题3:
用牛顿迭代法求方程x=
从1-10的平方根的根.
x2=a
f（x）=x2-a=0
迭代式:
xn+1=（xn+a/xn）/2
#include“math.h”
main（）
{floata,x0,x1;
for（a=1;a<11;a++）
{x1=a;
do
{x0=x1;x1=（x0+a/x0）/2;}
while（fabs（x1-x0）>0.0001）;
printf（“%f\n”,x1）;}
}
题4:
用矩形法求一元函数f（x）=ln（x+1）+x/2，在区间[1，5]上的积分近似值S，保留2位小数
main（）
{floata=1,b=5,x,sum=0,h.n=100;
H=（b-a）/n;
For（x=a;xsum+=log（x+1）+x/2;
printf（“%f\n”,sum*h）;
}
题5:
用梯形法求一元函数f（x）=ln（x+1）+x/2，在区间[1，5]上的积分近似值S，保留2位小数
方法一:
main（）
{floata=1,b=5,x,sum=0,h.n=100,d1,d2;
H=（b-a）/n;
For（x=a;x{d1=log（x+1）+x/2;
d2=log（x+h+1）+（x+h）/2;
sum+=d1+d2;}
printf（“%f\n”,sum*h/2）;
}
方法二:
main（）
{floata=1,b=5,x,sum=0,h.n=100;
H=（b-a）/n;
For（x=a+h;xsum+=log（x+1）+x/2;}
sum=log（a）+a/2+log（b）+b/2+sum*2;
printf（“%f\n”,sum*h/2）;
}
题6:
用梯形法求积分
近似值S，保留2位小数
#include“math.h”
main（）
{floata=0,b=1.57,x,sum=0,h,n=100;
h=（b-a）/n;
for（x=a+h;xsum+=sin（x）;
sum=sin（a）+sin（b）+sum*2;
printf（“%4.2f\n”,sum*h/2）;
}
升级会员 