第7章 函 数 为什么要使用函数？ 函数定义、调用、声明 局部变量和全局变量 变量的存储类别 内部函数和外部函数 函数的嵌套调用和递归调用 第7章 函 数 为什么要使用函数？ 函数定义、调用、声明 形参和实参 返回值 数组作为函数参数 局部变量和全局变量 变量的存储类别 内部函数和外部函数 函数的嵌套调用和递归调用 小 结 习 题 游 戏

哪个程序扩展性更好？ 例：求a、b两个数中的最大数 a=5; b=10; else m=b; void main() void main() { int a,b,m; a=5; b=10; if (a>b) m=a; else m=b; printf("max=%d",m); } void main() { int a,b,m; a=5; b=10; m=max(a,b); printf("max=%d",m); } int max ( int x, int y ) { int z; if (x>y) z=x; else z=y; return(z);

哪个程序扩展性更好？ 例：求a、b、c、d四个数中的最大数 void main() { int a=1,b=3,c=2,d=5,m; if (a>b) m=a; else m=b; if (c>m) m=c; if ( d>m) m=d; printf("%d",m); } void main() { int a=1,b=3,c=2,d=5,m,e,f; e=max(a,b); f=max(c,d) m=max(e,f); printf("%d",m); } int max ( int x, int y ) { int z; if (x>y) z=x; else z=y; return(z);

怎样让程序看起来简单明了？ aver=average(a,n); 例 数组求平均数 例 冒泡排序 void main() 例 数组求平均数 例 冒泡排序 void main() { int a[10], i,t; float aver; for(i=0；i<10；i++) scanf("%d"，&a[i])； for(i=0；i<9；i++) aver +=a[i]; aver=aver/10; printf("aver=%f",aver); for(i=0；i<=9；i++) printf("%d "，a[i])； } #include <stdio.h> void main() { int i,j,a[10]； printf("input 10 numbers:\n")； for(i=0；i<10；i++) scanf("%d"，&a[i])； printf("\n")； for(j=0；j<9；j++) for(i=0；i<9-j；i++) if(a[i]>a[i+1]) {t=a[i]; a[i]=a[i+1]; a[i+1]=t;} printf("%d "，a[i])； } 输 入 核 心 输 出 //输入数组a[n]函数 inputarray(a,n); inputarray(a,10); //求数组平均数函数 aver=average(a,n); //求数组冒泡排序函数 sort(a,10); //输出数组a[n]函数 outputarray(a,n); outputarray(a,10);

函数的定义 （1）Ｃ语言源程序，由若干个函数函数组成，至少包含一个main函数。程序总是从main函数开始执行。 （2）函数结构 #include<stdio.h> void main() {int max(int x, int y); int a,b,c; scanf("%d,%d",&a,&b); c=max(a,b); printf("max=%d",c); } int max ( int x, int y ) { int z; if (x>y) z=x; else z=y; return(z); （1）Ｃ语言源程序，由若干个函数函数组成，至少包含一个main函数。程序总是从main函数开始执行。 （2）函数结构 [函数类型] 函数名([函数参数表]) { [说明语句部分] [执行语句部分] [return ] }

函数分类 用户使用角度： (1) 库函数-----C语言提供的函数 (2) 自定义函数：完成特殊功能 函数参数： (1) 无参数的函数。 (2）有参数的函数，主调函数与被调函数之间有数据传递。 函数返回值： (1) 无返回值的函数。 void (2）有返回值，带回一个值到主函数 能否被其它源文件调用： (1) 内部函数； (2) 外部函数（如库函数） #include<stdio.h> void main( ) { int max(int x, int y); int a,b,c; scanf("%d,%d",&a,&b); c=max(a,b); printf("max=%d",c); } int max ( int x, int y ) { int z; if (x>y) z=x; else z=y; return(z);

函数 函数声明 函数调用 函数参数 函数返回值 #include<stdio.h> void main() { int max ( int x, int y ); int a,b,c; scanf("%d,%d",&a,&b); c=max(a,b); printf("max=%d",c); } /*求最大值函数*/ int max ( int x, int y ) { int z; if (x>y) z=x; else z=y; return(z); 函数声明 函数调用 函数参数 函数返回值

函数参数：形参和实参1/4 void main() { int max(int x, int y); int a,b,c; scanf("%d,%d",&a,&b); c=max(a, b); printf("max=%d",c); } int max (int x, int y ) { int z; if (x>y) z=x; else z=y; return(z); a b c 10 5 10，5 10 函数返回 函数调用 x y 10 5 10 5 实参:调用函数时实际使用的变量或表达式 z 10 形参：函数定义时参数表中的变量名

函数参数：形参和实参2/4 void main() { int a,b,c; scanf("%d,%d",&a,&b); c=max(a, b); printf("max=%d",c); } int max (int x, int y ) { int z; if (x>y) z=x; else z=y; return(z); 说明：1.形参和实参 必须相同：个数相等 次序相同 类型一致 （否则自动转换） 不必相同： 变量名 实参 例：形参和实参类型不同 int max (int x,int y) { return(x>y?x:y); } main(){ printf("%d",max(4.7,9.6)); } /*输出结果9*/ 形参

函数参数：形参和实参3/4 void main() { int a,b,c; scanf("%d,%d",&a,&b); c=max(a, b); printf("max=%d",c); } int max (int x, int y ) { int z; if (x>y) z=x; else z=y; return(z); 说明：2.形参存储空间 (1)函数被调用时才给形参分配存储单元 (2)实参和形参占用不同的内存单元，同名也互不影响。 (3)函数返回时释放形参所占空间 函数返回 函数调用 10 5 实参 a b c 10 5 int max (int a, int b ) 形参 10 a b 10 5 x y z 10

函数参数：形参和实参4/4 练习：程序运行结果是什么 void main() { int a=5; fun(a); printf("a=%d",a); } void fun(int a) { a=a+5； 1.实参和形参有不同的存储单元 2.实参给形参仅仅是"值传递" 3. 对形参的任何改变不会影响实参 因此：主函数中a不变 实参 5 a 值传递 形参 5 a 10 运行结果：　ａ＝５

函数的返回值 void main() { int a,b,c; scanf("%d,%d",&a,&b); c=max(a, b); return ( 返回值表达式 ); (1) 将流程返回给主调用函数 (2) 将"返回值表达式"的值通过函数名带回主调函数。 (3) void: 明确表示不返回值 void main() { int a,b,c; scanf("%d,%d",&a,&b); c=max(a, b); printf("max=%d",c); } int max (int x, int y ) { int z; if (x>y) z=x; else z=y; return(z); 函数返回 函数调用 10 5 实参 a b c 10 5 10 形参 10 5 x y z 10

函数调用 main() { int a,b,c,m; a=5;b=10;c=15; m=max(a, b); printf("max=%d",m); } int max (int x, int y ) { int z; if (x>y) z=x; else z=y; return(z); 函数调用的一般形式: 函数名([实际参数表]) （1）函数表达式。 函数作为表达式的一项， 以函数返回值参与相关的运算 c=2*max(a,b); （2）函数实参。 把函数的返回值作为另一个 函数调用的实际参数出现。 m=max(max(a,b),c) （3）函数语句。 多用于无返回值的函数。 m=max(max(a,b),c); m=2*max(a,b); 函数返回 函数调用 10 5 实参 形参

函数的声明 例：void main() { float a,b,c,s; scanf("%f %f %f",&a,&b,&c); s=sum(sum(a,b),c); /*函数的调用*/ printf("sum=%f",s); } float sum(float x,float y) /*函数的定义*/ { return(x+y); float sum(float x,float y); /*函数的声明*/

函数的声明 错！不能省略参数类型 函数声明: 在主调函数中对被调函数做声明 格式1： 函数类型 函数名( 参数列表)； 函数类型 函数名( 参数列表)； 格式2： 省略参数的名称，只指定参数的类型 函数类型 函数名(数据类型1 ,数据类型2，…)； #include<stdio.h> void main() { float a,b,c,s; scanf("%f %f %f",&a,&b,&c); s=sum(sum(a,b),c); printf("sum=%f",s); } float sum(float x,float y) { return(x+y); float sum(float x，float y); /*声明*/ float sum(float ,float ); /*声明*/ float sum( x , y ); /*声明*/ 错误案例法 float sum(float x ,float y ); 正确 float sum(float , float ); 正确 float sum( x , y ); 错误

函数 练习1 (1) 有以下程序  void f(int x,int y)  { int t;  if(x<y){ t=x; x=y; y=t; }  }  main()  { int a=4,b=3,c=5;  f(a,b);  f(a,c);  f(b,c);  printf("%d,%d,%d\n",a,b,c);  }  执行后输出的结果是  A) 3,4,5  B) 5,3,4  C) 5,4,3  D) 4,3,5  不带回返回值 1.实参和形参有不同的存储单元 2.实参给形参仅仅是"值传递" 3. 对形参的任何改变不会影响实参 因此：函数f中不改变abc的值 函数 语句

函数 练习2 函数嵌套 F(3,4) = 3 F(3,5)=6 F(3,6)=9 (2) 若有以下程序  int f(int x,int y)  { return (y-x)*x; }  main()  { int a=3,b=4,c=5,d;  d=f(f(3,4),f(3,5));  printf("%d\n",d);  }  执行后输出结果是 。  函数嵌套 F(3,4) = 3 F(3,5)=6 F(3,6)=9 函数实参 9

函数 练习3 (3) 若程序中定义了以下函数 double myadd(double a,double b) (3) 若程序中定义了以下函数 double myadd(double a,double b) { return (a+b);} 并将其放在调用语句之后，则在调用之前应该对该函数进行说明，以下选项中错误的说明是（） A) double myadd(double a,b); B) double myadd(double,double); C) double myadd(double b,double a); D) double myadd(double x,double y);  不能省略形参类型 可以省略形参名 完整版 形参名可以和定义时不同

A0701 求N！ (变量参数,有返回值) 及累加和 long factorial ( int n) { int i; //函数:阶乘 long factorial ( int n) { int i; long int k; return k; } void main() { long int k; int i,n; printf("input a int number<15: "); scanf("%d",&n); printf("%d!=%ld\n",n,k); } long factorial ( int n); //函数: 累加和 int sum ( int n) { long int a=0; for(i=1;i<=n;i++) a += i; return a; } k=factorial(n); for(i=1,k=1;i<=n;i++) k *= i; printf("1+...+%d=%ld\n",n,sum(n));

A0702 求数组平均值(数组参数,有/无返回值) inputarray(a,10); //函数:输入数组a[n] void inputarray(int a[], int n) { int i; } #define N 10 void main() { int i, a[10]； float aver=0; printf("average = %.2f\n",aver); } void inputarray(int a[], int n) float average(int a[], int n) n n printf("input %d num:\n",N ); for(i=0；i<N ;i++) scanf("%d"，&a[i])； printf("\n")； 输 入 核 心 inputarray(a,10); //函数:数组a[n]的平均值 float average(int a[], int n) { int i; float aver=0; return aver; } for(i=0;i<N ;i++) aver+=a[i]; aver=aver/N; n aver=average(a,N); n

A0703 冒泡排序1 (数组参数, 无返回值) inputarray(a,10); outputarray(a,10); //函数:输入数组a[n] void inputarray(int a[], int n) { int i; } void main() { int i,j,a[10]； printf("input 10 numbers:\n")； for(j=0；j<9；j++) for(i=0；i<9-j；i++) if(a[i]>a[i+1]) {t=a[i]; a[i]=a[i+1];a[i+1]=t;} } n 输 入 核 心 输 出 for(i=0；i<10；i++) scanf("%d"，&a[i])； printf("\n")； inputarray(a,10); //函数:输出数组a[n] void outputarray(int a[], int n) { int i; } n for(i=0；i<10；i++) printf("%d "，a[i])； outputarray(a,10);

A0703 冒泡排序2 (数组参数, 无返回值) sort(a,10); void sort(int a[], int n) //函数:输入数组a[n] void sort(int a[], int n) { int i,j; } void main() { int i,j,a[10]； printf("input 10 numbers:\n")； inputarray(a,10); outputarray(a,10); } n-1; n-1-j; 输 入 核 心 输 出 for(j=0；j<9；j++) for(i=0；i< 9-j ；i++) if(a[i]>a[i+1]) { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } //函数:对数组a[n] 排序 sort(a,10);

A0704 大小写转换 (数组参数,无返回值) A0704 用函数重做A0608：键盘输入一串字符，将其中的大写字母转换成小写字母后输出 void main() { int i; char str[80]； printf("input string:\n"); gets(string); puts(string); } /*函数：将str字符数组中大写字母转为小写字母*/ void lowercase(char str[]) { int i; } for(i=0;str[i]!='\0';i++) if( str[i]>='A' && str[i]<='Z') str[i] += 32; 核 心 //函数：大写转小写 lowercase(str);

A0705 数组名 做函数参数 #include "stdio.h" f(int array[],int n) { array[n]++； 数组名作参数表示地址传递 实参数组—地址传递—形参数组 f和main在对同一个存储单元操作 f中对数组的改变影响main 中数组的值 #include "stdio.h" f(int array[],int n) { array[n]++； } void main() { int a[]={1，2，3，4，5 }； f(a，2)； printf("%d\n"，a[2])； a[0]a[1] a[2] a[3] a[4] array[0] array[1] array[2] array[3] array[4] 1 2 3 4 5 4 程序运行结果：4

数组元素 做函数参数 #include <stdio.h> void f(int n) { n++； } void main() 数组元素使用时与普通变量一样 实参——值传递——形参 a[2]和普通变量一样为值传递 (f和main对不同的存储单元操作, f中n改变不影响main函数中a[2]值 #include <stdio.h> void f(int n) { n++； } void main() { int a[]={1，2，3，4，5 }； f(a[2])； printf("%d\n"，a[2])； 函数调用 函数返回 a[0]a[1] a[2] a[3] a[4] 1 2 3 4 5 程序运行结果：3 3 n 4

数组名 做函数参数 数组名作参数表示地址 传递，（即函数f中的改变 影响main函数中的值，f和main在对同一个存储单元操作） 练习： 下面程序运行结果 #include "stdio.h" f(int b[]，int m，int n) { int i； for(i=m；i<n；i++) b[i]++； } void main() { int x，a[]={1，2，3，4，5，6，7，8，9}； f(a，3，7)； for(i=0；i<9；i++) printf("%d\n"，a[i])； 数组名作参数表示地址 传递，（即函数f中的改变 影响main函数中的值，f和main在对同一个存储单元操作） 1，2，3，5，6，7，8，8，9

变量的生存期 例： void main() { int a,b,c; scanf("%d,%d",&a,&b); c=max(a, b); printf("max=%d",c); } int max (int x, int y ) { int z; if (x>y) z=x; else z=y; return(z); 生存期 (时间） 不同的变量"出现"和"消失"的时间不同 10，5 函数返回 函数调用 实参 a b c 10 5 10 形参 x y 10 5 z 10

变量的作用域 例： void main() { void add(); //函数声明 a=5； int a; add(); //函数调用 作用域(空间）： 不同位置的变量"有效"范围不同 生存期 (时间） 不同的变量"出现"和"消失"的时间不同 例： void main() { void add(); //函数声明 a=5； add(); //函数调用 printf("a=%d",a); } void add ( ) //函数定义 { a=a+5; 变量a的有效范围 int a; a有效范围 a 10 5 错！此处变量a未定义 运行结果：a=10

全局变量和局部变量 (1) 局部变量 作用域：某函数内定义的变量 ，只在该函数内有效。 生存期：与定义它的函数相同。 (2) 全局 变量 (1) 局部变量 作用域：某函数内定义的变量 ，只在该函数内有效。 生存期：与定义它的函数相同。 (2) 全局 变量 作用域：在函数之外说明的变量从定义点到本文结束都有效 生存期：生存到本文结束 void main() { int a,b,c; //局部变量 scanf("%d,%d",&a,&b); c=max(a, b); printf("max=%d",c); } int max (int x, int y ) { int z; //形参也是局部变量 if (x>y) z=x; else z=y; return(z); int a; //全局变量 void main() { void add(); a=5； add(); printf("a=%d",a); } void add ( ) { a=a+5;

全局变量和局部变量 void inputarray(int a[],int n) { int i; A0706 求数组的平均数 printf("input %d matrix:\n",n); for(i=0；i<n ；i++) scanf("%d"，&a[i]); } A0706 求数组的平均数 全局变量能被所有函数使用 #define N 10 float aver; void main() { int a[N]; void input( int a[], int); //函数声明 void average(int a[],int); //函数声明 input(a,N); //函数调用 average(a,N); //函数调用 printf("%f",aver); } 局部变量在main中有效，可作为参数被其他函数使用 局部变量在average函数中有效 void average(int a[],int n) { int i,s=0; for(i=0;i< n ;i++) s+=a[i]; aver=(float)(s)/n; }

全局变量和局部变量 练习 #include <stdio.h> int a,b; /*a，b为全局变量*/ void f1( ) 全局变量和局部变量 练习 #include <stdio.h> void f1( ) { int t1,t2; t1 = a * 2; t2 = b * 3; b = 100； printf ("t1=%d,t2=%d\n", t1, t2); } main() { int a=2; b=4; f1( ); printf ("a=%d,b=%d", a, b); int a,b; /*a，b为全局变量*/ 全局变量ab的值可在任何一个函数中改变。 程序输出结果为: t1=4,t2=12 a=2,b=100 a=2; b=4; 错！ main中的局部变量a、b不能被函数f使用

C语言内存分配 数据在程序运行期间，根据需要分配空间，用完之后即释放所占据的空间，故其的生命期相比整个程序的运行期要短。如: 内部变量 1 代码区： 存放程序的指令 1 代码 2 静态数据 3 动态数据（栈stack） 4 自由空间（堆heap） 2 静态数据区： 数据在程序运行过程中一直存在，程序结束后，静态数据所占据的空间被释放。如：全局变量 3 动态数据区： 数据在程序运行期间，根据需要分配空间，用完之后即释放所占据的空间，故其的生命期相比整个程序的运行期要短。如: 内部变量

变量的存储类别 变量都有不同的存储属性，对应不同的作用域和生存期。 自动类[auto] 静态类[static] 自动变量，只在该函数内有效 前面所学变量默认为：auto 静态类[static] 寄存器类[register] (了解） 外部类[extern]

static（静态变量） 静态存储 生存期：从定义开始到本文件结束（函数调用结束也不释放） 作用域：在定义的函数内有效，其它函数不能引用它们 初始化： 在编译时只初始化一次 定义时若无初始化则自动赋为"０" A0707-1例： main( ) { int i; for(i=0;i<3;i++) fa(); } void fa( ) { int a=0; a=a+1; printf("%d\n",a); A0707-2例： main ( ) { int i; for(i=0;i<3;i++) fs(); } void fs( ) { static int b=0; b=b+1; printf("%d\n",b); 输出结果 1 输出结果 1 2 3 static b在函数每次调用时其值都被保留。

static（静态变量） 静态变量 自动变量 全局变量 生命期 从定义开始到文件结束 从定义开始到本函数结束 作用域 限于本函数

外部变量extern （在同一个文件中） 例：给出长l、宽w、高h，计算体积 int vs(int l,int w) { int v； v=l*w*h； /*使用外部变量h的值*/ return v； } main() { int l=5,w=2； /*内部变量的定义*/ printf("v=%d",vs(l,w))； int h=5； /*定义外部变量h*/ extern int h； /*说明外部变量h*/

外部变量extern （在多个文件中） //源文件一：f1.c 求数组和 #define N 5 float sum; void main() { int i; int a[N]={1,2,3,4,5}; for(i=0;i<N;i++) sum +=a[i]; printf("sum=%f",sum); } //源文件二：f2.c 求数组平均值 extern float sum; void average() { float aver; aver=sum/5; printf("aver=%f",aver); } 运行结果：sum=15.000000

外部函数extern /*源文件一：f1.c*/ #define N 5 float sum; void main() { int i; int a[N]={1,2,3,4,5}; for(i=0;i<N;i++) sum +=a[i]; printf("sum=%f",sum); } /*源文件二：f2.c*/ extern float sum; void average() { float aver; aver=sum/5; printf("aver=%f",aver); } extern //外部函数声明 extern void average(); average(); //外部函数调用 运行结果：sum=15.000000 aver=3.000000

外部函数 A0708 外部函数extern：可以被其他文件调用的函数 为什么没有外部说明？ //文件sort.c : 主函数完成冒泡程序 #include<stdio.h> void main() { void input(int a[],int n); void output(int a[],int n); int a[10],i,j,t; input(a,10); //外部函数调用 for(j=0;j<9;j++) for(i=0;i<9-j;i++) if(a[i]>a[i+1]) {t=a[i]; a[i]=a[i+1];a[i+1]=t;} output(a,10); //外部函数调用 } // 文件inout.c :数组输入输出函数文件 #include<stdio.h> //外部函数定义 extern void input(int a[],int n) { int i; printf("input %d number:\n",n); for(i=0;i<n;i++) scanf("%d",&a[i]); } extern void output(int a[],int n) printf("%5d",a[i]); //外部函数声明 extern 为什么没有外部说明？ 本页结束后，思考问题 " printf和scanf" 也是外部函数，但是没有显式的外部说明，如何使用？

定义头文件 (1)保存为 inout.h :头文件 (2)保存路径： VC/include 文件夹下 或 当前C程序文件夹下 // 文件inout.c :数组输入输出函数文件#include<stdio.h> extern void input(int a[],int n) //数组输入 { ……. } extern void output(int a[],int n) //数组输出 { ……. } (1)保存为 inout.h :头文件 (2)保存路径： VC/include 文件夹下 或 当前C程序文件夹下 例：程序二：冒泡排序 #include " inout.h" void main() { int a[10],i,j,t; input(a,10); //外部函数调用 for(j=0;j<9;j++) for(i=0;i<9-j;i++) if(a[i]>a[i+1]) { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } output(a,10); //外部函数调用 } 例：程序一：求数组累加和 void main() { int a[10], i,sum=0; input(a,10); //外部函数调用 for(i=0;i<10;i++) sum += a[i]; output(a,10); //外部函数调用 printf("sum=%d",sum); } #include< inout.h>

函 数 嵌 套 例：求 N！ A0709例：求1！+2！+3！+…+N！ void main() { long factorial ( int n); long int k; int i,n; printf("int num: "); scanf("%d",&n); printf("%ld\n",k); } long fsum(int num) { int n; long k, sum=0; for(n=1;n<=num;n++) { k=factorial(n); sum +=k; } return sum; #include<stdio.h> void main() { long fsum(int n); long sum; int n; scanf("%d",n) sum=fsum(n); printf("%ld",sum); } long factorial ( int n); //函数:阶乘 long factorial ( int n) { int i; long int k=1; return k; } k=factorial(n); for(i=1;i<=n;i++) k *= i;

函数嵌套 函数的嵌套调用是指，在执行被调用函数时，被调用函数又调用了其它函数。 函数调用可以嵌套，但定义只能是平行关系。

用递归算法计算n！ A0710采用递归的方法计算n! 的递归定义形式的: 编程: 1 n=0; n!= n* (n-1)! n>0 if (初始条件) 表达式; else 递推表达式;

用递归算法计算n！ #include <stdio.h> long fac(unsigned n) { long f ; if (n==0) f=1; /*递归结束条件*/ else f=n*fac(n-1); return f; } 1 n=0; n!= n* (n-1)! n>0 main( ) { long y; int n; long fac(unsigned n); scanf("%d", &n); y = fac(n); printf("%d=%ld\n", n, y); }

用递归算法计算n！----输入3 fac(3) fac(3) = 3 *fac(2) = 3 *2=6 fac(2) fac(2) if (n==0) f=1; /*递归结束条件*/ else f=n*fac(n-1); fac(3) = 3 *fac(2) fac(3) = 3 *2=6 fac(2) = 2 *fac(1) fac(2) = 2*1=2 递推 回归 fac(1) = 1 *fac(0) fac(1) = 1*1=1 fac(0)=1

函数的递归调用 所谓递归调用，就是指定义的函数自己直接或间接调用自己。 直接递归调用 间接递归调用 函数直接在自身的函数 体中调用函数本身。 f(a,b,c){ . f(x,y,z); } 间接递归调用 函数之间在自己的函数体中 相互交叉调用。 g(x,y); g(t,b){

小结——函 数 函数——功能相对独立的一段程序 优点：1. 优化程序结构，增强代码复用 2. 使主函数简单明了，含义清晰，增强程序的可读性 主控模块 模块1_1 模块1_n 模块2_1 模块2_n 模块n_1 模块n_n 模块1 模块2 模块n

小结——函数 函数声明 函数调用 函数定义 函数参数 函数返回值 不能省略参数类型 #include<stdio.h> void main() { int max ( int x, int y ); int a,b,c; scanf("%d,%d",&a,&b); c=max(a,b); printf("max=%d",c); } /*求最大值函数*/ int max ( int x, int y ) { int z; if (x>y) z=x; else z=y; return(z); 函数调用 调用时参数必须匹配 可作为表达式一部分或者单独语句调用 函数定义 参数 返回值 函数参数 形参和实参 数组名作为参数 值传递、地址传递 函数返回值 只能返回一个值 遇到 return回到主调函数

函数 习题 B0701 ：键盘输入10个数，找最大数、最小数。要求写出数组输入函数，找最大最小数函数。 C0701：用菜单结构编程完成以下任务： 键盘输入某班30人C语言成绩，要求 1. 求平均成绩 2. 统计各分数段人数，并输出 3. 输出最高分及学号 4. 输出最低分及学号 5. 打印成绩优秀(90~100)的学生学号及成绩 6. 打印成绩不及格(0~59)的学生学号及成绩

函数 作业 #include<stdio.h> #define N 30 void input(int a[],int n) void main() { void f1(int a[],int); void f2(int a[],int); void f3(int a[],int); void f4(int a[],int); void f5(int a[],int); void f6(int a[],int); void input(int a[],int); int a[N+1]; input(a,N); f1(a,N); ..... } void input(int a[],int n) { int i; for(i=1;i<=n;i++) scanf("%d",&a[i]); } void f1(int a[],int n) float aver=0; aver+=a[i]; aver= aver/n; printf("aver=%8.2f",aver); 键盘输入某班30人C语言成绩，要求 1. 求平均成绩 2. 统计各分数段人数，并输出 3. 输出最高分及学号 4. 输出最低分及学号 5. 打印优秀(90~100)的学生学号及成绩 6. 打印不及格(0~59)的学生学号及成绩 数组输入

游戏扩展 C0702 游戏集