【文档说明】黄逸民-c语言程序设计-chapt[6]-课件.ppt，共(65)页，486.512 KB，由小橙橙上传

转载请保留链接：https://www.ichengzhen.cn/view-44671.html

以下为本文档部分文字说明：

第六章函数§6.1概述模块化程序设计❖基本思想：将一个大的程序按功能分割成一些小模块,❖特点：⚫各模块相对独立、功能单一、结构清晰、接口简单⚫控制了程序设计的复杂性⚫提高元件的可靠性⚫缩短开发周期⚫避免程序开发

的重复劳动⚫易于维护和功能扩充❖开发方法:自上向下,逐步分解，分而治之C是模块化程序设计语言源程序文件1预编译命令说明部分执行部分函数1函数n源程序文件i源程序文件nC程序C程序结构C是函数式语言必须有且只能有一个名为main的主函数C程序的

执行总是从main函数开始，在main中结束函数不能嵌套定义,可以嵌套调用函数分类❖从用户角度⚫标准函数（库函数）：由系统提供⚫用户自定义函数❖从函数形式⚫无参函数⚫有参函数使用库函数应注意：1、函数功能2、函数参数的数目和顺序，及各参数意义和类型3、函数返回值意义和类型4、

需要使用的包含文件Ch7_201.c§6.2函数的定义一般格式合法标识符函数返回值类型缺省int型无返回值void函数体函数类型函数名（形参类型说明表）{说明部分语句部分}现代风格:例有参函数（现代风格）intmax(intx,inty){intz;z=x>y?x:y;ret

urn(z);}例有参函数（现代风格）intmax(intx,y){intz;z=x>y?x:y;return(z);}例空函数dummy(){}函数体为空例无参函数printstar(){printf(“*******

***\n”);}或printstar(void){printf(“**********\n”);}函数类型函数名（形参表）形参类型说明{说明部分语句部分}传统风格:例有参函数（传统风格）intmax(x,y)in

tx,y;{intz;z=x>y?x:y;return(z);}§6.3函数的返回值返回语句❖形式：return(表达式)；或return表达式;或return;❖功能：使程序控制从被调用函数返回到调用函数中，同时把返值带给调用函数❖说明：⚫函数

中可有多个return语句⚫若无return语句，遇}时，自动返回调用函数⚫若函数类型与return语句中表达式值的类型不一致，按前者为准，自动转换------函数调用转换⚫void型函数例无返回值函数voidswap(intx,

inty){inttemp;temp=x;x=y;y=temp;}printstar(){printf("**********");}main(){inta;a=printstar();printf("%d",a);}例函数带回不确定值输出：10voidprintstar()

{printf("**********");}main(){inta;a=printstar();printf("%d",a);}编译错误！例函数返回值类型转换main(){floata,b;intc;scanf("%f,%f",&a,&b);c=max(a,b);p

rintf("Maxis%d\n",c);}max(floatx,floaty){floatz;z=x>y?x:y;return(z);}§6.4函数的调用调用形式函数名(实参表);说明：⚫实参与形参个数相等，类型一致，按顺序一一对应⚫实参表求值顺序，因系统而定（TurboC自右向左）main(

){inti=2,p,k;k=++i;p=f(i,k);printf("%d",p);}intf(inta,intb){intc;if(a>b)c=1;elseif(a==b)c=0;elsec=-1;return(c);}例参数求值顺序main(){inti=2

,p,k;k=i++;p=f(i,k);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));程序举例、求

500以内的全部素数，并以每行10个进行输出，其中判断素数要求用函数实现。程序：#include<math.h>intprime(intx){inti,r=1;for(i=2;i<=sqrt(x);i++)if(x%i==0

){r=0;break;}returnr;}voidprt(intx,intn){printf(“%6d”,x);/*素数输出*/if(n%10==0)printf(“\n”);/*保证输出素数时每行10个*/}判断素数函数采用定义方式main(){intm,i,n

=0;for(m=2;m<=500,m++)if(prime(m))/*函数调用的结果是判断m是否为素数*/{n++;prt(m,n);/*调用输出函数*/}}函数说明❖对被调用函数要求：⚫必须是已存在的函数⚫库函数:#include<*.h>⚫用户自定义函数:函数类型说

明❖函数说明⚫一般形式：函数类型函数名(形参类型[形参名],…..);或函数类型函数名();⚫作用：告诉编译系统函数类型、参数个数及类型，以便检验⚫函数定义与函数说明不同⚫函数说明位置：程序的数据说明部分（函数内

或外）⚫下列情况下，可不作函数说明◆若函数返值是char或int型，系统自动按int型处理◆被调用函数定义出现在主调函数之前⚫有些系统(如BorlandC++)要求函数说明指出函数返值类型和形参类型，并且对void和int型函数也要进行函数说明例函数说明举例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;retu

rn(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);}被调函数出现在主调函数之前，不必函数说明/*ch7_5.c*/main(){floatadd(float,float);/*func

tiondeclaration*/floata,b,c;scanf("%f,%f",&a,&b);c=add(a,b);printf("sumis%f",c);}floatadd(floatx,floaty){floatz;z=x+y

;return(z);}floatadd();§6.5函数参数及其传递方式形参与实参❖形式参数：定义函数时函数名后面括号中的变量名❖实际参数：调用函数时函数名后面括号中的表达式c=max(a,b);（main

函数）（max函数）max(intx,inty){intz;z=x>y?x:y;return(z);}例比较两个数并输出大者main(){inta,b,c;scanf("%d,%d",&a,&b);c=max(a,b);printf("Maxis%d",c);}max(intx,in

ty){intz;z=x>y?x:y;return(z);}形参实参❖说明：⚫实参必须有确定的值⚫形参必须指定类型⚫形参与实参类型一致，个数相同⚫若形参与实参类型不一致，自动按形参类型转换———函数调用转换⚫形参

在函数被调用前不占内存;函数调用时为形参分配内存；调用结束，内存释放§6.5函数参数及其传递方式形参与实参❖形式参数：定义函数时函数名后面括号中的变量名❖实际参数：调用函数时函数名后面括号中的表达式例计算x的立方#include

<stdio.h>floatcube(floatx){return(x*x*x);}main(){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:例交换两个数/*ch7_2.c*/#include<stdio.h>main(){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);}Voidswap(inta,intb){intte

mp;temp=a;a=b;b=temp;}调用：711a:b:711x:y:swap:711x:y:117a:b:temp❖地址传递⚫方式：函数调用时，将数据的存储地址作为参数传递给形参⚫特点：◆形参与实参占用同样的存储单元◆“双向”传递◆实参和形参必须是地址常量或变量/*ch9_3

.c*/swap(p1,p2)int*p1,*p2;{intp;p=*p1;*p1=*p2;*p2=p;}main(){inta,b;scanf("%d,%d",&a,&b);printf(“a=%d,b=%d\n”,a,

b);printf(“swapped:\n”);swap(&a,&b);printf(”a=%d,b=%d\n",a,b);}例交换两个数a59b调前：a59b调swap：p1&a&bp2a95b交换：p1&a&bp2a95b返回：#include<stdio.h>lon

gsum(inta,intb);longfactorial(intn);main(){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);}l

ongsum(inta,intb);longfactorial(intn);文件包含编译预处理命令函数类型说明函数定义函数调用函数调用函数返回值形参实参§6.6函数的嵌套与递归调用嵌套调用C规定：函数定义不可嵌套，但可以嵌套调用函数main()调用

函数a结束a函数b函数调用函数b例求三个数中最大数和最小数的差值#include<stdio.h>intdif(intx,inty,intz);intmax(intx,inty,intz);intmin(intx,int

y,intz);voidmain(){inta,b,c,d;scanf("%d%d%d",&a,&b,&c);d=dif(a,b,c);printf("Max-Min=%d\n",d);}Ch7_202.cintdif(intx,inty,intz){re

turnmax(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函数例用弦截法求方程根08016523=−+−xxxxyf(x)0x1x2xf(x1)f(x2))()()()(121221xfxfxfxxfxx−−=求f(x1)与f(x2)连线与x轴的交点x输入x1,x2,求f(x1

),f(x2)直到f(x1)与f(x2)异号y=f(x),y1=f(x1)y与y1同号真假x1=xy1=yx2=x直到|y|<root=x输出rootroot函数运行情况：Inputx1,x2:2,6

Arootofequationis5.0000main()调用函数root输出根x结束root函数xpoint函数调用函数xpoint调用函数ff函数递归调用❖定义：函数直接或间接的调用自身叫函数的递归调用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);}例求n的阶乘−==)1()!1()1,0(1!nnnnn/*ch7_8.c*/#include<stdio.h>intfac(in

tn){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("Inputaintegernu

mber:");scanf("%d",&n);y=fac(n);printf("%d!=%15d",n,y);}例Hanoi问题voidmove(chargetone,charputone){printf("%c--->%c\n",getone,putone);}voidhano

i(intn,charone,chartwo,charthree){if(n==1)move(one,three);else{hanoi(n-1,one,three,two);move(one,three);h

anoi(n-1,two,one,three);}}main(){intm;printf("Inputthenumberofdisks:");scanf("%d",&m);printf("Thestepstomoving%3ddisks:\n",m);hanoi(m,'

A','B','C');}D:\fengyi\bkc\power\power.cABC§6.7数组作为函数参数数组元素作函数实参——值传递例两个数组大小比较432105a562312107688432105b2123439866

54n=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>main(){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;els

eif(x<y)flag=-1;elseflag=0;return(flag);}数组名作函数参数❖地址传递❖在主调函数与被调函数分别定义数组,且类型应一致❖形参数组大小(多维数组第一维)可不指定❖形参数组名是地址变量例求学生的平均

成绩#include<stdio.h>floataverage(intstu[10],intn);voidmain(){intscore[10],i;floatav;printf("Input10scores：\n"

);for(i=0;i<10;i++)scanf("%d",&score[i]);av=average(score,10);printf("Averageis：%.2f",av);}floataverage(intstu[

10],intn){inti;floatav,total=0;for(i=0;i<n;i++)total+=stu[i];av=total/n;returnav;}实参用数组名形参用数组定义,intstu[]..2109score562312….….8

8stu例数组元素与数组名作函数参数比较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;}main(){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>voi

dswap2(intx[]){intz;z=x[0];x[0]=x[1];x[1]=z;}main(){inta[2]={1,2};swap2(a);printf("a[0]=%d\na[1]=%d\n",a[0],a[1]);}地

址传递例数组元素与数组名作函数参数比较例数组排序----简单选择排序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;}}}main(){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]=arra

y[k];array[k]=t;}}}main(){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");}kjjkjkjjjjj0123

456789a4968573299927137688array949kk1368i=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;}}}main(){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");}例求

二维数组中最大元素值1357246815173412ijmax=11357246815173412ijmax=31357246815173412ijmax=5j1357246815173412imax=7j1357246815173412imax=7

j1357246815173412imax=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);}main(){inta[3][4]={{1,3,5,7},{2,4,6,8},{15,17,34,12}};printf("maxvalueis%d\n",max_value(a))

;}多维形参数组第一维维数可省略,第二维必须相同intarray[][4]例求二维数组中各行元素之和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];}}main(){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_rowxresult1812§6.8变量的存储属性概述❖变量是对程序中数据的存储空间的抽象内存……

.main(){inta;a=10;printf(“%d”,a);}1020002001程序中使用变量名对内存操作❖变量的属性⚫数据类型：变量所持有的数据的性质（操作属性）⚫存储属性◆存储器类型：寄存器、静态存储

区、动态存储区◆生存期：变量在某一时刻存在-------静态变量与动态变量◆作用域：变量在某区域内有效-------局部变量与全局变量❖变量的存储类型⚫auto-----自动型⚫register-----寄存器型⚫static------静态型⚫extern---

--外部型❖变量定义格式:[存储类型]数据类型变量表;§6.8变量的存储属性概述❖变量是对程序中数据的存储空间的抽象如:intsum;autointa,b,c;registerinti;staticfloatx,y;局部变量与全局变量❖局部变量---内部变

量⚫定义：在函数内定义，只在本函数内有效⚫说明：◆main中定义的变量只在main中有效◆不同函数中同名变量，占不同内存单元◆形参属于局部变量◆可定义在复合语句中有效的变量◆局部变量可用存储类型：autoregi

sterstatic（默认为auto）floatf1(inta){intb,c;…….}charf2(intx,inty){inti,j;……}main(){intm,n;…….}a,b,c有效x,y,i,j有效m,n有效例不同函数中同名变量main(){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例复合语句中变量#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]);}例不同函数中同名变量main(){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=4❖全局变量---外部变量⚫定义：在函数外定义，可为本文件所有函数共用⚫有效范围：从定义

变量的位置开始到本源文件结束，及有extern说明的其它源文件应尽量少使用全局变量，因为：全局变量在程序全部执行过程中占用存储单元降低了函数的通用性、可靠性，可移植性降低程序清晰性，容易出错定义说明◆次数：只能1次可说明多次◆位置：所有函数之外函数内或函数外◆分配内存

：分配内存,可初始化不分配内存,不可初始化>>>>>>>>>>>>⚫外部变量说明：extern数据类型变量表；⚫外部变量定义与外部变量说明不同⚫若外部变量与局部变量同名，则外部变量被屏蔽⚫外部变量可用存储类型：缺省或staticfloatmax,min;floa

taverage(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=ar

ray[i];sum+=array[i];}return(sum/n);}main(){inti;floatave,score[10];/*Input*/ave=average(score,10);printf("max=%6.2f\nm

in=%6.2f\naverage=%6.2f\n",max,min,ave);}作用域maxminintp=1,q=5;floatf1(inta){intb,c;…….}intf3(){…..}charc1,c2;charf2(

intx,inty){inti,j;……}main(){intm,n;…….}c1,c2的作用范围p,q的作用范围externcharc1,c2;externcharc1,c2;c1,c2的作用范围扩展后c1,c2的作用范围扩展后例外部变量定义与说明intmax(intx,inty)

{intz;z=x>y?x:y;return(z);}main(){externinta,b;printf("max=%d",max(a,b));}inta=13,b=-8;运行结果：max=13externinta,b;intmax(){in

tz;z=a>b?a:b;return(z);}main(){printf("max=%d",max());}inta=13,b=-8;/*ch7_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=8inti;main(){voidprt();for(i=0;i<5;i++)prt();}voidp

rt(){for(i=0;i<5;i++)printf(“%c”,’*’);printf(“\n”);}例外部变量副作用运行结果：*****动态变量与静态变量❖存储方式⚫静态存储：程序运行期间分配固定存储空间⚫动态存储：程序运行期间根据需要动态分配存储空间❖内存用户区程序区静态存储区动态存储

区全局变量、局部静态变量形参变量局部动态变量（autoregister)函数调用现场保护和返回地址等❖生存期⚫静态变量:从程序开始执行到程序结束⚫动态变量:从包含该变量定义的函数开始执行至函数执行结束变量存储类型静态动态存储方式程序整

个运行期间函数调用开始至结束生存期编译时赋初值，只赋一次每次函数调用时赋初值自动赋初值0或空字符不确定未赋初值静态存储区动态区存储区寄存器局部变量外部变量作用域定义变量的函数或复合语句内本文件其它文件◆局部变量默认为auto型◆register型变量个数受限,且不能为long,d

ouble,float型◆局部static变量具有全局寿命和局部可见性◆局部static变量具有可继承性◆extern不是变量定义,可扩展外部变量作用域register局部staticauto外部st

atic外部存储类别例文件file1.cinta;main(){…….…….f2;…….f1;…….}f1(){autointb;………f2;……..}f2(){staticintc;………}C作用域b作用域a作用域mainf2f1mainf1f2maina

生存期:b生存期:c生存期:例auto变量的作用域main(){intx=1;voidprt(void);{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作用域main(){voidincrement(void);increment();increment();increment();}voidin

crement(void){intx=0;x++;printf(“%d\n”,x);}例局部静态变量值具有可继承性运行结果：111main(){voidincrement(void);increment(

);increment();increment();}voidincrement(void){staticintx=0;x++;printf(“%d\n”,x);}运行结果：123例变量的寿命与可见性#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("-----MAI

N------\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:-10register

main:c0静态存储区动态存储区other:a2other:b0other:c10843315443other:c10675156main(){voidgx(),gy();externintx,y;print

f(“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例引用其它文件中的外部变量intglobal;externfloatx;main(){intlocal;...}externintg

lobal;staticintnumber;func2(){...}floatx;staticintnumber;func3(){externintglobal;...}file1.cfile2.cfile3.c例引用其它文件中的变量，输出ab和a的m次方inta;ma

in(){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);}externinta;intpower(intn){inti,y=1;for(i=1;i<=n;i++)y*=a;retu

rn(y);}宏定义1、宏的基本定义宏定义格式：#define宏名宏定义字符串作用：#表示它在编译预处理中起作用，而不是真正的C语句，行尾不加分号。例、#definePI3.1415926#defineTRUE1#defineFALSE0简单应用：#definePI3.1415926m

ain(){floatm,s,r;scanf(“%f”,&r);m=2*PI*r;s=PI*r*r;printf(“Theperimeter=%f,andarea=%f\n”,m,s);}2、宏定义的用途1

）符号常量2）简单的函数功能实现3）为程序书写带来一些方便3、注意1）在程序中用定义的字符串代替，由执行时的表达式意义决定。2）一般宏名字采用大写字母3）宏的作用是有范围的4、宏的作用范围宏定义可以写在程序中任何位置，它的作用范围从定义书写处到文件尾，在范围内可以引用宏名进

行替换。通过“#undef”强制指定宏的结束范围。例、宏的作用范围源程序：#defineA“Thisisthefirstmacro”voidf1(){printf(“A”);printf(“\n”);}#defi

neB“Thisissecondmacro”voidf2(){printf(“B”);}#undefBmain(){f1();f2();}A的有效范围B的有效范围带参数的宏定义1、宏要实现简单的函数功能，参数使用是比不可少的。由于宏常常限制，因此只

能实现简单的函数功能。例、简单的带参宏定义程序#defineMAX(a,b)a>b?a:b;#defineSQR(x)x*xmain(){intx,y;scanf(“%d%d”,&x,&y);x=MAX(x,y);y=SQR(x);printf(“%d%d”,x,y);}

说明：宏引用形式与函数调用相似，但两者的实现过程完全不同。宏代换是在程序的编译预处理时完成的，函数是在程序执行时解释的。例、求带宏定义的程序输出。程序：#defineF(x)x-2#defineD(x)x*F(x)main(){p

ritnf(“%d,%d”,D(x),D(D(3)));}分析：在阅读带宏定义的程序时，一定要坚持替换的原则，先一一替换好后，最后再进行计算，千万不可一边替换一边计算。请看：因为：D(3)=x*F(x)先用x替换展开=x*x-2进一步对F(x)展开，这里没有括号=3*3-2最后把x

=3代进去计算=7所以：D(D(3))=D(7)就是是大错特错了，没有坚持先替换的原则正确的是：D(D(3))=D(x*x-2)先对Ｄ(3)用x替换展开，作为外层Ｄ()的参数=x*x-2*F(x*x-2)拿展开后的参数对D进一步进行宏替换=x*x-2*x*x-

2-2拿展开后的参数对F进一步进行宏替换=3*3-2*3*3-2-2=-13最后把x=3代进去计算运行结果：7-13编译预处理C语言的编译预处理功能主要包括3种1）文件包含（#include）2）宏定义（#define）3）条件编译前2个前面已经介绍了，下面介绍C的条件编译。一般

的程序经过编译后，所有的C语言都能生成到目标程序中，如果只想把源程序中一部分语句生成目标代码，可以使用条件编译。例如、#defineFLAG1#ifFLAG程序段1#else程序段2#endif“#ifFLAG”表示只要FLAG经过宏定义（宏

定义字符串内容任意，也可以没有），程序段1参加编译，如果没有FLAG的宏定义，程序段2参加编译。说明：采用条件编译的好处有两点，一是目标代码精简，不包含无关的代码；二是系统代码保护性好。条件编译的主要形式：#if宏名/常量表达式#if宏名/常量表达式1代码块代码块1#endif#e

lif宏名/常量表达式2代码块2#if宏名/常量表达式#else代码块1代码块3#else#endif代码块2#endif#ifdef宏名代码块1#else代码块2#endif