| 函数嵌套及指针、文件等 函数的嵌套调用
Ｃ语言中不允许作嵌套的函数定义。因此各函数之间是平行的，不存在上一级函数和下一级函数的问题。 但是Ｃ语言允许在一个函数的定义中出现对另一个函数的调用。 这样就出现了函数的嵌套调用。即在被调函数中又调用其它函数。 这与其它语言的子程序嵌套的情形是类似的。其关系可表示如图5.2。
图5.2表示了两层嵌套的情形。其执行过程是：执行main函数中调用a函数的语句时，即转去执行a函数，在a函数中调用b 函数时，又转去执行b函数，b函数执行完毕返回a函数的断点继续执行，a 函数执行完毕返回main函数的断点继续执行。
[例5.8]计算s=22!+32!
本题可编写两个函数，一个是用来计算平方值的函数f1， 另一个是用来计算阶乘值的函数f2。主函数先调f1计算出平方值， 再在f1中以平方值为实参，调用 f2计算其阶乘值，然后返回f1，再返回主函数，在循环程序中计算累加和。
long f1(int p)
{
int k;
long r;
long f2(int);
k=p*p;
r=f2(k);
return r;
}
long f2(int q)
{
long c=1;
int i;
for(i=1;i<=q;i++)
c=c*i;
return c;
}
main()
{
int i;
long s=0;
for (i=2;i<=3;i++)
s=s+f1(i);
printf("\ns=%ld\n",s);
}
long f1(int p)
{
……
long f2(int);
r=f2(k);
……
}
long f2(int q)
{
……
}
main()
{ ……
s=s+f1(i);
……
}
在程序中，函数f1和f2均为长整型，都在主函数之前定义， 故不必再在主函数中对f1和f2加以说明。在主程序中， 执行循环程序依次把i值作为实参调用函数f1求i2值。在f1中又发生对函数f2的调用，这时是把i2的值作为实参去调f2，在f2 中完成求i2! 的计算。f2执行完毕把C值(即i2!)返回给f1，再由f1 返回主函数实现累加。至此，由函数的嵌套调用实现了题目的要求。 由于数值很大， 所以函数和一些变量的类型都说明为长整型，否则会造成计算错误。
函数的递归调用 一个函数在它的函数体内调用它自身称为递归调用。 这种函数称为递归函数。Ｃ语言允许函数的递归调用。在递归调用中， 主调函数又是被调函数。执行递归函数将反复调用其自身。 每调用一次就进入新的一层。例如有函数f如下：
int f (int x)
{
int y;
z=f(y);
return z;
}
这个函数是一个递归函数。 但是运行该函数将无休止地调用其自身，这当然是不正确的。为了防止递归调用无终止地进行， 必须在函数内有终止递归调用的手段。常用的办法是加条件判断， 满足某种条件后就不再作递归调用，然后逐层返回。 下面举例说明递归调用的执行过程。
[例5.9]用递归法计算n!用递归法计算n!可用下述公式表示：
n!=1 (n=0,1)
n×(n-1)! (n>1)
按公式可编程如下：
long ff(int n)
{
long f;
if(n<0) printf("n<0,input error");
else if(n==0||n==1) f=1;
else f=ff(n-1)*n;
return(f);
}
main()
{
int n;
long y;
printf("\ninput a inteager number:\n");
scanf("%d",&n);
y=ff(n);
printf("%d!=%ld",n,y);
}
long ff(int n)
{ ……
else f=ff(n-1)*n;
……
}
main()
{ ……
y=ff(n);
……
}
程序中给出的函数ff是一个递归函数。主函数调用ff 后即进入函数ff执行，如果n<0,n==0或n=1时都将结束函数的执行，否则就递归调用ff函数自身。由于每次递归调用的实参为n-1，即把n-1 的值赋予形参n，最后当n-1的值为1时再作递归调用，形参n的值也为1，将使递归终止。然后可逐层退回。下面我们再举例说明该过程。 设执行本程序时输入为5， 即求 5!。在主函数中的调用语句即为y=ff(5)，进入ff函数后，由于n=5,不等于0或1，故应执行f=ff(n-1)*n,即f=ff(5-1)*5。该语句对ff作递归调用即ff(4)。 逐次递归展开如图5.3所示。进行四次递归调用后，ff函数形参取得的值变为1，故不再继续递归调用而开始逐层返回主调函数。ff(1)的函数返回值为1，ff(2)的返回值为1*2=2，ff(3)的返回值为2*3=6，ff(4) 的返
回值为6*4=24，最后返回值ff(5)为24*5=120。
例5. 9也可以不用递归的方法来完成。如可以用递推法，即从1开始乘以2，再乘以3…直到n。递推法比递归法更容易理解和实现。但是有些问题则只能用递归算法才能实现。典型的问题是Hanoi塔问题。
[例5.10]Hanoi塔问题
一块板上有三根针，A，B，C。A针上套有64个大小不等的圆盘， 大的在下，小的在上。如图5.4所示。要把这64个圆盘从A针移动C针上，每次只能移动一个圆盘，移动可以借助B针进行。但在任何时候，任何针上的圆盘都必须保持大盘在下，小盘在上。求移动的步骤。
本题算法分析如下，设A上有n个盘子。
如果n=1，则将圆盘从A直接移动到C。
如果n=2，则：
1.将A上的n-1(等于1)个圆盘移到B上；
2.再将A上的一个圆盘移到C上；
3.最后将B上的n-1(等于1)个圆盘移到C上。
如果n=3，则：
A. 将A上的n-1(等于2，令其为n`)个圆盘移到B(借助于C)，
步骤如下：
(1)将A上的n`-1(等于1)个圆盘移到C上，见图5.5(b)。
(2)将A上的一个圆盘移到B，见图5.5(c)
(3)将C上的n`-1(等于1)个圆盘移到B，见图5.5(d)
B. 将A上的一个圆盘移到C，见图5.5(e)
C. 将B上的n-1(等于2，令其为n`)个圆盘移到C(借助A)，
步骤如下：
(1)将B上的n`-1(等于1)个圆盘移到A，见图5.5(f)
(2)将B上的一个盘子移到C，见图5.5(g)
(3)将A上的n`-1(等于1)个圆盘移到C，见图5.5(h)。
到此，完成了三个圆盘的移动过程。
从上面分析可以看出，当n大于等于2时， 移动的过程可分解为
三个步骤：
第一步 把A上的n-1个圆盘移到B上；
第二步 把A上的一个圆盘移到C上；
第三步 把B上的n-1个圆盘移到C上；其中第一步和第三步是类同的。
当n=3时，第一步和第三步又分解为类同的三步，即把n`-1个圆盘从一个针移到另一个针上，这里的n`=n-1。 显然这是一个递归过
程，据此算法可编程如下： move(int n,int x,int y,int z)
{
if(n==1)
printf("%c-->%c\n",x,z);
else
{
move(n-1,x,z,y);
printf("%c-->%c\n",x,z);
move(n-1,y,x,z);
}
}
main()
{
int h;
printf("\ninput number:\n");
scanf("%d",&h);
printf("the step to moving %2d diskes:\n",h);
move(h,'a','b','c');
}
move(int n,int x,int y,int z)
{
if(n==1)
printf("%-->%c\n",x,z);
else
{
move(n-1,x,z,y);
printf("%c-->%c\n",x,z);
move(n-1,y,x,z);
}
}
main()
{ ……
move(h,'a','b','c');
}
从程序中可以看出,move函数是一个递归函数，它有四个形参n,x,y,z。n表示圆盘数，x,y,z分别表示三根针。move 函数的功能是把x上的n个圆盘移动到z 上。当n==1时，直接把x上的圆盘移至z上，输出x→z。如n!=1则分为三步：递归调用move函数，把n-1个圆盘从x移到y；输出x→z；递归调用move函数，把n-1个圆盘从y移到z。在递归调用过程中n=n-1，故n的值逐次递减，最后n=1时，终止递归，逐层返回。当n=4 时程序运行的结果为
input number:
4
the step to moving 4 diskes:
a→b
a→c
b→c
a→b
c→a
c→b
a→b
a→c
b→c
b→a
c→a
b→c
a→b
a→c
b→c
变量的作用域
在讨论函数的形参变量时曾经提到， 形参变量只在被调用期间才分配内存单元，调用结束立即释放。 这一点表明形参变量只有在函数内才是有效的， 离开该函数就不能再使用了。这种变量有效性的范围称变量的作用域。不仅对于形参变量， Ｃ语言中所有的量都有自己的作用域。变量说明的方式不同，其作用域也不同。 Ｃ语言中的变量，按作用域范围可分为两种， 即局部变量和全局变量。
一、局部变量 局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内， 离开该函数后再使用这种变量是非法的。
例如：
int f1(int a) /*函数f1*/
{
int b,c;
……
}a,b,c作用域
int f2(int x) /*函数f2*/
{
int y,z;
}x,y,z作用域
main()
{
int m,n;
}
m,n作用域 在函数f1内定义了三个变量，a为形参，b,c为一般变量。在 f1的范围内a,b,c有效，或者说a,b,c变量的作用域限于f1内。同理，x,y,z的作用域限于f2内。 m,n的作用域限于main函数内。关于局部变量的作用域还要说明以下几点：
1. 主函数中定义的变量也只能在主函数中使用，不能在其它函数中使用。同时，主函数中也不能使用其它函数中定义的变量。因为主函数也是一个函数，它与其它函数是平行关系。这一点是与其它语言不同的，应予以注意。
2. 形参变量是属于被调函数的局部变量，实参变量是属于主调函数的局部变量。
3. 允许在不同的函数中使用相同的变量名，它们代表不同的对象，分配不同的单元，互不干扰，也不会发生混淆。如在例5.3 中，形参和实参的变量名都为n，是完全允许的。4. 在复合语句中也可定义变量，其作用域只在复合语句范围内。例如：
main()
{
int s,a;
……
{
int b;
s=a+b;
……b作用域
}
……s,a作用域
}[例5.11]main()
{
int i=2,j=3,k;
k=i+j;
{
int k=8;
if(i==3) printf("%d\n",k);
}
printf("%d\n%d\n",i,k);
}
main()
{
int i=2,j=3,k;
k=i+j;
{
int k=8;
if(i=3) printf("%d\n",k);
}
printf("%d\n%d\n",i,k);
}
本程序在main中定义了i,j,k三个变量，其中k未赋初值。 而在复合语句内又定义了一个变量k，并赋初值为8。应该注意这两个k不是同一个变量。在复合语句外由main定义的k起作用，而在复合语句内则由在复合语句内定义的k起作用。因此程序第4行的k为main所定义，其值应为5。第7行输出k值，该行在复合语句内，由复合语句内定义的k起作用，其初值为8，故输出值为8，第9行输出i，k值。i是在整个程序中有效的，第7行对i赋值为3，故以输出也为3。而第9行已在复合语句之外，输出的k应为main所定义的k，此k值由第4 行已获得为5，故输出也为5。
二、全局变量
全局变量也称为外部变量，它是在函数外部定义的变量。 它不属于哪一个函数，它属于一个源程序文件。其作用域是整个源程序。在函数中使用全局变量，一般应作全局变量说明。 只有在函数内经过说明的全局变量才能使用。全局变量的说明符为extern。 但在一个函数之前定义的全局变量，在该函数内使用可不再加以说明。 例如：
int a,b; /*外部变量*/
void f1() /*函数f1*/
{
……
}
float x,y; /*外部变量*/
int fz() /*函数fz*/
{
……
}
main() /*主函数*/
{
……
}/*全局变量x,y作用域 全局变量a,b作用域*/
从上例可以看出a、b、x、y 都是在函数外部定义的外部变量，都是全局变量。但x,y 定义在函数f1之后，而在f1内又无对x,y的说明，所以它们在f1内无效。 a,b定义在源程序最前面，因此在f1,f2及main内不加说明也可使用。
[例5.12]输入正方体的长宽高l,w,h。求体积及三个面x*y,x*z,y*z的面积。
int s1,s2,s3;
int vs( int a,int b,int c)
{
int v;
v=a*b*c;
s1=a*b;
s2=b*c;
s3=a*c;
return v;
}
main()
{
int v,l,w,h;
printf("\ninput length,width and height\n");
scanf("%d%d%d",&l,&w,&h);
v=vs(l,w,h);
printf("v=%d s1=%d s2=%d s3=%d\n",v,s1,s2,s3);
}
本程序中定义了三个外部变量s1,s2,s3， 用来存放三个面积，其作用域为整个程序。函数vs用来求正方体体积和三个面积， 函数的返回值为体积v。由主函数完成长宽高的输入及结果输出。由于Ｃ语言规定函数返回值只有一个， 当需要增加函数的返回数据时，用外部变量是一种很好的方式。本例中，如不使用外部变量， 在主函数中就不可能取得v,s1,s2,s3四个值。而采用了外部变量， 在函数vs中求得的s1,s2,s3值在main 中仍然有效。因此外部变量是实现函数之间数据通讯的有效手段。对于全局变量还有以下几点说明： 1. 对于局部变量的定义和说明，可以不加区分。而对于外部变量则不然，外部变量的定义和外部变量的说明并不是一回事。外部变量定义必须在所有的函数之外，且只能定义一次。其一般形式为： [extern] 类型说明符 变量名，变量名… 其中方括号内的extern可以省去不写。
例如： int a,b;
等效于：
extern int a,b;
而外部变量说明出现在要使用该外部变量的各个函数内， 在整个程序内，可能出现多次，外部变量说明的一般形式为： extern 类型说明符 变量名，变量名，…； 外部变量在定义时就已分配了内存单元， 外部变量定义可作初始赋值，外部变量说明不能再赋初始值， 只是表明在函数内要使用某外部变量。
2. 外部变量可加强函数模块之间的数据联系， 但是又使函数要依赖这些变量，因而使得函数的独立性降低。从模块化程序设计的观点来看这是不利的， 因此在不必要时尽量不要使用全局变量。
3. 在同一源文件中，允许全局变量和局部变量同名。在局部变量的作用域内，全局变量不起作用。
[例5.13]int vs(int l,int w)
{
extern int h;
int v;
v=l*w*h;
return v;
}
main()
{
extern int w,h;
int l=5;
printf("v=%d",vs(l,w));
}
int l=3,w=4,h=5;
本例程序中，外部变量在最后定义， 因此在前面函数中对要用的外部变量必须进行说明。外部变量l，w和vs函数的形参l，w同名。外部变量都作了初始赋值，mian函数中也对l作了初始化赋值。执行程序时，在printf语句中调用vs函数，实参l的值应为main中定义的l值，等于5，外部变量l在main内不起作用；实参w的值为外部变量w的值为4，进入vs后这两个值传送给形参l，wvs函数中使用的h 为外部变量，其值为5，因此v的计算结果为100，返回主函数后输出。变量的存储类型各种变量的作用域不同， 就其本质来说是因变量的存储类型相同。所谓存储类型是指变量占用内存空间的方式， 也称为存储方式。
变量的存储方式可分为“静态存储”和“动态存储”两种。
静态存储变量通常是在变量定义时就分定存储单元并一直保持不变， 直至整个程序结束。5.5.1节中介绍的全局变量即属于此类存储方式。动态存储变量是在程序执行过程中，使用它时才分配存储单元， 使用完毕立即释放。 典型的例子是函数的形式参数，在函数定义时并不给形参分配存储单元，只是在函数被调用时，才予以分配， 调用函数完毕立即释放。如果一个函数被多次调用，则反复地分配、 释放形参变量的存储单元。从以上分析可知， 静态存储变量是一直存在的， 而动态存储变量则时而存在时而消失。我们又把这种由于变量存储方式不同而产生的特性称变量的生存期。 生存期表示了变量存在的时间。 生存期和作用域是从时间和空间这两个不同的角度来描述变量的特性，这两者既有联系，又有区别。 一个变量究竟属于哪一种存储方式， 并不能仅从其作用域来判断，还应有明确的存储类型说明。
在Ｃ语言中，对变量的存储类型说明有以下四种：
auto 自动变量
register 寄存器变量
extern 外部变量
static 静态变量
自动变量和寄存器变量属于动态存储方式， 外部变量和静态变量属于静态存储方式。在介绍了变量的存储类型之后， 可以知道对一个变量的说明不仅应说明其数据类型，还应说明其存储类型。 因此变量说明的完整形式应为： 存储类型说明符 数据类型说明符 变量名，变量名…； 例如：
static int a,b; 说明a,b为静态类型变量
auto char c1,c2; 说明c1,c2为自动字符变量
static int a[5]=; 说明a为静整型数组
extern int x,y; 说明x,y为外部整型变量
下面分别介绍以上四种存储类型：
一、自动变量的类型说明符为auto。
这种存储类型是Ｃ语言程序中使用最广泛的一种类型。Ｃ语言规定， 函数内凡未加存储类型说明的变量均视为自动变量， 也就是说自动变量可省去说明符auto。 在前面各章的程序中所定义的变量凡未加存储类型说明符的都是自动变量。例如：
{ int i,j,k;
char c;
……
}等价于： { auto int i,j,k;
auto char c;
……
}
自动变量具有以下特点：
1. 自动变量的作用域仅限于定义该变量的个体内。在函数中定义的自动变量，只在该函数内有效。在复合语句中定义的自动变量只在该复合语句中有效。 例如：
int kv(int a)
{
auto int x,y;
{ auto char c;
} /*c的作用域*/
……
} /*a,x,y的作用域*/
2. 自动变量属于动态存储方式，只有在使用它，即定义该变量的函数被调用时才给它分配存储单元，开始它的生存期。函数调用结束，释放存储单元，结束生存期。因此函数调用结束之后，自动变量的值不能保留。在复合语句中定义的自动变量，在退出复合语句后也不能再使用，否则将引起错误。例如以下程序： |
