第7章用函数实现模块化程序设计

实验三

项目名称：循环结构程序设计实验目的1、熟练掌握for语句的使用；2、熟练掌握break语句与continue语句的使用；3、能够用循环实现一些常用算法；4、循环嵌套的应用。实验四:

项目名称：数组

实验目的

1、熟练掌握一维数组、二维数组定义、赋值和输入输出方法；

2、熟练掌握字符数组和字符串函数的使用；

3、掌握有关数组的一些常用算法；

实验内容：习题6.5,6.13,6.15实验目的1、掌握函数的定义方法；2、掌握函数的调用及函数声明；3、掌握局部变量和全局变量的使用。实验内容1、习题7.3；2、习题7.8；3、习题7.18；（选做）4、找出以下程序的正确运行结果，并对结果进行分析实验五

项目名称：函数#defineMAX10inta[MAX]，i；main（）{ printf（“\n”）；

sub1()；

sub3（a）；

sub2（）；

sub3（a）；}sub2（）{ inta[MAX]，i，max；

max=5；

for（i=0；i<max；i++）

a[i]=i；}sub1（）{ for（i=0；i<MAX；i++）

a[i]=i+i；}sub3（inta[]）{ inti；

for（i=0；i<MAX；i++）

printf（"%d"，a[i]）；

printf（"\n"）;}实验六指针和结构体实验内容：第八章习题：8.6（要求预习报告）第九章习题：9.5第七章用函数实现

模块化程序设计秦丹阳黑龙江大学电子工程学院通信工程系TEL:86608943E-mail:qindanyang@7.1

为什么要用函数模块化程序设计基本思想：将一个大的程序按功能分割成一些小模块,每个模块用来实现一个特定的功能。特点：各模块相对独立、功能单一、结构清晰、接口简单控制了程序设计的复杂性提高元件的可靠性缩短开发周期避免程序开发的重复劳动易于维护和功能扩充开发方法:自上向下,逐步分解，分而治之C是模块化程序设计语言程序中函数调用示意图#include<stdio.h>/*8-1.c*/intmain(){ voidprintstar(); /*对printstar函数进行声明*/ voidprint_message(); /*对print_message函数进行声明*/ printstar(); /*调用printstar函数*/ print_message(); /*调用print_message函数*/ printstar(); return0; /*调用printstar函数*/}voidprintstar() /*定义printstar函数*/{ printf(“********************************\n”);}voidprint_message() /*定义print_message函数*/{ printf(“Howdoyoudo!\n”);}********************************

Howdoyoudo!********************************函数说明一个C程序是由一个或多个程序模块组成，每一个程序模块作为一个源程序文件。一个源程序文件可以为多个C程序共用。每个源程序文件由若干函数组成。一个源程序文件是一个编译单位。C程序的执行从main函数开始，也从main函数终止。必须有且只能有一个名为main的主函数源程序中所有的函数在结构上都是平行的，即在定义函数时是分别进行的，互相独立的。一个函数并不从属于另一个函数，即函数不能嵌套定义。main函数可以调用其他函数，其他函数之间可以互相调用。main函数是系统调用的。函数分类从用户角度标准函数（库函数）：由系统提供，用户不用定义，可以直接使用用户自定义函数：用以解决用户专门需要的函数从函数形式无参函数在调用无参函数时，主调函数不向被调用函数传递数据。一般用来执行指定的一组操作。有参函数在调用函数时，主调函数在调用被调用函数时，通过参数向被调用函数传递数据。使用库函数应注意：1、函数功能2、函数参数的数目和顺序，及各参数意义和类型3、函数返回值意义和类型4、需要使用的包含文件voidprintstar() voidprint_message()intmax(intx,inty)7.2

怎么定义函数7.2.1为什么要定义函数定义函数应包括的内容指定函数的名字，以便以后按名调用指定函数的类型，即函数返回值的类型指定函数参数的名字和类型，以便在调用时向它们传递数据指定函数功能intmax(intx,inty)7.2.2定义函数的方法定义无参函数合法标识符函数返回值类型缺省int型无返回值void函数体函数类型函数名（）{

声明部分 语句部分}函数类型函数名（void）{

声明部分 语句部分}例无参函数

voidprintstar(){printf(“**********\n”);}或

voidprintstar(void){printf(“**********\n”);}定义有参函数合法标识符函数返回值类型缺省int型无返回值void函数体函数类型函数名（形式参数列表）{

声明部分

语句部分}例有参函数

intmax(intx,inty){intz;z=x>y?x:y;return(z);}例有参函数

intmax(intx,y){intz;z=x>y?x:y;return(z);}定义空函数函数类型函数名（）{

}例空函数

voiddummy(){}函数体为空#include<stdio.h>/*1-3.c*/intmain(){intmax(intx,inty);inta,b,c;scanf(“%d,%d”,&a,&b);c=max(a,b);printf(“max=%d\n”,c);return0；}输入：4，6输出：6intmax(intx,inty){ intz; if(x>y) z=x; elsez=y; return(z);}

求最大值函数函数类型函数名（形参表）形参类型说明{

说明部分 语句部分}传统风格:例有参函数（传统风格）

intmax(x,y)

intx,y;{intz;z=x>y?x:y;return(z);}7.3

调用函数7.3.1函数调用的形式函数调用的一般形式函数名(实参表列)说明：若调用无参函数，则实参表为空，但括号不能省略若实参表列包含多个实参，则各参数间用逗号隔开。实参与形参个数相等，类型一致，按顺序一一对应实参表求值顺序，因系统而定（TurboC自右向左）voidprintstar()voidmain(){intmax(intx,inty);inta,b,c;scanf("%d,%d",&a,&b);c=max(a,b);printf("Maxis%d",c);}intmax(intx,inty){intz;z=x>y?x:y;return(z);}voidmain()/*8-7.c*/{inti=2,p;p=f(i,++i);printf("%d",p);}intf(inta,intb){intc;if(a>b)c=1;elseif(a==b)c=0;elsec=-1;return(c);}例参数求值顺序voidmain(){inti=2,p;p=f(i,i++);printf("%d",p);}intf(inta,intb){intc;if(a>b)c=1;elseif(a==b)c=0;elsec=-1;return(c);}运行结果：0运行结果：1调用方式函数调用语句：把函数调用单独作为一个语句例printstar();printf(“Hello,World!\n”);函数表达式：函数调用出现在另一个表达式中例m=max(a,b)*2;函数参数：

函数调用作为另一个函数调用时的实参例printf(“%d”,max(a,b));m=max(a,max(b,c));说明:调用函数不一定要求包括分号7.3.2函数调用时的数据传递形式参数和实际参数形式参数：定义函数时函数名后面括号中的变量名。简称“形参”实际参数：在主调函数中调用一个函数时，函数名后面括号中的参数或表达式。简称“实参”实参和形参间的数据传递（虚实结合）在调用函数过程中，系统会把实参的值传递给被调用函数的形参该值在函数调用期间有效，可以参加该函数中的运算c=max(a,b);（main函数）

（max函数）intmax(intx,inty){intz;z=x>y?x:y;return(z);}【例7.2】输入两个整数，要求输出其中值较大者，要求用函数实现intmain(){intmax(intx,inty);inta,b,c;scanf("%d,%d",&a,&b);c=max(a,b);printf("Maxis%d",c);return0；}intmax(intx,inty){intz;z=x>y?x:y;return(z);}形参实参对max函数的声明定义有参函数max说明：实参可以是常量、变量或表达式，但必须有确定的值。在调用时将实参的值赋给形参形参必须指定类型形参与实参类型一致，个数相同若形参与实参类型不一致，自动按形参类型转换———函数调用转换如：max(3,a+b)7.3.3函数调用过程形参在未被调用时，不占内存中的存储单元在发生函数调用时，形参被临时分配内存单元将实参对应的值传递给形参在执行被调用函数期间，由于形参已经有值，可以利用形参进行相关的运算通过return语句将函数值带回到主调函数。若函数不需要返回值，则不需要return语句（void）调用结束，形参内存单元被释放。c=max(a,b);（main函数）

（max函数）intmax(intx,inty){intz;z=x>y?x:y;return(z);}例计算x的立方#include<stdio.h>/*8-2.c*/floatcube(floatx){return(x*x*x);}voidmain(){floata,product;printf("Pleaseinputvalueofa:");scanf("%f",&a);product=cube(a);printf(”Cubeof%.4fis%.4f\n",a,product);}xaproduct××××1.21.21.728参数传递方式值传递方式方式：函数调用时,为形参分配单元,并将实参的值复制到形参中；调用结束，形参单元被释放，实参单元仍保留并维持原值特点：形参与实参占用不同的内存单元单向传递（实参->形参）711x:y:调用前：调用结束：711x:y:例交换两个数/*8-3.c*/#include<stdio.h>voidmain(){intx=7,y=11;printf("x=%d,\ty=%d\n",x,y);printf("swapped:\n");

swap(x,y);printf("x=%d,\ty=%d\n",x,y);}swap(inta,intb){inttemp;temp=a;a=b;b=temp;}调用：711a:b:711x:y:swap:711x:y:117a:b:temp#include<stdio.h>/*8-4.c*/

longsum(inta,intb);longfactorial(intn);voidmain(){intn1,n2;longa;scanf("%d,%d",&n1,&n2);a=sum(n1,n2);printf("a=%1d",a);}longsum(inta,intb){longc1,c2;c1=factorial(a);c2=factorial(b);

return(c1+c2);}

longfactorial(intn){longrtn=1;inti;for(i=1;i<=n;i++)rtn*=i;

return(rtn);}longsum(inta,intb);longfactorial(intn);文件包含编译预处理命令函数类型说明函数定义函数调用函数调用函数返回值形参实参7.3.4函数的返回值返回语句形式：return(表达式)；

或

return表达式;

或

return;功能：使程序控制从被调用函数返回到调用函数中，同时把返回值带给调用函数c=max(a,b);（main函数）

（max函数）intmax(intx,inty){intz;z=x>y?x:y;return(z);}voidmain(){intmax(intx,inty);inta,b,c;scanf("%d,%d",&a,&b);c=max(a,b);printf("Maxis%d",c);}intmax(intx,inty){intz;z=x>y?x:y;return(z);}说明：函数中可有多个return语句如果不需要从被调函数带回函数值可不要return语句return语句后面的括号可以不要；return后面的值可以是一个表达式。若无return语句，遇}时，自动返回调用函数在定义函数时需指定函数值的类型，如无函数类型说明，则自动按整型处理。函数类型要与return语句中的表达式类型一致。若函数类型与return语句中表达式值的类型不一致，按前者为准，自动转换------函数调用转换不带回值的函数，应当用void定义函数为无类型（空类型），此时函数体中不得出现return语句。例无返回值函数

voidswap(intx,inty){inttemp;temp=x;x=y;y=temp;}intmax(intx,inty){returnx>y?x:y;}例函数返回值类型转换voidmain()/*8-6.c*/{intmax(floatx,floaty)floata,b;intc;scanf("%f,%f",&a,&b);c=max(a,b);printf("Maxis%d\n",c);}intmax(floatx,floaty){floatz;z=x>y?x:y;

return(z);}printstar()/*8-5.c*/{printf("**********");}voidmain(){inta;a=printstar();printf("%d",a);}例函数带回不确定值输出：10voidprintstar(){printf("**********");}voidmain(){inta;a=printstar();printf("%d",a);}编译错误！对被调用函数要求：必须是已经定义的函数若使用库函数:#include<*.h>用户自定义函数:若该函数的位置在主调函数后面时，在主调函数中对被调用函数作声明7.4

对被调用函数的声明和函数原型【例7.4

】输入两个实数，用一个函数求出它们之和main(){floata,b;intc;scanf("%f,%f",&a,&b);c=max(a,b);printf("Maxis%d\n",c);}max(floatx,floaty){floatz;z=x>y?x:y;return(z);}int型函数可不作函数说明（BorlandC++不行）/*ch7_5.c*/floatadd(floatx,floaty){floatz;z=x+y;return(z);}main(){floata,b,c;scanf("%f,%f",&a,&b);c=add(a,b);printf("sumis%f",c);}被调函数出现在主调函数之前，不必函数说明/*8-8.c*/intmain(){floatadd(floatx,floaty);/*functiondeclaration*/floata,b,c;scanf("%f,%f",&a,&b);c=add(a,b);printf("sumis%f",c);return0；}floatadd(floatx,floaty){floatz;z=x+y;return(z);}floatadd(float,float);函数声明一般形式：函数类型函数名(形参类型1形参名1,形参类型2形参名2，…);

或函数类型函数名(形参类型1，形参类型2，…);作用：告诉编译系统函数类型、参数个数及类型，以便检验函数定义与函数声明不同（；）函数声明位置：程序的数据说明部分（函数内或外）下列情况下，可不作函数声明若函数返值是char或int型，系统自动按int型处理被调用函数定义出现在主调函数之前文件开头已对本文件中所调用的函数进行了声明有些系统要求函数声明指出函数返值类型和形参类型，并且对void和int型函数也要进行函数声明voidmain(){intmax(intx,inty);inta,b,c;scanf("%d,%d",&a,&b);c=max(a,b);printf("Maxis%d",c);}intmax(intx,inty){intz;z=x>y?x:y;return(z);}7.5

函数的嵌套调用C规定：函数定义不可嵌套，但可以嵌套调用函数main()调用函数a结束a函数b函数调用函数b

例求三个数中最大数和最小数的差值#include<stdio.h>/*8-9.c*/

intdif(intx,inty,intz);intmax(intx,inty,intz);intmin(intx,inty,intz);voidmain(){inta,b,c,d;scanf("%d%d%d",&a,&b,&c);

d=dif(a,b,c);printf("Max-Min=%d\n",d);}intdif(intx,inty,intz){returnmax(x,y,z)-min(x,y,z);}intmax(intx,inty,intz){intr;r=x>y?x:y;return(r>z?r:z);}intmin(intx,inty,intz){intr;r=x<y?x:y;return(r<z?r:z);}main()调用函数dif输出结束dif函数max函数调用函数max调用函数minmin函数【例7.5】输入4个整数，找出其中最大的数。用函数的嵌套调用处理#include<stdio.h>intmain(){ intmax4(inta,intb,intc,intd); inta,b,c,d,max; printf("pleaseenter4intergernumbers:"); scanf("%d%d%d%d",&a,&b,&c,&d); max=max4(a,b,c,d); printf("max=%d\n",max); return0;}intmax4(inta,intb,intc,intd){ intmax2(inta,intb); intm; m=max2(a,b); m=max2(m,c); m=max2(m,d); return(m);}

intmax2(inta,intb){ if(a>=b) returna; else returnb;}定义：函数直接或间接的调用自身叫函数的递归调用f()调f调f2调f1f1()f2()说明C编译系统对递归函数的自调用次数没有限制每调用函数一次，在内存堆栈区分配空间，用于存放函数变量、返回值等信息，所以递归次数过多，可能引起堆栈溢出intf(intx){inty,z;……

z=f(y);…….return(2*z);}intf1(intx){inty,z;……

z=f2(y);…….return(2*z);}intf2(intt){inta,c;……

c=f1(a);…….return(3+c);}7.6函数的递归调用例求n的阶乘/*ch7_8.c*/#include<stdio.h>intfac(intn){intf;if(n<0)printf("n<0,dataerror!");elseif(n==0||n==1)f=1;elsef=fac(n-1)*n;return(f);}main(){intn,y;printf("Inputaintegernumber:");scanf("%d",&n);

y=fac(n);printf("%d!=%15d",n,y);}7.7

数组作为函数参数(5.6)7.7.1数组元素作函数实参——值传递【例7.9】输入10个数,要求输出其中值最大的元素和该数是第几个数.定义一个数组a,长度为10,用来存放10个数.设计一个函数max,用来求两个数中的大者.主函数中定义一个变量m,用来存放max函数返回值#include<stdio.h>intmain(){intmax(intx,inty);inta[10],i,n,m;printf("Enter10integernumbers:");for(i=0;i<10;i++) scanf("%d",&a[i]);printf("\n");for(i=1,m=a[0],n=0;i<10;i++) if(max(m,a[i])>m){m=max(m,a[i]); n=i;}printf(“thelargestnumberis%d\n”,m);

printf(“

itisthe%dthnumber.\n”,n+1);return0;}intmax(intx,inty){return(x>y?x:y);}例两个数组大小比较(5.7)432105a562312107688432105b212343986654n=0m=0k=0in=0m=0k=1in=0m=1k=1in=1m=1k=1in=1m=1k=2in=2m=1k=2in=3m=1k=2a和b为有10个元素的整型数组比较两数组对应元素变量n,m,k记录a[i]>b[i],a[i]==b[i],a[i]<b[i]的个数最后若n>k,认为数组a>b

若n<k,认为数组a<b

若n==k,认为数组a==b#include<stdio.h>/*8-11.c*/voidmain(){inta[10],b[10],i,n=0,m=0,k=0;printf("Enterarraya:\n");for(i=0;i<10;i++) scanf("%d",&a[i]);printf("Enterarrayb:\n");for(i=0;i<10;i++) scanf("%d",&b[i]);for(i=0;i<10;i++){if(large(a[i],b[i])==1)n=n+1;elseif(large(a[i],b[i])==0)m=m+1;elsek=k+1;}

/*Output*/}intlarge(intx,inty){intflag;if(x>y)flag=1;elseif(x<y)flag=-1;elseflag=0;return(flag);}7.7.2数组名作函数参数地址传递：传递的是数组首元素的地址在主调函数与被调函数分别定义数组,且类型应一致形参数组大小(多维数组第一维)可不指定形参数组名是地址变量【例7.10】有一个一维数组score,内放10个学生成绩,求平均成绩

#include<stdio.h>/*8-12.c*/intmain(){floataverage(floatarray[10]);floatscore[10],aver;inti;printf("Input10scores:\n");for(i=0;i<10;i++)scanf("%f",&score[i]);printf("\n");aver=average(score);printf("Averageis:%5.2f",aver);return0;}floataverage(floatarray[10]){inti;floataver,sum=array[0];for(i=1;i<10;i++)sum=sum+array[i];aver=sum/10;returnaver;}实参用数组名形参用数组定义,

floatarray[]..2109score562312….….88array地址传递：传递的是数组首元素的地址在主调函数与被调函数分别定义数组,且类型应一致形参数组大小(多维数组第一维)可不指定形参数组名是地址变量例求学生的平均成绩(形参数组长度可变)..2109score562312….….88array#include<stdio.h>/*8-13.c*/voidmain(){floataverage(floatarray[10],intn);floatarray[10],aver;inti;printf("Input10scores:\n");for(i=0;i<10;i++) scanf("%f",&array[i]);aver=average(array,10);printf("Averageis:%.2f",aver);}#include<stdio.h>/*8-13.c*/voidmain(){floataverage(floatarray[],intn);floatarray_1[6],aver_1;floatarray_2[5],aver_2;inti;printf("Input6scores:\n");for(i=0;i<6;i++) scanf("%f",&array_1[i]);aver_1=average(array,6);printf("Input5scores:\n");for(i=0;i<5;i++) scanf("%f",&array_2[i]);aver_2=average(array,5);printf("Averageofarray1is:%.2f",aver_1);printf("Averageofarray2is:%.2f",aver_2);}floataverage(floatarray[],intn){inti;floataver,sum=0;for(i=0;i<n;i++)sum+=array[i];aver=sum/n;returnaver;}例数组元素与数组名作函数参数比较12a调用前a[0]a[1]12a调用a[0]a[1]12xy21xy交换12a返回#include<stdio.h>voidswap2(intx,inty){intz;z=x;x=y;y=z;}voidmain(){inta[2]={1,2};

swap2(a[0],a[1]);printf("a[0]=%d\na[1]=%d\n",a[0],a[1]);}值传递12a调用前12ax调用21ax交换21a返回#include<stdio.h>voidswap2(intx[]){intz;z=x[0];x[0]=x[1];x[1]=z;}voidmain(){inta[2]={1,2};

swap2(a);printf("a[0]=%d\na[1]=%d\n",a[0],a[1]);}地址传递例数组元素与数组名作函数参数比较【例7.12】用选择法对数组中10个整数按由大到小排序排序过程：（1）首先通过n-1次比较，从n个数中找出最小的，将它与第一个数交换—第一趟选择排序，结果最小的数被安置在第一个元素位置上（2）再通过n-2次比较，从剩余的n-1个数中找出关键字次小的记录，将它与第二个数交换—第二趟选择排序（3）重复上述过程，共经过n-1趟排序后，排序结束例初始：[49386597761327]kji=11349一趟：13[386597764927]i=22738二趟：1327[6597764938]三趟：132738[97764965]四趟：13273849[769765]五趟：1327384965[9776]六趟：132738496576[97]kkkkjjjjjjjjjj/*7-5.c*/#include<stdio.h>voidmain(){inta[10],i,j,k,x;printf("Input10numbers:\n");

for(i=0;i<10;i++)scanf("%d",&a[i]);printf("\n");

for(i=0;i<9;i++)

{k=i;

for(j=i+1;j<10;j++)

if(a[j]<a[k])k=j;

if(i!=k){x=a[i];a[i]=a[k];a[k]=x;}

}printf("Thesortednumbers:\n");

for(i=0;i<10;i++) printf("%d",a[i]);}例数组排序----简单选择排序voidsort(intarray[],intn){inti,j,k,t;for(i=0;i<n-1;i++){k=i; for(j=i+1;j<n;j++) if(array[j]<array[k])k=j; if(k!=i) {t=array[i]; array[i]=array[k]; array[k]=t; }}}voidmain(){inta[10],i;for(i=0;i<10;i++) scanf("%d",&a[i]);

sort(a,10);for(i=0;i<10;i++)printf("%d",a[i]);printf("\n");}0123456789a4968573299927137688arraykjjjkjkjjjjj949i=0例数组排序----简单选择排序voidsort(intarray[],intn){inti,j,k,t;for(i=0;i<n-1;i++){k=i; for(j=i+1;j<n;j++) if(array[j]<array[k])k=j; if(k!=i) {t=array[i]; array[i]=array[k]; array[k]=t; }}}voidmain(){inta[10],i;for(i=0;i<10;i++) scanf("%d",&a[i]);

sort(a,10);for(i=0;i<10;i++)printf("%d",a[i]);printf("\n");}kjjkjkjjjjj0123456789a4968573299927137688array949kk1368i=10123456789a9132732495768768899arrayi=8例数组排序----简单选择排序voidsort(intarray[],intn){inti,j,k,t;for(i=0;i<n-1;i++){k=i; for(j=i+1;j<n;j++) if(array[j]<array[k])k=j; if(k!=i) {t=array[i]; array[i]=array[k]; array[k]=t; }}}voidmain(){inta[10],i;for(i=0;i<10;i++) scanf("%d",&a[i]);

sort(a,10);for(i=0;i<10;i++)printf("%d",a[i]);printf("\n");}【例7.13】有一个3*4的矩阵,求所有元素中的最大值1357246815173412ijmax=11357246815173412ijmax=31357246815173412ijmax=5j1357246815173412imax=7j1357246815173412imax=7j1357246815173412imax=34intmax_value(intarray[3][4]){inti,j,k,max;max=array[0][0];for(i=0;i<3;i++)for(j=0;j<4;j++) if(array[i][j]>max) max=array[i][j];return(max);}voidmain(){inta[3][4]={{1,3,5,7}, {2,4,6,8},{15,17,34,12}};printf("maxvalueis%d\n",max_value(a));}多维形参数组第一维维数可省略,第二维必须相同

intarray[][4]7.7.3多维数组名作函数参数例求二维数组中各行元素之和get_sum_row(intx[][3],intresult[],introw,intcol){inti,j;for(i=0;i<row;i++){result[i]=0; for(j=0;j<col;j++) result[i]+=x[i][j];}}voidmain(){inta[2][3]={3,6,9,1,4,7};intsum_row[2],row=2,col=3,i;

get_sum_row(a,sum_row,row,col);for(i=0;i<row;i++)printf("Thesumofrow[%d]=%d\n",i+1,sum_row[i]);}314679asum_rowxresult18127.8

局部变量和全局变量 从变量的作用域（空间）角度来分，变量可以分为全局变量和局部变量7.8.1局部变量---内部变量定义：在函数内定义，只在本函数内有效说明：main中定义的变量只在main中有效不同函数中同名变量，占不同内存单元形参属于局部变量可定义在复合语句中有效的变量floatf1(inta){intb,c;…….}charf2(intx,inty){inti,j;……}main(){intm,n;…….}a,b,c有效x,y,i,j有效m,n有效例不同函数中同名变量voidmain(){inta,b;a=3;b=4;printf("main:a=%d,b=%d\n",a,b);sub();printf("main:a=%d,b=%d\n",a,b);}sub(){inta,b;a=6;b=7;printf("sub:a=%d,b=%d\n",a,b);}例复合语句中变量#defineN5main(){inti;inta[N]={1,2,3,4,5};for(i=0;i<N/2;i++)

{

inttemp; temp=a[i]; a[i]=a[N-i-1]; a[N-i-1]=temp;

}for(i=0;i<N;i++)printf("%d",a[i]);}运行结果：54321例复合语句中变量#defineN5/*8-15.c*/main(){inti;inta[N]={1,2,3,4,5};for(i=0;i<N/2;i++)

{

inttemp; temp=a[i]; a[i]=a[N-i-1]; a[N-i-1]=temp;

}for(i=0;i<N;i++)printf("%d",a[i]);}例不同函数中同名变量voidmain()/*8-16.c*/{inta,b;a=3;b=4;printf("main:a=%d,b=%d\n",a,b);sub();printf("main:a=%d,b=%d\n",a,b);}sub(){inta,b;a=6;b=7;printf("sub:a=%d,b=%d\n",a,b);}运行结果：main:a=3,b=4sub:a=6,b=7main:a=3,b=47.8.2全局变量---外部变量定义： 在函数外定义，可为本文件所有函数共用有效范围： 从定义变量的位置开始到本源文件结束intp=1,q=5;floatf1(inta){intb,c;…….}intf3(){…..}charc1,c2;charf2(intx,inty){inti,j;……}main(){intm,n;…….}c1,c2的作用范围p,q的作用范围

应尽量少使用全局变量，因为：全局变量在程序全部执行过程中占用存储单元降低了函数的通用性、可靠性，可移植性降低程序清晰性，容易出错说明：设置全局变量的作用是增加函数间数据联系的渠道。若外部变量与局部变量同名，则在局部变量的作用范围内，外部变量被屏蔽,不起作用。floatmax,min;floataverage(floatarray[],intn){inti;floatsum=array[0];max=min=array[0];for(i=1;i<n;i++){if(array[i]>max)max=array[i];elseif(array[i]<min)min=array[i];sum+=array[i];}return(sum/n);}main(){inti;floatave,score[10];/*Input*/ave=average(score,10);printf("max=%6.2f\nmin=%6.2f\naverage=%6.2f\n",max,min,ave);}作用域maxmin/*8-17.c*/inta=3,b=5;max(inta,intb){intc;c=a>b?a:b;return(c);}main(){inta=8;printf("max=%d",max(a,b));}运行结果：max=8/*8-18.c*/inti;main(){voidprt();for(i=0;i<5;i++)prt();}voidprt(){for(i=0;i<5;i++)printf(“%c”,’*’);printf(“\n”);}例外部变量副作用运行结果：*****练习#include<stdio.h>intx=5,y=6;voidfun1(){ intx=3,y=4; printf("%d,%d\n",x,y);}voidfun2(intx,inty){ printf("%d,%d\n",x,y);}intmain(){ fun1(); fun2(1,2); printf("%d,%d\n",x,y); return0;}分析运行结果3，41，25，67.9

变量的存储方式和生存期（5.13,14）7.9.1动态存储方式与静态存储方式（从变量值存在的时间角度来分）存储方式静态存储：程序运行期间分配固定存储空间动态存储：程序运行期间根据需要动态分配存储空间内存用户区生存期（变量存在的时间）静态变量:从程序开始执行到程序结束动态变量:从包含该变量定义的函数开始执行至函数执行结束程序区静态存储区动态存储区全局变量、局部静态变量形参变量局部动态变量（autoregister)函数调用现场保护和返回地址等数据类型存储类别：数据在内存中存储的方式（静态和动态），具体包括4种：auto--自动型；register--寄存器型static--静态型；extern---外部型根据变量的存储类别，可以知道变量的作用域和生存期。生存期：变量在某一时刻存在-------静态变量与动态变量作用域：变量在某区域内有效-------局部变量与全局变量每一个变量和函数都有两个属性：数据类型和数据的存储类别如:intsum;

autointa,b,c;

registerinti;

staticfloatx,y;7.9.2局部变量的存储类别1、自动变量（auto变量）在调用函数时系统会给变量分配存储空间，在函数调用结束时自动释放这些存储空间，这类局部变量称为自动变量自动变量用关键字auto作存储类别的声明。关键字“auto”可以省略，auto不写则隐含确定为“自动存储类别”，它属于动态存储方式。程序中大多数变量属于自动变量。之前函数中定义变量都没有声明为auto，则都隐含指定为自动变量。intf(inta){autointb,c=3;…..}/*定义f函数，a为形参*//*定义b，c为自动变量*/autointb,c=3; intb,c=3;

例auto变量的作用域main()/*8-19.c*/{voidprt(void);

intx=1;printf(“\n”);

{

intx=3;prt();printf(“2ndx=%d\n”,x);

}printf(“1stx=%d\n”,x);}voidprt(void){intx=5;printf(“3thx=%d\n”,x);}运行结果：3thx=52ndx=31stx=1x=1作用域x=1作用域x=3作用域x=5作用域２、静态局部变量（static局部变量）静态局部变量：函数中的局部变量的值在函数调用结束后不消失而保留原值，即其占用的存储单元不释放，在下一次该函数调用时，该变量已有值，就是上一次函数调用结束时的值。静态局部变量用static进行声明。#include<stdio.h>voidmain()/*8-20.c*/{intf(inta);inta=2,i;for(i=0;i<3;i++)printf(“%d”,f(a));}intf(inta){autointb=0;staticintc=3;b=b+1;c=c+1;return(a+b+c);}运行结果：789#include<stdio.h>voidmain()/*8-20.c*/{intf(inta);inta=2,i;for(i=0;i<3;i++)printf(“%d”,f(a));}intf(inta){autointb=0;staticintc=3;b=b+1;c=c+1;return(a+b+c);}说明：静态局部变量属于静态存储类别，在静态存储区内分配存储单元。在程序整个运行期间都不释放。自动变量属于动态存储类别，占动态存储区空间，函数调用结束后即释放。对静态局部变量是在编译时赋初值的，即只赋初值一次，以后每次调用时都不再重新赋初值，而只是保留上次函数调用结束时的值。对自动变量赋初值，是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句若在定义局部变量时不赋初值，则对静态局部变量来说，编译时自动赋初值0（整型变量）。而对自动变量来说，如果不赋初值则它的值是不确定的值静态局部变量在函数调用结束后仍然存在，但其它函数不能引用它#include<stdio.h>/*8-21.c*/voidmain(){intfac(intn);inti;for(i=1;i<=5;i++) printf(“%d!=%d\n”,i,fac(i));}intfac(intn){staticintf=1;f=f*n;return(f);}例输出1到5的阶乘值运行结果：1!=12!=23!=64!=245!=120main(){voidincrement(void);increment();increment();increment();}voidincrement(void){intx=0;x++;printf(“%d\n”,x);}例局部静态变量值具有可继承性运行结果：111main(){voidincrement(void);increment();increment();increment();}voidincrement(void){staticintx=0;x++;printf(“%d\n”,x);}运行结果：123３、寄存器变量（register变量）寄存器变量：将局部变量的值放在CPU中的寄存器中，需要用时直接从寄存器取出参加运算，不必再到内存中去存取。寄存器变量用关键字register作声明。只有局部自动变量和形式参数可以作为寄存器变量，其他不行。计算机系统中的寄存器数目有限，不能定义任意多个寄存器变量静态局部变量不能定义为寄存器变量运算器内存存数取数#include<stdio.h>voidmain(){longfac(long);longi,n;scanf(“%ld”,&n);for(i=1;i<=n;i++) printf(“%ld!=%ld\n”,i,fac(i));}longfac(longn){registerlongi,f=1;/*定义寄存器变量*/for(i=1;i<=n;i++) f=f*n;return(f);}使用寄存器变量如:register

staticinta,b,c;例变量的寿命与可见性#include<stdio.h>inti=1;main(){staticinta;

registerintb=-10;

intc=0;printf("-----MAIN------\n");printf("i:%da:%d\b:%dc:%d\n",i,a,b,c);c=c+8;other();printf("-----MAIN------\n");printf("i:%da:%d\b:%dc:%d\n",i,a,b,c);i=i+10;

other();}other(){staticinta=2;staticintb;

intc=10;a=a+2;i=i+32;c=c+5;printf("-----OTHER------\n");printf("i:%da:%d\b:%dc:%d\n",i,a,b,c);b=a;}-------Main------i:1a:0b:-10c:0------Other------i:33a:4b:0c:15-------Main-----i:33a:0b:-10c:8-------Other-------i:75a:6b:4c:15全局i1main:a0b:-10registermain:c0静态存储区动态存储区other:a2other:b0other:c10843315443other:c106751567.9.3全局变量的存储类别用extern来声明外部变量，以扩展外部变量的作用域在一个文件内声明外部变量在多文件的程序中声明外部变量用extern声明外部变量，扩展外部变量在程序文件中的作用域1、在一个文件内扩展外部变量的作用域【例7.18】调用函数,求3个整数中的大者#include<stdio.h>intmain(){ intmax(); externintA,B,C; printf(“Pleaseenterthreeintegernumbers:”); scanf(“%d%d%d”,&A,&B,&C); printf(“maxis%d\n”,max()); return0;}intA,B,C;intmax();{ intm; m=A>B?A:B; if(C>m)m=C; return(m);}运行结果：Pleaseenterthreeintegernumbers:346712maxis67externA,B,C;main(){voidgx(),gy();

externintx,y;printf(“1:x=%d\ty=%d\n”,x,y);y=246;gx();gy();}voidgx(){externintx,y;x=135;printf(“2:x=%d\ty=%d\n”,x,y);}intx,y;voidgy(){printf(“3:x=%d\ty=%d\n”,x,y);}例用extern扩展外部变量作用域运行结果：1:x=0y=02:x=135y=2463:x=135y=246注意：建议将外部变量的定义放在引用它的所有函数之前，避免在函数中多加一个extern声明【例7.19】给定b的值，输入A和m，求Ab和A的m次方intA;intmain(){intpower(intn);intb=3,c,d,m;printf("Enterthenumberaanditspower:\n");scanf("%d,%d",&A,&m);c=A*b;printf("%d*%d=%d\n",A,b,c);d=power(m);printf("%d**%d=%d",A,m,d);return0;}externintA;intpower(intn){inti,y=1;for(i=1;i<=n;i++) y*=A;return(y);}file1.cfile2.c2、将外部变量的作用域扩展到其他文件一个C程序可以由多个源程序文件组成，当一个文件中要引用另一个文件中已定义变量时，用exter