C语言基础10函数（2）

函数的递归调用

定义：在一个函数中，直接或者间接调用了函数本身，我们称之为函数的递归调用。

//直接调用
a()->a();

//间接调用
a()->b()->a();
a()->b()->...->a();

递归调用的本质：

        是一种循环结构，他不同于之前所学的while，do-while，for这样的循环结构，这些循环结构是借助循环变量，而递归是利用函数自身实现循环结构，如果不加以控制，很容易产生死循环。

递归调用的注意事项：

        1.递归调用必须要有出口，一定要终止递归（否则会产生死循环）

        2.对终止条件的判断一定要放在函数递归之前

        3.进行函数的递归调用

        4.函数递归的同时一定要向出口逼近。

案例1：

/**
* 需求：递归案例-有5个人坐在一起，问第５个人多少岁？他说比第４个人大２岁。 
问第４个人岁数，他说比第３个人大２岁。 
问第３个人，又说比第２个人大２岁。 
问第２个人，说比第１个人大２岁。 
最后问第１个人，他说是１０岁。请问第５个人多大。 
*/ 
#include <stdio.h> 
/* 求年龄的递归函数 */ 
int age(int n) 
{ 
// 存放函数的返回值，也就是年龄 
int c; 
if(n == 1) 
{ 
c = 10;// 第一个人的年龄是10岁 
}
else if(n > 1) 
{ 
c = age(n-1)+2; // 当前这个人的年龄 = 上一个人的年龄+2 
}
return c; 
}
int main() 
{ 
printf("%d\n",age(5)); 
return 0; 
} 

案例二：

/**
* 需求：递归案例-求阶乘（n!） 
*/ 
#include <stdio.h>
/* 编写一个函数，用来求阶乘 */ 
long fac(int n) 
{ 
// 因为int型表示的数据范围小，所以乘法操作我们使用long来接收计算结果 
long f; 
if(n < 0) 
{ 
printf("n的范围不能是0以下的数！\n"); 
}
else if(n == 0 || n==1) // 此时不满足阶乘条件 
{ 
f = 1; 
}
else 
{ 
f = fac(n-1)*n; 
}
return f; 
}
int main() 
{ 
int n; 
printf("请输入一个整数：\n"); 
scanf("%d",&n); 
printf("%d!=%ld\n",n,fac(n)); 
return 0; 
} 

数组做函数参数

注意：

        当用数组做函数的实际参数时，则形参应该也要用数组/ 指针变量来接收，但请注意，此次并不代表传递了数组中所有的元素数据，而是传递了第一个元素的内存地址（数组首地址），形参接收这个地址后，则形参和实参就代表了同一块内存空间，则形参的数据修改会改变实参的。这种数据传递方式我们可以称之为“ 引用传递 ” 。

        如果用数组做函数形式参数，那么我们提供另一个形参表示数组的元素个数。原因是数组形参代表的仅仅是实际数组的首地址。也就是说形参只获取到了实际数组元素的开始，并未获取元素的结束。所以提供另一个形参表示数组的元素个数，可以防止在被调函数对实际数组元素访问的越界。

        但有一个例外，如果是用字符数组做形参，且实际数组中存放的是字符串数据（形参是字符数组，实参是字符串）。则不用表示数组元素的个数的形参，原因是字符串本身会自动结束符\0 。

案例：数组元素做函数实参

/**
* 需求：数组为参数案例-有两个数组ａ和ｂ，各有10个元素，将它们对应元素逐个地相比（即ａ[0]与ｂ[0]比，ａ[1] 
与ｂ[1]比……）。如果ａ数组中的元素大于ｂ数组中的相应元素的数目多于b数组中元素大于a数组中相应元素的数目(例 
如，a[i]>b]i]6次，b[i]>a[i] 3次，其中i每次为不同的值)，则认为a数组大于b数组，并分别统计出两个数组相应元 
素大于、等于、小于的个数。 
*
*/ 
#include <stdio.h> 
/* 定义一个函数，实现两个数的比较 */ 
int large(int x,int y) 
{ 
int flag;// 用来存放比较结果 
if(x > y) flag = 1; 
else if(x < y) flag = -1; 
else flag = 0; 
return flag; 
}
int main() 
{ 
// 比较用的两个数组，循环变量，最大，最小，相等 
int a[10],b[10],i,max=0,min=0,k=0; 
printf("请给数组a添加十个整型数据：\n"); 
for(i = 0;i < sizeof(a)/sizeof(int);i++) 
{ 
scanf("%d",&a[i]); 
}
printf("\n"); 
printf("请给数组b添加十个整型数据：\n"); 
for(i = 0;i < sizeof(b)/sizeof(int);i++) 
scanf("%d",&b[i]); 
printf("\n"); 
// 遍历 
for(i = 0;i < sizeof(a)/sizeof(int);i++) 
{ 
if(large(a[i],b[i])==1) 
{ 
max++; 
}
else if(large(a[i],b[i])==0) 
{ 
k++; 
}
else 
{ 
min++; 
} 
}
printf("max=%d,min=%d,k=%d\n",max,min,k); 
return 0; 
} 

案例二：

/**
* 需求：数组函数的参数案例-编写一个函数，用来分别求数组score_1（有5个元素）和数组score_2（有10个元素） 
各元素的平均值 。 
*/ 
#include <stdio.h> 
/* 定义一个函数，用来求平均分 */ 
float avg(float scores[],int len) 
{ 
int i;// 循环变量 
float aver,sum = scores[0];// 保存平均分和总成绩 
// 遍历集合 
for(i = 1;i < len;i++) 
{ 
sum += scores[i]; 
}
aver = sum / len; 
return aver; 
}
int main() 
{ 
//准备俩测试数组 
float score_1[5] = {66,34,46,37,97}; 
float score_2[10] = {77,88,66,55,65,76,87,98,75,34}; 
printf("这个班的平均分是：%6.2f\n",avg(score_1,sizeof(score_1)/sizeof(float))); 
printf("这个班的平均分是：%6.2f\n",avg(score_2,sizeof(score_2)/sizeof(float))); 
return 0; 
} 

变量的作用域

引入问题

        我们在函数设计过程中，经常要考虑对参数的设计，换句话说，我们需要考虑函数需要几个参数，需要什么类型的参数，但我并没有考虑函数是否需要提供参数，如果说函数可以访问到已定义的数据，则就不需要提供函数形参，那么我们到底要不要提供函数参数，取决于什么？答案就是变量的作用域 （如果函数在变量的作用域范围内，则函数可以直接访问数据）

变量的作用域

概念：变量的作用范围，也就是说变量在什么范围是有效的。

变量的分类

根据变量的作用域不同，变量可分为全局变量和局部变量

建议在全局变量定义时初始化。如果不初始化，系统会将全局变量初始化为 0 （ 0 | \0 |0.0 ）。

• 使用全局变量的优缺点：

优点：

        1. 利用全局变量可以实现一个函数对外输出的多个结果数据。

        2. 利用全局变量可以减少函数形参个数，从而降低内存消耗，以及因形参传递带来的时间消耗。

缺点：

        1. 全局变量在程序的整个运行期间，始终占据内存空间，会引起资源消耗。

        2. 过多的全局变量会引起程序的混乱，造成程序结果错误。

        3. 降低程序通用性，特别是当我们进行函数移植时，不仅仅要移植函数，还要考虑全局变量。

        4. 违反了 “ 高内聚，低耦合 ” 的程序设计原则。

总结：我们发现弊大于利，建议尽量减少对全局变量的使用，函数之间要产生联系，仅通过实参 -

形参的方式产生联系。

作用域举例：

案例：

int p=1,q=5; /*外部变量p,q*/ 
float f1(int a) /*定义函数f1*/ 
{ int b,c; 
… 
}
char c1,c2; /*外部变量c1,c2*/ 
char f2 (int x, int y) /*定义函数f2*/ 
{ int i,j; 
… 
}
void main ( ) /*主函数*/ 
{ int m,n; 
… 
} 

 注意：

如果全局变量（外部变量）和局部变量同名，程序执行的时候， 就近原则

int a = 10; 
int main() 
{ 
int i = 20; 
printf("%d\n",a); // 20 就近原则 
for(int i = 0;i < 5; i++) 
{ 
printf("i=%d ",i); // 0 1 2 3 4 就近原则 
} 
} 

变量的生命周期

• 概念：变量在程序运行中存在的时间
• 根据变量存在的时间不同，变量可分为静态存储方式和动态存储方式。

• 变量的存储类型

 变量的完整定义格式：[存储类型] 数据类型 变量列表;

• 存储类型

auto

auto 存储类型只能修饰局部变量，被 auto 修饰的局部变量是存储在动态存储区的。 auto 也是局部变

量默认的存储类型。

int a = 10;等价于 auto int a = 10;

static

修饰局部变量：局部变量会被存储在静态存储区。局部变量的生命周期被延长，但是作用域不发

生改变。

修改全局变量：全局变量的生命周期不变，但作用域被衰减。一般限制全局变量只能在本文件

内

#include "demo01.h"
 // 全局变量 
static int fun_a = 10;
 int fun1()

#include "demo01.h" 
main()
 {
 // 此时fun_a就不能被其他文件访问 
fun_a = 20; 
} 

extern

外部存储类型：只能修饰全局变量，使全局变量可以被其他文件访问。相当于扩展了全局变量的

作用域。

extern 修饰外部变量，往往是外部变量进行声明，声明该变量是在外部文件中定义的；不是变量定

义。

 

register

寄存器存储类型：只能修饰局部变量，用 register 修饰的局部变量会直接存储到 CPU 的寄存器中，

往往将循环变量设置为寄存器存储类型

面试题 static关键字的作用

1. static 修饰局部变量，延长其生命周期，但不影响局部变量的作用域。

2. static 修饰全局变量，不影响全局变量的生命周期，会限制全局变量的作用域仅限本文件内使

用；

3. static 修饰函数：此函数就称为内部函数，仅限本文件内调用。 static int funa(){..}

值传递与引用传递

值传递：发生在整型、浮点型、字符型，数据传递，传递的是数值，也就是内存空间只能被当前变

量独享。

引用传递：发生在数组、指针、结构体 .. ，数据传递，传递的是地址值，也就是内存空间可以被多

个变量共享。

// 值传递（整型、浮点型、字符型..） 
fun(int x) 
{ 
printf("%d\n",x); // x = 10 
x = 20; // x = 20 
}
main() 
{ 
int a = 10; // a = 10 
fun(a); 
printf("%d\n",a);// a = 10
}
------------------------------------------------------------------------------------- 
// 引用传递（数组、指针、结构体..） 
fun(int x[10]) 
{ 
printf("%d\n",x[9]);// x[9] = 0 
x[9] = 20; // x[9] = 20 
}
main() 
{ 
int a[10] = {1,2,3}; 
fun(a); 
printf("%d\n",a[9]);// a[9] = 20 
} 

内部函数和外部函数

• 内部函数：使用static修饰的函数，称作内部函数，内部函数只能在当前文件中调用。
• 外部函数：使用extern修饰的函数，称作外部函数，extern是默认的，可以不写，也就是说本质上我们所写的函数都是外部函数，建议外部函数在被其他文件调用的时候，在其他文件中声明的时候，加上extern关键字。