第八章 函数

本章要点 函数的概念 函数的定义与调用 函数的递归调用 变量的作用域 函数的作用域

主要内容 8.1 概述 8.２函数定义的一般形式 8.３函数参数和函数的值 8.４ 函数的调用 8.５ 函数的嵌套调用 8.６函数的递归调用 8.７数组作为函数参数 8.8 局部变量和全局变量 8.９变量的存储类别 8.10 内部函数和外部函数

8.1 概述 一个Ｃ程序可由一个主函数和若干个其他函数构成。一个较大的程序可分为若干个程序模块，每一个模块用来实现一个特定的功能。在高级语言中用子程序实现模块的功能。子程序由函数来完成。 函数间的调用关系:由主函数调用其他函数，其他函数也可以互相调用。同一个函数可以被一个或多个函数调用任意多次。

例8.1先举一个函数调用的简单例子 # include <stdio.h> void main() { void printstar(); /*对printstar函数声明*/ void print_message(); /*对print_message函数声明*/ printstar(); ／*调用printstar函数*／ print_message(); /*调用print_message函数*/ printstar(); ／*调用printstar函数*/ }

运行情况如下： * * * * * * * * * * * * * * * * How do you do! void printstar() ／*定义printstar函数*／ { printf("* * * * * * * * * * * * * * * *\n"); } void print_message() ／*定义print_message函数*／ printf("How do you do!\n"); 运行情况如下： * * * * * * * * * * * * * * * * How do you do!

说明： (1)一个Ｃ程序由一个或多个程序模块组成，每一个程序模块作为一个源程序文件。对于较大的程序，通常将程序内容分别放在若干个源文件中，再由若干源程序文件组成一个C程序。这样便于分别编写、分别编译，提高调试效率。一个源程序文件可以为多个C程序公用。

(2) 一个源程序文件由一个或多个函数以及其他有关内容（如命令行、数据定义等）组成。一个源程序文件是一个编译单位，在程序编译时是以源程序文件为单位进行编译的，而不是以函数为单位进行编译的。 (3) Ｃ程序的执行是从main函数开始的，如果在main函数中调用其他函数，在调用后流程返回到main函数，在main函数中结束整个程序的运行。

(4)所有函数都是平行的，即在定义函数时是分别进行的，是互相独立的。一个函数并不从属于另一函数，即函数不能嵌套定义。函数间可以互相调用，但不能调用main函数。main函数是系统调用的。

(5)从用户使用的角度看，函数有两种： ① 标准函数，即库函数。这是由系统提供的，用户不必自己定义这些函数，可以直接使用它们。不同的C系统提供的库函数的数量和功能会有一些不同，但许多基本的函数是共同的。 ② 用户自己定义的函数。用以解决用户的专门需要。

(6) 从函数的形式看，函数分两类： ①无参函数。无参函数一般用来执行指定的一组操作。在调用无参函数时，主调函数不向被调用函数传递数据。 ②有参函数。主调函数在调用被调用函数时，通过参数向被调用函数传递数据。

8.２函数定义的一般形式 8.2.1 无参函数的定义一般形式 定义无参函数的一般形式为: 类型标识符　函数名（） ｛ 声明部分 语句部分 ｝

8.2.2 有参函数定义的一般形式 定义有参函数的一般形式为: 类型标识符 函数名（形式参数表列） ｛ 声明部分 语句部分 ｝ 例如： 类型标识符　函数名（形式参数表列） ｛ 声明部分 语句部分 ｝ 例如： ｉｎｔ ｍａｘ（int ｘ，int ｙ） 　｛ｉｎｔ ｚ；/ *函数体中的声明部分*／ 　　ｚ＝ｘ＞ｙ？ｘ∶ｙ； return（ｚ）； ｝

8.2.3 空函数 定义空函数的一般形式为: 类型标识符 函数名（） ｛ ｝ 例如： ｄｕｍｍｙ（） 类型标识符　函数名（） ｛ ｝ 例如： ｄｕｍｍｙ（） 主调函数调用空函数时，只表明这里要调用一个函数，但函数本身什么工作也不做等,以后扩充函数功能时补充上。

8.３函数参数和函数的值 8.３.１形式参数和实际参数 形式参数：函数名后面括号中的变量名称为“形式参数”（简称“形参”）。 实际参数：主调函数中调用一个函数时，函数名后面括号中的参数(可以是一个表达式)称为“实际参数”（简称“实参”）。 函数返回值：return后面的括号中的值作为函数带回的值（称函数返回值）。

主调函数和被调用函数之间有数据传递的关系。在不同的函数之间传递数据，可以使用的方法有： 参数：通过形式参数和实际参数 返回值：用return语句返回计算结果 全局变量：外部变量

例8.２调用函数时的数据传递 #include <stdio.h> void ｍａｉｎ（） ｛ int max(int ｘ，int ｙ)； /* 对ｍａｘ函数的声明 */ int ａ，ｂ，ｃ； scanf（＂％ｄ，％ｄ＂，＆ａ，＆ｂ）； ｃ＝ｍａｘ（ａ，ｂ）； printf（＂Ｍａｘ ｉｓ ％ｄ＂，ｃ）； ｝

７，８↙ Ｍａｘ ｉｓ ８ 运行情况如下： int max(int ｘ，int ｙ)／*定义有参函数max *／ ｛ int ｚ； ｚ＝ｘ＞ｙ？ｘ∶ｙ； return（ｚ）； ｝ 运行情况如下： ７，８↙ Ｍａｘ ｉｓ ８

通过函数调用，可使两个函数中的数据发生联系。

关于形参与实参的说明： （1） 在定义函数中指定的形参，在未出现函数调用时，它们并不占内存中的存储单元。只有在发生函数调用时，函数max中的形参才被分配内存单元。在调用结束后，形参所占的内存单元也被释放。 （2） 实参可以是常量、变量或表达式， 例如： max（３，ａ＋ｂ）； 但要求它们有确定的值。在调用时将实参的值赋给形参。

（3）在被定义的函数中，必须指定形参的类型。 （4）实参与形参的类型应相同或赋值兼容。 （5）值传递:实参向形参的数据传递是单向“值传递”，只能由实参传给形参，而不能由形参传回来给实参。 在调用函数时，给形参分配存储单元，并将实参对应的值传递给形参，调用结束后，形参单元被释放，实参单元仍保留并维持原值。

8.3.2 函数的返回值 函数的返回值是通过函数调用使主调函数得到的确定值。 例如:例8.２中，max（２，３）的值是３，max（５，２）的值是5。赋值语句将这个函数值赋给变量ｃ。

说明： （1）函数的返回值是通过函数中的return语句获得的。 一个函数中可以有一个以上的return语句，执行到哪一个return语句，哪一个语句起作用。 return语句后面的括弧也可以不要 例如: “return ｚ;” 等价于 “return （ｚ）；” return后面的值可以是一个表达式。 例如: ｍａｘ（int ｘ，int ｙ） ｛　 return（ｘ>ｙ？ｘ:ｙ）； ｝

注意： 凡不加类型说明的函数，自动按整型处理。 （2）函数的返回值应当属于某一个确定的类型，在定义函数时指定函数返回值的类型。 例如:下面是3个函数的首行： int max（float ｘ，float ｙ） /* 函数值为整型 */ char letter（char c1，char c2） /* 函数值为字符型 */ double min（int ｘ，int ｙ） /* 函数值为双精度型 */ 注意： 凡不加类型说明的函数，自动按整型处理。

（3）在定义函数时指定的函数类型一般应该和return语句中的表达式类型一致。 对数值型数据，可以自动进行类型转换。即函数类型决定返回值的类型。 （4）对于不带回值的函数，应当用“void”定义函数为“无类型”（或称“空类型”）。此时在函数体中不得出现return语句。

运行情况如下： １．５， ２．５↙ Max is ２ 例 8.３ 返回值类型与函数类型不同 # include <stdio.h> void main（） ｛ int ｍａｘ（float ｘ，float ｙ）; 　 float ａ，ｂ； 　 int ｃ； 　 scanf（＂％ｆ，％ｆ，＂，＆ａ，＆ｂ）； 　 ｃ＝ｍａｘ（ａ，ｂ）； 　 printf（＂Ｍａｘ ｉｓ ％ｄ＼ｎ＂，ｃ）； ｝ int max（float ｘ，float ｙ） ｛ float ｚ； /* z为实型变量 */ ｚ＝ｘ＞ｙ？ｘ∶ｙ； return（ｚ）； 运行情况如下： １．５， ２．５↙ Max is ２　

8.４ 函数的调用 8.４.1 函数调用的一般形式 函数调用的一般形式为: 函数名（实参表列） 说明: （1）如果是调用无参函数，则“实参表列”可以没有，但括弧不能省略。

（2）如果实参表列包含多个实参，则各参数间用逗号隔开。实参与形参的个数应相等，类型应匹配。实参与形参按顺序对应，一一传递数据。 （3）如果实参表列包括多个实参，对实参求值的顺序并不是确定的，有的系统按自左至右顺序求实参的值，有的系统则按自右至左顺序。

例 8.4 实参求值的顺序 #include <stdio.h> void main() { int f(int a,int b); /* 函数声明 */ int i=2,p; p=f(i,++i); /* 函数调用 */ printf("%d\n",p); } 　

int f(int a,int b) /* 函数定义 */ { int c; if(a>b) c=1; else if(a==b) c=0; else c=-1; return(c); }　　 　

int i=2,p; p=f(i,++i); 对于函数调用 如果按自左至右顺序求实参的值，则函数调用相当于ｆ（２，３） 如果按自左至右顺序求实参的值，则函数调用相当于ｆ（3，３）

8.4.2 函数调用的方式 按函数在程序中出现的位置来分，可以有以下三种函数调用方式： １．函数语句 把函数调用作为一个语句。这时不要求函数带回值，只要求函数完成一定的操作。 ２．函数表达式 函数出现在一个表达式中，这种表达式称为函数表达式。这时要求函数带回一个确定的值以参加表达式的运算。例如:ｃ＝２*ｍａｘ（ａ，ｂ）；

３．函数参数 函数调用作为一个函数的实参。 例如: m = max (a , max ( b , c ) ) ; 其中max ( b , c )是一次函数调用，它的值作为max另一次调用的实参。m的值是a、b、c三者中的最大者。

在一个函数中调用另一函数（即被调用函数）需要具备哪些条件呢 ？ 8.4.3 对被调用函数的声明和函数原型 在一个函数中调用另一函数（即被调用函数）需要具备哪些条件呢 ？ 1.首先被调用的函数必须是已经存在的函数（是库函数或用户自己定义的函数）。但光有这一条件还不够。

2.如果使用库函数，还应该在本文件开头用#include 命令将调用有关库函数时所需用到的信息“包含”到本文件中来。 3.如果使用用户自己定义的函数，而该函数的位置在调用它的函数（即主调函数）的后面，应该在主调函数中对被调用的函数作声明。

函数原型的一般形式为: 1. 函数类型 函数名(参数类型1，参数类型2……)； 2. 函数类型 函数名(参数类型1，参数名1，参数类型2，参数名2……)； 声明的作用是把函数名、函数参数的个数和参数类型等信息通知编译系统，以便在遇到函数调用时，编译系统能正确识别函数并检查调用是否合法。

注意： 函数的“定义”和“声明”的区别： 函数的定义是指对函数功能的确立，包括指定函数名，函数值类型、形参及其类型、函数体等，它是一个完整的、独立的函数单位。 函数的声明的作用则是把函数的名字、函数类型以及形参的类型、个数和顺序通知编译系统，以便在调用该函数时系统按此进行对照检查。

例8.５ 对被调用的函数作声明 # include <stdio.h> void main（） ｛ float add（float x， float y）； ／*对被调用函数add的声明*／ float a，b，c； scanf（＂％f，％f＂，＆a，＆b）； c＝add（a，b）; printf（＂sum is ％f \n＂，c）； ｝ float add（float ｘ，float ｙ） ／*函数首部*／ ｛ float ｚ； /* 函数体 */ z＝ｘ＋ｙ； return（z）；

例8．５ 对被调用的函数作声明 # include <stdio.h> float add（float ｘ，float ｙ） ／*函数首部*／ ｛ float ｚ； /* 函数体 */ z＝ｘ＋ｙ； return（z）； ｝ void main（） ｛ float a，b，c； scanf（＂％f，％f＂，＆a，＆b）； c＝add（a，b）; printf（＂sum is ％f \n＂，c）；

8.５ 函数的嵌套调用 嵌套定义就是在定义一个函数时，其函数体内又包含另一个函数的完整定义 。

例 8.６ 用弦截法求方程 f(x)=x3-5x2+16x-80=0 的根

方法： 1. 取两个不同点x1,x2,如果f(x1)和f(x2)符号相反,则(x1,x2)区间内必有一个根。如果f(x1)与f(x2)同符号,则应改变x1,x2,直到f(x1)、f(x2)异号为止。注意x1、x2的值不应差太大,以保证(x1,x2)区间内只有一个根。 2. 连接(x1,f(x1))和(x2,f(x2))两点,此线(即弦)交x轴于x。

3. 若f(x)与f(x1)同符号,则根必在(x,x2)区间内,此时将x作为新的x1。如果f(x)与f(x2)同符号,则表示根在(x1,x)区间内,将x作为新的x2。

N-S流程图

实现各部分功能的几个函数: 1. 用函数f(x)代表x的函数:x3-5x2+16x-80。 2. 用函数调用xpoint (x1,x2)来求(x1,f(x1))和 (x2,f(x2))的连线与x轴的交点x的坐标。 3. 用函数调用root (x1,x2)来求(x1,x2)区间的 那个实根。显然,执行root函数过程中要用到函 数xpoint,而执行xpoint函数过程中要用 到f函数。

＃include <stdio．ｈ> ＃include <math．ｈ> float f(float x) ／* 定义ｆ函数，以实现f(x) ＝x3-5x2+16x-80 *／ ｛ float ｙ； ｙ=((ｘ-５.０)*ｘ+１６.０)*ｘ-８０.０； return（ｙ）； ｝

float xpoint (float x1，float x2) ／*定义xpoint函数，求出弦与x轴交点 */｛ float ｙ； ｙ=（ｘ１*ｆ(ｘ２)-ｘ２*ｆ(ｘ１)) ／ｆ(ｘ２)-ｆ(ｘ１))； return (ｙ)； ｝

float root（float ｘ１，float ｘ２） ｙ１＝ｆ（ｘ１）； do ｛ ｘ＝xpoint（ｘ１，ｘ２）； ｙ＝ｆ（ｘ）； 　if（ｙ*ｙ１＞０） /*ｆ(ｘ)与ｆ(ｘ１)同符号 */ 　 ｛ ｙ１＝ｙ； 　 ｘ１＝ｘ；｝ 　 ｅｌｓｅ ｘ２＝ｘ； } while（fabs（ｙ）＞＝0.0001）； return（ｘ ｝

运行情况如下： input ｘ１，ｘ２： ２，６ void main（） ／*主函数 */ ｛float ｘ１，ｘ２，ｆ１，ｆ２，ｘ； do ｛printf（＂ｉｎｐｕｔ ｘ１，ｘ２：＼ｎ＂）； scanf（＂％ｆ，％ｆ＂，＆ｘ１，＆ｘ２）； ｆ１＝ｆ（ｘ１）； ｆ２＝ｆ（ｘ２）； ｝while（ｆ１*ｆ２＞＝０）； ｘ＝ｒｏｏｔ（ｘ１，ｘ２）； printf(＂Ａ root of equation is ％８.４ｆ\n＂，ｘ)； ｝ 运行情况如下： input ｘ１，ｘ２： ２，６ Ａ root of equation is 5.0000

8.6 函数的递归调用 在调用一个函数的过程中又出现直接或间接地调用该函数本身，称为函数的递归调用。Ｃ语言的特点之一就在于允许函数的递归调用。 例如： int f ( int ｘ) ｛ ｉｎｔ ｙ，ｚ； ｚ＝ｆ（ｙ）； return（２*ｚ）； ｝

例 8.7: 有５个人坐在一起，问第５个人多少岁？他说比第４个人大２岁。问第４个人岁数，他说比第３个人大２岁。问第３个人，又说比第２个人大２岁。问第２个人，说比第１个人大２岁。最后问第１个人，他说是１０岁。请问第５个人多大。 age（5）= age （4）+2 age（4）= age （3）+2 age（3）= age （2）+2 age（2）= age （1）+2 age（1）= 10 用数学公式表述如下： age（n）= 10 （ｎ＝１） age（n-1）+2 （ｎ>１）

１８ 可以用一个函数来描述上述递归过程： int age（int ｎ） ／*求年龄的递归函数*／ if（ｎ＝＝１） ｃ＝１０； else ｃ＝ａｇｅ（ｎ－１）＋２； return（ｃ）； ｝ 运行结果如下： １８ 用一个主函数调用age函数，求得第5人的年龄。 #include <stdio.h> void main（） ｛ printf（″％ｄ″，age（５））； ｝

例8.８用递归方法求ｎ！ 求ｎ！也可以用递归方法，即５！等于４！×５，而４！＝３！×４…１！＝１。 可用下面的递归公式表示： ｎ！＝１ （ｎ＝０，１） ｎ·（ｎ－１）！ （ｎ＞１）

例8.9 Hanoi（汉诺塔）问题:

由上面的分析可知：将ｎ个盘子从Ａ座移到Ｃ座可以分解为以下3个步骤： 1.将Ａ上ｎ－１个盘借助Ｃ座先移到Ｂ座上。 2.把Ａ座上剩下的一个盘移到Ｃ座上。 3.将ｎ－１个盘从Ｂ座借助于Ａ座移到Ｃ座上。

程序如下： #include <stdio.h> void main() { void hanoi(int n,char one,char two,char three); /* 对hanoi函数的声明 */ int m; printf("input the number of diskes:"); scanf(“%d”,&m); printf("The step to moveing %d diskes:\n",m); hanoi(m,'A','B','C'); }

void hanoi(int n,char one,char two,char three) /* 定义hanoi函数,将ｎ个盘从one座借助two座，移到three座 */ { void move(char x,char y); /* 对move函数的声明 */ if(n==1) move(one,three); else { hanoi(n-1,one,three,two); move(one,three); hanoi(n-1,two,one,three); } } void move(char x,char y) /* 定义move函数 */ printf(“%c-->%c\n",x,y);

运行情况如下： input the number of diskes:3↙ The steps to noving 3 diskes: Ａ－－＞Ｃ Ａ－－＞Ｂ Ｃ－－＞Ｂ Ｂ－－＞Ａ Ｂ－－＞Ｃ

8.７数组作为函数参数 8.7.1 数组元素作函数实参 由于实参可以是表达式，而数组元素可以是表达式的组成部分，因此数组元素可以作为函数的实参，与用变量作实参一样，是单向传递，即“值传送”方式。

例 8.10 有两个数组ａ和ｂ，各有１０个元素，将它们对应地逐个相比（即ａ［０］与ｂ［０］比，ａ［１］与ｂ［１］比……）。如果ａ数组中的元素大于ｂ数组中的相应元素的数目多于b数组中元素大于a数组中相应元素的数目(例如，a［i］>b［i］6次，b［i］>a［i］3次，其中i每次为不同的值)，则认为a数组大于b数组，并分别统计出两个数组相应元素大于、等于、小于的次数。

#include <stdio.h> void main（） ｛ int large(int x，int y)； /* 函数声明 */ int ａ[10],ｂ[10],ｉ，ｎ＝０，ｍ＝０，ｋ＝０； printf（″enter array a∶＼ｎ″）； for（ｉ＝０；ｉ＜１０；ｉ＋＋＝) scanf（″％ｄ″，＆ａ［ｉ］）； printf（″＼ｎ″）； printf（″ enter arrayｂ∶＼ｎ″）； scanf （″％ｄ″，＆ｂ［ｉ］）； for（ｉ＝０；ｉ＜１０；ｉ＋＋） { if（large (ａ[i],ｂ[i] )== １） ｎ＝ｎ＋１； 　 else if（ large (ａ[i],ｂ[i] )==０） ｍ=ｍ+１； else ｋ＝ｋ＋１；}

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 larger than array b＼n"); else if (n<k) printf("array a is smaller than array b\n"); 　else printf("array ａ is equal to array b＼n"); ｝ large（int ｘ，int ｙ） { int ｆｌａｇ； if（ｘ＞ｙ）ｆｌａｇ＝１； 　else if（ｘ＜ｙ）flag＝－１； 　　else flag＝０； return（flag）；

运行情况如下： enter array a： １ ３ ５ ７ ９ ８ ６ ４ ２ ０↙ ｅｎｔｅｒ ａｒｒａｙ ｂ∶ 5 3 8 9 –1 –3 5 6 0 4↙ ａ［ｉ］＞ｂ［ｉ］ ４ ｔｉｍｅｓ ａ［ｉ］＝ｂ［ｉ］ １ ｔｉｍｅｓ ａ［ｉ］＜ｂ［ｉ］ ５ ｔｉｍｅｓ array a is smaller thann array b

8.7.2 数组名作函数参数 例8.11 用数组名作函数参数时，此时形参应当用数组名或用指针变量 。 有一个一维数组score，内放10个学生成绩，求平均成绩。

#include <stdio.h> void main（） ｛ float average（float array［10］）; /* 函数声明 */ float score[10] , aver； 　 int ｉ； 　 printf（″input １０ scores：＼ｎ″）； 　 for（ｉ＝０；ｉ＜１０；ｉ＋＋＝ scanf（″％ｆ″，＆score［ｉ］）； 　 printf（″＼ｎ″）； 　 aver＝average（ score ）； 　 printf （″ average score is ％５.２ｆ\n″, aver）； ｝　

float average （float array［10］） ｛ int ｉ； float aver，ｓｕｍ＝ａｒｒａｙ［０］； 　 for (ｉ＝１；ｉ＜１０；ｉ＋＋＝) 　ｓｕｍ＝ｓｕｍ＋ａｒｒａｙ［ｉ］； 　ａｖｅｒ＝ｓｕｍ／１０； 　return（aver）； ｝ 运行情况如下： input １０ scores： １００ ５６ ７８ ９８.5 ７６ ８７ ９９ ６７.5 ７５ ９７↙ average score is 83.40

例 8.１２形参数组不定义长度 #include <stdio.h> void main（） ｛ float average（float ａｒｒａｙ［ ］，int ｎ） float score_1[5] ＝{９８．５，９７，９ １.５，６０，５５}； float score_2［10］={ 67.5，89.5，99，6９.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)); ｝

float average（float ａｒｒａｙ［ ］，int ｎ） 　 for（ｉ＝１；ｉ＜ｎ；ｉ＋＋＝ sum＝sum＋array［ｉ］； 　 aver＝sum／ｎ； 　 return（ａｖｅｒ）； ｝ 运行结果如下： the average of class A is 80.40 The average of class Ｂ is 78.20

例 8.13 用选择法对数组中10个整数按由小到大排序。 所谓选择法就是先将10个数中最小的数与a［0］对换;再将a［1］到a［9］中最小的数与a［1］对换……每比较一轮,找出一个未经排序的数中最小的一个。共比较9轮。

未排序时的情况: a[0] a[1] a[2] a[3] a[4] 3 6 1 9 4 将5个数中最小的数1与a［0］对换: 1 6 3 9 4 将余下的4个数中最小的数3与a［1］对换 1 3 6 9 4 将余下的3个数中最小的数4与a［2］对换 1 3 4 9 6 将余下的2个数中最小的数6与a［3］对换 1 3 4 6 9

程序： #include <stdio.h> void main（） ｛ void sort（int ａｒｒａｙ［］，int ｎ）; int ａ［１０］，ｉ； printf（″enter the array＼ｎ″）； for（ｉ＝０；ｉ＜１０；ｉ＋＋＝ 　 scanf（″％ｄ″，＆ａ［ｉ］）； sort（ａ，１０）； printf（″the sorted array∶＼ｎ″）； 　　 printf（″％ｄ″，ａ［ｉ］）； 　 printf（″＼ｎ″）； 　 ｝　

void sort（int array［］，int ｎ）/*排序函数*/ for（ｉ＝０；ｉ＜ｎ－１；ｉ＋＋） 　　｛ ｋ＝ｉ； 　　　　 for（ｊ＝ｉ＋１；ｊ＜ｎ；ｊ＋＋） 　　　if（array[ｊ] ＜ array[ｋ]=ｋ=ｊ； 　　　　 ｔ=array[k]； array[k]=array[i];array[i]=t ｝

#include <stdio.h> void main（） ｛ max_value ( int ａｒｒａｙ［ ］［4］); 8.7.3. 多维数组名作函数参数 用多维数组名作为函数实参和形参。在被调函数中对形参数组定义时可以指定每一维的大小 。 程序： #include <stdio.h> void main（） ｛ max_value ( int ａｒｒａｙ［ ］［4］); int [3][4]={{1,3,5,7},{2,4,6,8},{15,17,34,12}}； printf（″max value is ％ｄ＼ｎ″， max_value(a) ）； ｝　　

Max value is 34 max_value （ int array［ ］［4］） ｛ int ｉ，ｊ，ｋ，max； 　 for（ｉ=０；ｉ＜３；ｉ＋＋） 　for（ｊ＝０；ｊ＜４；ｊ＋＋＝ 　　　if（array［ｉ］［ｊ］＞ｍａｘ） max= array ［ｉ］［ｊ］； return（max）； ｝ 　　 运行结果如下： Max value is 34

8.8局部变量和全局变量 8.8.1局部变量 内部变量：在一个函数内部定义的变量称内部变量。它只在本函数范围内有效，即：只有在本函数内才能使用这些变量，故称为“局部变量” 。

例： float f1( int a) /*函数f1 */ {int b,c; … /* a、b、c有效*/ } char f2(int x,int y) /*函数f2 */ {int i,j; /* x、y、i、j有效*/ void main( ) /*主函数*/ {int m,n; … /* m、n有效*/ } 　　

主函数中定义的变量只在主函数中有效,而不因为在主函数中定义而在整个文件或程序中有效。主函数也不能使用其他函数中定义的变量。 (2) 不同函数中可以使用相同名字的变量,它们代表不同的对象,互不干扰。 (3) 形式参数也是局部变量。 (4) 在一个函数内部,可以在复合语句中定义变量,这些变量只在本复合语句中有效,这种复合语句也称为“分程序”或“程序块”。

void main ( ) {int a,b; … {int c; c=a+b; c在此范围内有效 a,b在此范围内有效 } } 　

8.8.2 全局变量 外部变量：函数之外定义的变量称为外部变量。外部变量可以为本文件中其他函数所共用。它的有效范围为从定义变量的位置开始到本源文件结束。所以也称全程变量。

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

例8.15 有一个一维数组，内放１０个学生成绩 ，写一个函数，求出平均分、最高分和最低分。 #include <stdio.h> float Max＝０，Min＝０； ／*全局变量*／ void main（） ｛ float average（float array［ ］，int n）; float ave，score[10]； int ｉ； 　 for（ｉ＝０；ｉ＜１０；ｉ＋＋） 　 scanf（″％ｆ″，＆ｓｃｏｒｅ［ｉ］）； ave= average（ｓｃｏｒｅ，１０）； 　 printf(“max=%6.2f＼nmin=%6.2f＼n average=%6.2f＼n“，Max，Min，ave)； }

float average（float array［ ］，int n） ／* 定义函数，形参为数组 */ ｛ int ｉ； float aver，sum=array［０］； Max=Min=array［０］； for（ｉ=１；ｉ＜ｎ；ｉ＋＋） ｛ if（array［ｉ］＞Max）Max＝array［ｉ］； 　 else if（array［ｉ］＜Min）Min＝ array［ｉ］； 　sum=sum+array［ｉ］； 　 ｝ aver＝ｓｕｍ／ｎ； return（ａｖｅｒ）； ｝ 运行情况如下： ９９ ４５ ７８ ９７ １００ ６７．５ ８９ ９２ ６６ ４３↙ ｍａｘ＝１００．００ ｍｉｎ＝４３．００ ａｖｅｒａｇｅ＝７７．６５

建议：不必要时不要使用全局变量，原因如下： ① 全局变量在程序的全部执行过程中都占用存储单元，而不是仅在需要时才开辟单元。 ② 使用全局变量过多，会降低程序的清晰性。在各个函数执行时都可能改变外部变量的值，程序容易出错。因此，要限制使用全局变量。

③降低函数的通用性。因为函数在执行时要依赖于其所在的外部变量。如果将一个函数移到另一个文件中，还要将有关的外部变量及其值一起移过去。但若该外部变量与其他文件的变量同名时，就会出现问题，降低了程序的可靠性和通用性。一般要求把Ｃ程序中的函数做成一个封闭体，除了可以通过“实参——形参”的渠道与外界发生联系外，没有其他渠道。

例 8.１6 外部变量与局部变量同名 #include <stdio.h> int a=3,b=5; /* a,b为外部变量*/ a,b作用范围 void main ( ) { int a=8; /*a为局部变量 */ 局部变量a作用范围 printf (″%d″, max (a,b)); 全局变量b的作用范围 } max (int a, int b) /*a,b为局部变量 */ { int c; c=a＞b?a∶b; 形参a、b作用范围 return (c); 运行结果为 8

8.９ 变量的存储类别 8.9.1 动态存储方式与静态存储方式 从变量的作用域（即从空间）角度来分，可以分为全局变量和局部变量。 从变量值存在的时间角度来分，又可以分为静态存储方式和动态存储方式。 静态存储方式：指在程序运行期间由系统分配固定的存储空间的方式。 动态存储方式：则是在程序运行期间根据需要进行动态的分配存储空间的方式。这个存储空间可以分为三部分：1.程序区 2.静态存储区 3.动态存储区

变量和函数有两个属性：数据类型和数据的存储类别。存储类别指的是数据在内存中存储的方式。 存储方式分为两大类：静态存储类和动态存储类。包含： 自动的（auto）； 静态的（static）； 寄存器的（register）； 外部的（extern）。 根据变量的存储类别，可以知道变量的作用域和生存期。

8.9.2 auto变量 自动变量auto：不专门声明为static存储类别的局部变量都是动态分配存储空间，在调用该函数时系统会给它们分配存储空间，在函数调用结束时就自动释放这些存储空间。因此这类局部变量称为自动变量。 函数中的形参和在函数中定义的变量(包括在复合语句中定义的变量)，都属此类。 自动变量用关键字auto作存储类别的声明。 例如： int ｆ（int ａ） ／*定义f函数，ａ为形参 *／ ｛auto int ｂ，ｃ＝３；/*定义ｂ、ｃ为自动变量 *／ 　… ｝

8.9.3 用static声明局部变量 当函数中的局部变量的值在函数调用结束后不消失而保留原值时，该变量称为静态局部变量。用关键字static进行声明。

例8．１7 考察静态局部变量的值 #include <stdio.h> void main（） ｛int ｆ（int）; int ａ＝２，ｉ； for（ｉ＝０；ｉ＜３；ｉ＋＋＝ printf（″％ｄ ″，ｆ（ａ））； 　｝ int ｆ（int ａ） ｛auto int ｂ＝０； static ｃ＝３； ｂ＝ｂ＋１； 　ｃ＝ｃ＋１； return（ａ＋ｂ＋ｃ）； 　 ｝

对静态局部变量的说明： （1） 静态局部变量属于静态存储类别，在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量（即动态局部变量）属于动态存储类别，占动态存储区空间而不占静态存储区空间，函数调用结束后即释放。 （2）对静态局部变量是在编译时赋初值的，即只赋初值一次，在程序运行时它已有初值。以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的值。

（3）如在定义局部变量时不赋初值的话，则对静态局部变量来说，编译时自动赋初值０（对数值型变量）或空字符（对字符变量）。而对自动变量来说，如果不赋初值则它的值是一个不确定的值。 （4）虽然静态局部变量在函数调用结束后仍然存在，但其他函数不能引用它。

例8．１8 输出１到５的阶乘值 #include <stdio.h> void main（） ｛int fac（int ｎ）; int ｉ； for（ｉ＝１；ｉ＜＝５；ｉ＋＋） printf（″%ｄ！=％ｄ＼ｎ″,ｉ,fac（ｉ））； ｝ Int fac（int ｎ） ｛static int ｆ＝１； ｆ＝ｆ*ｎ； return（ｆ）；

8.9.4 register变量 变量的值是存放在内存中的。当程序中用到哪一个变量的值时，由控制器发出指令将内存中该变量的值送到运算器中。 经过运算器进行运算，如果需要存数，再从运算器将数据送到内存存放。

如果有一些变量使用频繁，则为存取变量的值要花费不少时间。为提高执行效率，Ｃ语言允许将局部变量的值放在CPU中的寄存器中，需要用时直接从寄存器取出参加运算，不必再到内存中去存取。由于对寄存器的存取速度远高于对内存的存取速度，因此这样做可以提高执行效率。这种变量叫做寄存器变量，用关键字register作声明。

例8．19使用寄存器变量 #include <stdio.h> void main ( ) {long fac(long); long i,n; scanf("%ld",&n); for(i=1;i<=n;i++) printf("%ld!=%ld\n",i,fac(i)); } long fac(long n) {register long i,f=1; /*定义寄存器变量*/ for (i=1;i<=n;i++) f=f*i; return (f);

8.9.5 用extern声明外部变量 外部变量是在函数的外部定义的全局变量，它的作用域是从变量的定义处开始，到本程序文件的末尾。在此作用域内，全局变量可以为程序中各个函数所引用。编译时将外部变量分配在静态存储区。用extern来声明外部变量，以扩展外部变量的作用城。

1. 在一个文件内声明外部变量 例8．20 用extern声明外部变量，扩展它在程序文件中的作用域 #include <stdio.h> void main() { int max(int,int); ／*外部变量声明*／ extern A,B; printf("%d\n",max(A,B)); } int A=13,B=-8; ／*定义外部变量*／ int max(int x,int y) ／*定义ｍａｘ函数 *／ { int z; z=x>y?x:y; return(z);

2. 在多文件的程序中声明外部变量 例8.２１ 用extern将外部变量的作用域扩展到其他文件。本程序的作用是给定ｂ的值，输入ａ和ｍ，求ａ×ｂ和am的值。文件file１.ｃ中的内容为： #include <stdio.h> int A; /*定义外部变量*/ void main() ｛int ｐｏｗｅｒ（int）； /*函数声明*/ int ｂ＝３，ｃ，ｄ，ｍ； printf（″enter the number a and its power m:\n″）； scanf（″％ｄ，％ｄ″，＆A，＆ｍ）； ｃ＝A*ｂ； printf（″％ｄ*％ｄ＝％ｄ＼ｎ″，A，ｂ，ｃ）； ｄ＝ｐｏｗｅｒ（ｍ）； printf（″％ｄ**％ｄ＝％ｄ\n″，A，ｍ，ｄ）； ｝

文件file２．ｃ中的内容为： extern A； /*声明A为一个已定义的外部变量*/ int powre（int ｎ）; ｛int ｉ，ｙ＝１； for（ｉ＝１；ｉ＜＝ｎ；ｉ＋＋） ｙ*＝A； return（ｙ）； ｝

8.9.6 用static声明外部变量 在程序设计中,某些外部变量只限于被本文件引用，而不能被其他文件引用。这时可以在定义外部变量时加一个staitic声明。 例如： file1.c file2.c static int A; extern int A; void main ( ) void fun (int n) { {… … A=A*n; }

8.9.7 关于变量的声明和定义 定义性声明:需要建立存储空间的(如：int a; )声明。 8.9.7 关于变量的声明和定义 定义性声明:需要建立存储空间的(如：int a; )声明。 引用性声明:不需建立存储空间的声明（extern a；)。 注意： 声明包括定义，但并非所有的声明都是定义。对“int a;” 而言，它既是声明，又是定义。而对“extern a;” 而言，它是声明而不是定义。

8.９.8 存储类别小结 从作用域角度分，有局部变量和全局变量。它们采用的存储类别如下： 局部变量包括： 自动变量、 静态局部变量、寄存器变量。 形式参数可以定义为自动变量或寄存器变量。 全局变量包括： 静态外部变量、外部变量。

（2）从变量存在的时间来区分，有动态存储和静态存储两种类型。静态存储是程序整个运行时间都存在，而动态存储则是在调用函数时临时分配单元。 动态存储 ：自动变量、寄存器变量、形式参数。 静态存储：态局部变量、静态外部变量 、外部变量。

(3) 从变量值存放的位置来区分,可分为： 内存中静态存储区：静态局部变量、静态外部变量、 外部变量。 内存中动态存储区：自动变量和形式参数。 CPU中的寄存器：寄存器变量。

(4) static对局部变量和全局变量的作用不同。对局部变量来说,它使变量由动态存储方式改变为静态存储方式。而对全局变量来说,它使变量局部化，但仍为静态存储方式。从作用域角度看,凡有static声明的，其作用域都是局限的，或者是局限于本函数内，或者局限于本文件内。

8.10 内部函数和外部函数 8.10.1内部函数 根据函数能否被其他源文件调用,将函数区分为内部函数和外部函数。 如果一个函数只能被本文件中其他函数所调用,它称为内部函数。在定义内部函数时,在函数名和函数类型的前面加static。即 static 类型标识符 函数名(形参表) 例如: static int fun ( int a , int b )

8.10.2 外部函数 (1) 定义函数时,如果在函数首部的最左端加关键字extern,则表示此函数是外部函数，可供其他文件调用。例如，函数首部可以写为extern int fun (int a, int b)，这样，函数fun就可以为其他文件调用。如果在定义函数时省略extern,则隐含为外部函数。 (2) 在需要调用此函数的文件中,用extern对函数作声明，表示该函数是在其他文件中定义的外部函数 。

例 8.22 有一个若干字符的字符串,今输入一个字符,要求程序将字符串中该字符删去。用外部函数实现。 File.c（文件１） #include <stdio.h> void main() { extern void enter_string(char str[]); extern void detele_string(char str[],char ch); extern void print_string(char str[]);／*以上3行声明在本函数中将要调用的在其他文件中定义的3个函数*／ char c; char str[80]; scanf("%c",&c); detele_string(str,c); print_string(str); }

file２．ｃ（文件２） #include <stdio.h> void enter_string(char str[80]) ／* 定义外部函数 enter-string*／ { gets(str); ／*向字符数组输入字符串*／ }　 file３．ｃ（文件３） void delete_string(char str[],char ch) ／*定义外部函数 delete_string *／ { int i,j; for(i=j=0;str[i]!='\0';i++) if(str[i]!=ch) str[j++]=str[i]; str[i]='\0'; }

#include <stdio.h> void print_string(char str[]) { file４．ｃ（文件４） #include <stdio.h> void print_string(char str[]) { printf("%s\n",str); }　 运行情况如下： ａｂｃｄｅｆｇｃ↙ (输入ｓｔｒ） 　　ｃ↙  （输入要删去的字符） ａｂｄｅｆｇ （输出已删去指定字符的字符串）