第六章函数.doc

第六章 函 数
教学时间：
10学时
教学目的：
1、掌握函数定义的形式
2、掌握函数的嵌套调用与递归调用
3、理解局部变量和全局变量

内容、重点、难点：　
内容：
6.1 概 述
6.2 函数定义的一般形式
6.3 函数参数和函数的值
6.4 函数的调用
6.5 函数的嵌套调用
6.6 函数的递归调用
6.7 数组作为函数参数
6.8 局部变量和全局变量
6.9 动态存储变量与静态存储变量
重点：
1、函数的定义、调用
2、数组作为函数参数
难点：
1、函数的嵌套、递归调用
2、 局部变量和全局变量的应用
注：教案尾页有小结和作业
第6章 函 数
一个较大的程序一般应分为若干个程序模块，每一个模块用来实现一个特定的功能，所有的高级语言中都有子程序这个概念，用子程序来实现模块的功能。
在C语言中，子程序的作用是由函数来完成的。一个C程序可由一个主函数和若干个函数构成。由主函数来调用其它函数，其它函数也可以互相调用。同一个函数可以被一个或多个函数调用任意多次。
6.1 概 述
一、问题的提出
[问题] 一个简单的例子。
main( )
{
printstar( ); /*调用printstar函数*/
print_message( ); /*调用print_message函数*/
printstar( ); /*调用printstar函数*/
}
printstar( ) /*pirntstar函数*/
{
printf(″* * * * * * * * * * * * * * * * * *\n″);
}
print_message( ) /*print_message函数*/
{
printf(″ How do you do!\n″);
}
运行情况如下：
* * * * * * * * * * * * * * * * * *
How do you do !
* * * * * * * * * * * * * * * * * *
[说明]：本节问题中，printstar和print_message都是用户定义的函数名，分别用来输出一排星号和一行信息。
现对函数在程序中的使用作几点说明：
1．一个源程序文件由一个或多个函数组成。一个源程序文件是一个编译单位，即以源文件为单位进行编译，而不是以函数为单位进行编译。
2．一个C程序由一个或多个源程序文件组成。
3．C程序的执行从main函数开始，调用其它函数后流程回到main函数，再在main函数中结束整个程序的运行。main函数是系统定义的。
4．所有函数都是平行的，即在定义函数时是互相独立的，一个函数并不从属于另一函数，即函数不能嵌套定义，但可以互相调用，但不能调用main函数。
5．从用户的角度看，函数有两种：
（1）标准函数，即库函数。
（2）用户自己定义的函数，以解决用户的专门需要。
6．从函数的形式看，函数分两类：
（1）无参函数。如本节问题中的printstar和print_message就是无参函数。
（2）有参函数。在调用函数时，在主调函数和被调用函数之间有参数传递。
6.2 函数定义的一般形式
一、 问题的提出
例6.1 求两数之和。
main( )
{
float a,b,c;
float add(float,float); /*对被调函数的说明*/
scanf(″%f,%f″,&a,&b);
c＝add(a,b);
printf(″sum＝%f\n″,c);
}
float add(x,y)
float x,y;
{
float z;
z＝x+y;
return(z);
}
运行结果：
8.2，6.5↙
sum is 14.700000
二、无参函数的定义形式
类型标识符 函数名（）
{说明部分
语句}
用“类型标识符”指定函数值的类型，即函数带回来的值的类型。无参函数一般不需要带回函数值，因此可以不写类型标识符，printstar和print_message就如此。
三、有参函数定义的一般形式
类型标识符 函数名（形式参数表列）
形式参数说明
{说明部分
语句}
例如：
float add(x,y)
float x,y; /*形式参数说明*/
{float z; /*函数体中的说明部分*/
z＝x+y;
return(z);
}
注意：1、第二行“float x，y；”是对形式参数作类型说明，指定x和y为单精度型。花括弧内是函数体，它包括说明部分和语句部分。
2、“float z;”必须写在花括弧内，而不能写在花括弧外。
3、不能将第二、三行合并写成“float x，y，z；”。形式参数的说明应在函数体外。
4、在函数体的语句中求出z的值（为x与y的和），return语句的作用是将z的值作为函数值带回到主调函数中。
return后面的括弧中的值作为函数带回的值（或称函数返回值）。在函数定义时已指定add函数为实型，在函数体中定义z为实型，二者是一致的，将z作为函数add的值带回调用函数。
四、空函数
也可以有“空函数”，它的形式为：
类型说明符 函数名（）
{ }
例如
dummy（）
{ }
调用此函数时，什么工作也不做，没有任何实际作用。
6.3 函数参数和函数的值
一、形式参数和实际参数
“形式参数”：在定义函数时函数名后面括弧中的变量名。
“实际参数”：用函数时，函数名后面括弧中的表达式。
例6.2 main()
{
int a,b,c;
scanf(″％d%d″,&a,&b);
c＝max(a,b);
printf(″Max is %d″,c);
}
max(x,y)
int x,y;
{
int z;
z＝x>y?x:y;
return(z);
}
运行情况如下：
7，8↙
Max is 8
关于形参与实参的说明：
1． 定义函数时指定的形参变量，在未出现函数调用时，它们并不占用内存中的存储单元。只有在发生函数调用时函数中的形参才被分配内存单元。在调用结束后，形参所占的内存单元也被释放。
2．实参可以是常量、变量和表达式，如：
max＝（3，a+b）；
但要求它们有确定的值。在调用时将实参的值赋给形参变量。

3．定义的函数中，必须指定形参的类型。
4．实参与形参的类型应相同或赋值兼容。
5． C语言规定，实参变量对形参变量的数据传递是“值传递”，即单向传递，只由实参传给形参，而不能由形参传回来给实参。在内存中，实参单元与形参单元是不同的单元。
6．ANSI新标准允许使用另一种方法对形参类型作说明，即在列出“形参表列”时，同时说明形参类型。如
int max(int x,int y)
{……}
相当于：
int max(x,y)
int x,y;
{……}
又如：
float fun(array,n)
int array[10],n;
可以写成
float fun(int array[10],int n)
这两种用法等价，都可以使用。
二、函数的返回值
通常，希望通过函数调用使主调函数能得到一个确定的值，这就是函数的返回值。
1．函数的返回值是通过函数中的return语句获得的。
return语句后面的括弧也可以不要，如
return z；
它与“return（z）；”等价。
2．函数值的类型。
在定义函数时指定函数值的类型，例如：
int max(iny x,int y) 函数值为整型
char letter(char c1,char c2) 函数值为字符型
double min(float x,float y) 函数值为双精度型
在定义函数时对函数值说明的类型一般应该和return语句中的表达式类型一致。
3．如果函数值的类型和return语句中表达式的值的类型不一致，则以函数类型为准。对数值型数据，可以自动进行类型转换。即函数类型决定返回值的类型。
例6.3 将例6.2稍做改动（注意是变量的类型改动）。
main( )
{
float a,b;
int c;
scanf(″%f,%f″,&a,&b);
c＝max(a,b);
printf(″Max is %d\n″,c);
}
max(float x,float y)
{float z;
z＝x>y?x:y;
return(z);
}
运行情况如下：
1.5，2.5↙
Max is 2
4．如果被调用函数中没有return语句，并不带回一个确定的、用户所希望得到的函数值，但实际上，函数并不是不带回值，而只是不带回有用的值，带回的是一个不确定的值。
5．为了明确表示“不带回值”，可以用“void”定义“无类型”（或称“空类型”）。为使程序减少出错，保证正确调用，凡不要求带回函数值的函数，一般应定义为“void”类型。
6.4 函数的调用
一、问题的提出
输出n的阶乘值。n由键盘输入。
main( )
{
int n ;
float f;
float fac(int );
scanf(″%d″,&n);
f=fac(n);
printf(″％d!＝%f\n″,n,f);
}
float fac(int s)
{
float fa=1；
for（i＝1;i<s;i＋＋）
fa=fa*i;
return(fa);
}
二、函数调用的一般形式
函数调用的一般形式为
函数名（实参表列）；
如果是调用无参函数，则实参表列可以没有，但括弧不能省略，如
printstar( )；
三、函数调用的方式
按函数在程序中出现的位置来分，可以有以下三种函数调用方式：
1． 函数语句。把函数调用作为一个语句。如
printstar（）；
这时不要求函数带回值，只要求函数完成一定的操作。
2．函数表达式。函数出现在一个表达式中，这种表达式称为函数表达式。这时要求函数带回一个确定的值以参加表达式的运算。例如
c＝2*max（a，b）
函数max是表达式的一部分，它的值乘2再赋给c。
3、函数参数。函数调用作为一个函数的实参。
例如m＝max（a，max（b，c））；
四、对被调用函数的说明
在一个函数中调用另一函数（即被调用函数）需要具备哪些条件呢？
1．首先被调用的函数必须是已经存在的函数 。
2．如果使用库函数，一般还应该在本文件开头用＃include命令将调用有关库函数时所用到的信息包含到本文件来。
3．如果使用用户自己定义的函数，而且该函数与调用它的函数（即主调函数）在同一个文件中，一般还应该在主调函数中对被调用函数的返回值的类型作说明。这种类型说明的一般形式为
类型标识符 被调用函数的函数名（）
C语言规定，在以下几种情况下可以不在调用函数前对被调用函数作类型说明：
1．如果函数的值（函数的返回值）是整型或字符型，可以不必进行说
明，系统对它们自动按整型说明。
2．如果被调用函数的定义出现在主调函数之前，可以不必加以说明。因为编译系统已经先知道了已定义的函数类型，会自动处理的。
3．如果已在所有函数定义之前，在文件的开头，在函数的外部说明了函数类型，则在各个函数中不必对所调用的函数再作类型说明。
6.5 函数的嵌套调用
例6.5 函数的嵌套调用。
main( ) a2( )
{a1( ); {
a3( ); printf(″22222222\n″);
printf(″44444444\n″); }
} a3( )
a1( ) {
{ printf(″33333333\n″);
printf(″11111111\n″); }
a2( );
}
运行结果：
11111111
22222222
33333333
44444444
C语言不能嵌套定义函数，但可以嵌套调用函数。
6.6 函数的递归调用
例6.6 用递归方法求n!
float fac (n)
int n;
{
float f;
if(n<0) printf(″n<0,data error!″);
else if(n＝＝0‖n＝＝1) f＝1;
else f＝fac(n-1)*n;
return(f);
}
main( )
{
int n;
float y;
printf(″input a integer number: ″);
scanf(″%d″,&n);
y＝fac(n);
printf(″%d! ＝%15.0f″,n,y);
}
运行情况如下：
input an integer number：10↙
10！＝ 3628800
在调用一个函数的过程中又出现直接或间接地调用该函数本身，称为函数的递归调用。
例6.7有5个人坐在一起，问第5个人多少岁？他说比第4个人大2岁。问第4个人年龄，他说比第3个人大2岁。问第3个人，又说比第2个人大2岁。问第2个人，说比第1个人大2岁。最后问第1个人，他说是10岁。请问第5个人多大。
age(5)＝age(4)+2
age(4)＝age(3)+2
age(3)＝age(2)+2
age(2)＝age(1)+2
age(1)＝10
可以用式子表述如下：
10 (n＝1)
age(n)＝
age(n-1)+2 (n>1)
可以用一个函数来描述上述递归过程：
age(int n) /*求年龄的递归函数*/
{int c; /*c用作存放函数的返回值的变量*/
if(n＝ ＝1) c＝10;
else c＝age(n-1)+2;
return(c);
}
main( )
{
printf(″%d″,age(5));
}
运行结果如下：
18
6.7 数组作为函数参数
一、数组元素做实参
例6.8 有两个数组a、b。各有10个元素，将它们对应地逐个相比（即a[0]与b[0]比，a[1]与b[1]比，……）。如果a数组中的元素大于b数组中相应元素的数目多于b数组中元素大于a数组中相应元素的数目（例如，a[i]>b[i]6次，b[i]>a[i]3次，其中i每次为不同的值，）则认为a数组大于b数组，并分别统计出两个数组相应元素大于、等于、小于的次数。
main()
{
int a[10],b[10],i,n＝0,m＝0,k＝0;
printf(″enter array a:\n″);
for(i＝0;i<10;i++)
scanf(″%d″,&a[i]);
printf(″\n″);
printf(″enter array b:\n″);
for(i＝0;i<10;i++)
scanf(″%d″,&b[i]);
printf(″\n″);
for(i＝0;i<10;i++)
{
if (large(a[i],b[i])＝ ＝1) n＝n+1;
else if (large (a[i],b[i])＝ ＝0) m＝m+1;
else k＝k+1;}
printf(″a[i]>b[i]%d times \na[i]＝b[i]%d times\na[i]<b[i] %d times\n″,n,m,k );
if(n>k) printf(″array a is large than array b\n″);
else if(n<k) printf(″array a is smaller than array b\n″);
else printf(″array a is equal to array b\n″);
}
large(int x,int y)
{int flag;
if(x>y) flag＝1;
else if(x<y) flag＝－1;
else flag＝0;
return(flag);
}
运行情况如下：
enter array a：
1 3 5 7 9 8 6 4 2 0↙
enter array b：
5 3 8 9 –1 –3 5 6 0 4↙
a[i]>b[i] 4 times
a[i]＝b[i] 1 times
a[i]<b[i] 5 times
array a is smaller than array b
二、数组名作函数参数
例6.9 有一个一维数组score，内放10个学生成绩，求平均成绩。
float average(float array[10])
{
int i;
float aver,sum＝array[0];
for(i＝1;i<10;i++)
sum＝sum+array[i];
aver＝sum/10;
return(aver);
}
main( )
{
float score[10],aver;
int i;
printf(″input 10 scores:\n″);
for(i＝0;i<10;i++)
scanf(″%f″,&score[i]);
printf(″\n″);
aver＝average(score);
printf(″average score is %5.2f″,aver);
}
运行情况如下：
input 10 scores
100 56 78 98.5 76 87 99 67.5 75 97↙
average score is 83.40
[说明]
1．用数组名作函数参数，应该在主调函数和被调用函数中分别定义数组，上例中array是形参数组名，score是实参数组名，分别在其所在函数中定义，不能只在一方定义。
2．实参数组与形参数组类型应一致，如不一致，结果将出错。
3．实参数组和形参数组大小可以一致也可以不一致，C编译对形参数组大小不做检查，只是将实参数组的首地址传给形参数组。
4． 形参数组也可以不指定大小，在定义数组时在数组名后面跟一个空
的方括弧，为了在被调用函数中处理数组元素的需要，可以另设一个参数，传递数组元素的个数，例6.9可以改写为例6.10形式。
例6.10
float average(float array[ ],int n)
{int i;
float aver,sum＝array[0];
for(i＝1;i<n;i++)
sum＝sum/n;
return(aver);
}
main( )
{static float score_1[5]＝{98.5,97,91.5,60,55};
static float score_2[10]＝{67.5,89.5,99,69.5,77,89.5,76.5,54,60,99.5};
printf(″the average of class A is %6.2f\n″,average(score_1,5));
printf(″the average of class B is %6.2f\n″,average(score_2,10));
}
运行结果如下：
the average of class A is 80.40
the average of class B is 78.20
可以看出，两次调用average函数时数组大小是不同的，在调用时用一个实参传递数组大小（传给形参n），以便在average函数中对所有元素都访问到。
5．最后应该强调一点：用数组名作函数参数时，不是把数组的值传递给形参，而是把实参数组的起始地址传递给形参数组，这样两个数组就共占同一段内存单元。
例6.11 用选择法对数组中10个整数按由小到大的顺序排序。所谓选择法排序就是：先将10个数中最小的数与a[0]对换；再将a[1]到a[9]中最小的数与a[1]对换；……，每比较一轮，找出一个未经排序的数中最小的一个。共应比较9轮。
void sort(int array[ ],int n)
{int i,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[k];array[k]＝array[i];array[i]＝t;}
}
main( )
{int a[10],i;
printf(″enter the array\n″);
for(i＝0;i<10;i++)
scanf(″%d″,&a[i]);
sort(a,10);
printf(″the sorted array :\n″);
for(i＝0;i<10;i++)
printf(″%d″,a[i]);
printf(″\n″);
}
三、用多维数组名作函数实参
可以用多维数组名作为实参和形参，在被调用函数中对形参数组定义时可以指定每一维的大小，也可以省略第一维的大小说明。
例6.12 有一个3×4的矩阵，求其中的最大元素。
max_value(int array[ ][4])
{int i,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( )
{static int a[3][4]＝{{1,3,5,7},{2,4,6,8},{15,17,34,12}};
printf(″max value is %d\n″,max_value(a));
}
程序运行结果如下：
max value is 34
6.8 局部变量和全局变量
6.8.1 局部变量
在一个函数内部定义的变量是内部变量，它只在本函数范围内有效，也就是说只有在本函数内才能使用它们，在此函数以外是不能使用这些变量的。这样得变量称为“局部变量”。
说明：
1．主函数main中定义的变量也只在主函数中有效，不因为在主函数中定义而在整个文件或程序中有效。主函数也不能使用其它函数中定义的变量。
2．不同函数中可以使用相同名字的变量，它们代表不同的对象，互不干扰。
3．形式参数也是局部变量。例如f1函数中的形参a，也只在f1函数中有效。其它函数不能调用。
4．在一个函数的内部，可以在复合语句中定义变量，这些变量只在本复合语句中有效，这种复合语句也可称为“分程序”或“程序块”。
二、全局变量
在函数内定义的变量是局部变量，而在函数之外定义的变量称为外部变量，外部变量是全局变量。全局变量可以为本文件中其它函数所共用。它的有效范围为：从定义变量的位置开始到本源文件的结束。
说明：
1．设全局变量的作用：增加了函数间数据联系的渠道。由于函数的调用只能带回一个返回值，因此有时可以利用全局变量增加与函数联系的渠道，从函数得到一个以上的返回值。
例6.13 有一个一维数组，内放10个学生成绩，写一个函数，求出平均分，最高分和最低分。
float max＝0,min＝0; /*全局变量*/
float average(float array[ ],int n) /*定义函数，形参为数组*/
{int i;
float aver,sum＝array[0];
max＝min＝array[0];
for(i＝1;i<n;i＋＋)
{if(array[i]>max) max＝array[i];
else if(array[i]<min) min＝array[i];
sum＝sum＋array[i];
}
aver＝sum/n;
return(aver);
}
main( )
{float ave,score[10];
int i;
for(i＝0;i<10;i＋＋)
scanf(″%f″,&score[i]);
ave＝average(score,10);
printf(″max＝%6.2f\nmin＝%6.2f\naverage＝%6.2f\n″,max,min,
ave);
}
运行情况如下
99 45 78 97 100 67.5 89 92 66 43↙
max＝100.00
min＝ 43.00
average＝ 77.65
2．如果外部变量在文件开头定义，则在整个文件范围内都可以使用该外部变量，如果不在文件开头定义，按上面规定作用范围只限于定义点到文件终了。如果在定义点之前的函数想引用该外部变量，则应该在该函数中用关键字extern作“外部变量说明”。表示该变量在函数的外部定义，在函数内部可以使用它们。
外部变量定义和外部变量说明的区别：
（1）、外部变量的定义只能有一次，它的位置在所有函数之外，而同一文件中的外部变量的说明可以有多次，它的位置在函数之内（哪个函数要用就在哪个函数中说明）。
（2）、系统根据外部变量的定义（而不是根据外部变量的说明）分配存储单元。对外部变量的初始化只能在“定义”时进行，而不能在“说明”中进行。
（3）、所谓“说明”，其作用是：申明该变量是一个已在外部定义过的变量，仅仅是为了引用该变量而作的“申明”。原则上，所有函数都应当对所有的外部变量作说明（用extern），只是为了简化起见，允许在外部变量的定义点之后的函数可以省略这个“说明”。
3．如果在同一个源文件中，外部变量与局部变量同名，则在局部变量的作用范围内，外部变量不起作用。
6.9 动态存储变量与静态存储变量
一、变量的存储类别
从变量值存在的时间（即生存期）角度来分，可以分为静态存储变量和动态存储变量。
所谓静态存储方式是指在程序运行期间分配固定的存储空间的方式。而动态存储方式则是在程序运行期间根据需要进行动态的分配空间的方式。
先看一下内存中供用户使用的存储空间的情况。这个存储空间可分为三部分：
1． 程序区
2． 静态存储区
3． 动态存储区
数据分别存放在静态存储区和动态存储区中。全局变量存放在静态存
储区中，在程序开始执行时给全局变量分配存储区，程序执行完毕就释放。在程序执行过程中它们占据固定的存储单元，而不是动态地分配和释放的。
在动态存储区中存放以下数据：
（1）函数形参变量。在调用函数时给形参变量分配存储空间。
（2）局部变量（未加上static说明的局部变量，既自动变量）
（3）函数调用时的现场保护和返回地址等。
二、局部变量的存储方式
一、函数中的局部变量，如不做专门的说明，都是动态的分配存储空间的，存储在动态存储区中。对它们分配和释放存储空间的工作是由编译
系统自动处理的，因此这类局部变量称为自动变量。自动变量用关键字auto作存储类型的说明。
二、有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值，即其占用的存储单元不释放，在下一次该函数调用时，该变量已有值，就是上一次函数调用结束时的值。这时就可以指定该局部变量为“局部静态变量”，用static加以说明。
对局部静态变量的说明：
1．局部静态变量属于静态存储类别，在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量（即局部动态变量）属于动态存储类别，占动态存储区空间而不占固定空间，函数调用结束后即释放。
2．局部静态变量是在编译时赋初值的，即只赋初值一次，在程序运行时它已有初值。以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的值。而对自动变量赋初值，不是在编译时进行的，而是在函数调用时进行，每调用一次函数重新赋给一次初值，相当于执行一次赋值语句。
3．如果在定义局部变量时不赋初值的话，则对静态变量来说编译时自动赋初值为0（对数值型变量）或空字符（对字符型变量），如果不赋初值则它的值是一个不确定的值。
4．虽然局部静态变量在函数调用结束后仍然存在，但其它函数是不能引用它的。
三、如果有一些变量使用频繁，为提高执行效率，C语言允许将局部变量的值放在运算器中的寄存器中，需要时直接从寄存器取出参加运算，不必再到内存中去存储，这样就可以提高执行效率。这种变量叫“寄存器变量”，用关键字register作说明。
四、全局变量的存储方式
全局变量可以使用extern和static存储类别，当未对全局变量指定存储类别时，隐含为extern类别。
1．外部存储类别
2．静态存储类别
五、存储类别小结
对一个数据的定义，需要指定两种属性：数据类型和存储类别，分别用两个关键字进行定义，如：
static int a；（静态内部变量或静态外部变量）
auto char c；（自动变量，在函数内定义）
register int d；（寄存器变量，在函数内部定义）
extern int b；（定义外部变量）
从不同角度作以下归纳
1、从作用范围角度分：有局部变量和全局变量。
2、从变量存在的时间来区分，有动态存储和静态存储两种类型。
3、从变量值存放的位置来区分：
静态局部变量
内存中静态存储区 静态外部变量（函数外部静态变量）
外部变量（可为其他文件引用）
内存中动态存储区：自动变量和形式参数
CPU中的寄存器：寄存器变量
六、内部函数和外部函数
1． 内部函数
内部函数又称静态函数。定义时被说明成static类别，静态函数只局限
于所在文件，其他文件不能调用。
2． 外部函数
定义时被说明成extern类别的函数为外部函数。函数的隐含类别为
extern类别，外部函数可以被其他文件调用。
本章小结
在程序中使用函数，增加了程序的可读性，使程序在编写时更加简单，模块性更强。本章详细介绍了在C程序使用函数的基本方法。
1． 函数定义及调用部分。介绍了函数定义的格式，主要有无参和有参两
种，在调用时强调函数返回值应与函数类型说明一致，若无返回值应定义为void类型。
2． 在数组作函数参数时，有两种形式，一种是数组元素作函数实参，用
法与变量相同，另一种是数组名作实参和形参，传递的是数组的首地址。
3． 数据的存储类别分为两大类，静态存储类和动态存储类。函数中的局
部变量如不做特殊说明，都是动态分配存储空间的，如做static说明，将称为局部静态存储变量。函数中的全局变量在函数外部定义，编译时分配在静态存储区。
4． 内部函数和外部函数，内部函数用static做说明，只能被本文件中其它
函数所引用，外部函数用extern做说明，可以省略，外部函数可以被其它文件所引用。

作业：
P128 第一次作业： 6.1 6.2
第二次作业： 6.4 6.10