哈理工C++课件cpp7.ppt

1、,第7章 函数（二）,函数（二）,函数的参数传递,函数与指针,变量的作用域、生存期和存储,内联函数,函数重载,带有缺省参数值的函数,名字空间,函数的参数传递,函数通常是实现一个具体的功能的模块，因此函数必然要与程序中其它的模块进行信息交换。函数可以从函数之外获得所需数据，也可以将处理的结果返回函数的调用者。这些数据交换主要是通过函数的参数和返回值传递实现的。 在C+中实参和形参有三种结合方式: (1)值传递 (2)地址传递 (3)引用传递 其中地址传递也可以看作一种“特殊”的值传递。三种传递方式各具特色，在程序设计中发挥不同的作用。,一般值传递,实参与形参值传递是单向的传递，调用时实参仅将其值

2、赋给形参，因此在被调用函数中，对形参值的任何修改都不会影响到实参的值。参数值传递减少了调用函数和被调用函数之间的数据依赖，增强了函数自身的独立性。下面先回过头来看看本书第四章的一个实例。,一般值传递,【例7.1】交换两个变量的值。 / 7-1.cpp #include void swap(int x,int y) int t=x; x=y; y=t; cout函数内交换成功：x=x,y=yendl; void main() int a(2),b(3); swap(a,b); cout主函数交换失败：a=a,b=bendl; ,函数内交换成功：x=3,y=2 主函数交换失败：a=2,b=3,一般

3、值传递,当实参的值传递给形参时，形参拥有独立的地址，存储的是实参值的一个备份，在被调用函数中改变形参中的值时，改变的是这个备份中的值，实参的值不受影响。这是因为，当函数被调用时，函数的形参被分配了相应存储单元，在函数运行过程中，对形参的改变只发生在相应存储单元上。值传递方法实参不受影响，使函数之间的独立性增强。再看下面的实例。,一般值传递,【例7.2】用一个函数计算圆的周长和面积。 / 7-2.cpp #include using namespace std; #define PI 3.14159 void CircleFun(double radius, double perim, doub

4、le area) perim = 2 * PI * radius; area = PI * radius * radius; coutperim=perim, area=areaendl; int main() double p=0, a=0; CircleFun(10, p, a); cout圆的周长=p, 面积=aendl; return 0; ,perim=62.8318, area=314.159 圆的周长=0, 面积=0,一般值传递,程序中#include命令包含的文件省去了扩展名，并使用了名字空间std，这样可以使用C+标准库。 标准C+库中的所有组件都是在一个被称为std的名字空

5、间中声明和定义的。使用名字空间，可以解决命名冲突问题。关于名字空间的更多内容将在7.7中详细阐述。,地址传递,地址传递是一种“特殊”的值传递，在被调用函数的形参设定为指针类型，实参与形参之间传递的是“特殊”的值地址。实参传递给形参的是在调用函数中有实际意义的地址，形参变量接受了的地址值，当在函数中形参变量所指向的存储空间中的值发生了改变，那么这些改变发生在内存中统一的地址空间中，改变将被带回调用函数中。,地址传递,【例7.3】地址传递方式交换数据。 / 7-3.cpp #include using namespace std; void swap(int *x,int *y) int t=*x

6、; *x=*y; *y=t; int main() int a(2),b(3); swap( ,a=3, b=2,地址传递,程序中定义的函数swap(int* x,int* y)的两个形参x和y是指针变量，其功能是交换x和y所指向的两个变量的值。 实参是两个变量a和b的地址 #define PI 3.14159 void CircleFun(double radius, double *pPerim, double *pArea) *pPerim = 2 * PI * radius; *pArea = PI * radius * radius; int main() double p=0, a

7、=0; CircleFun(10, ,圆的周长=62.8318, 面积=314.159,引用参数传递,在C+中还可以采用引用传递方式，即函数的参数为引用。与引用变量方式相比，函数参数引用传递方式在说明引用参数时，不需提供初始值，其初始值在函数调用时由实参提供. 引用传递既有值传递方式使用方便的优点，又有地址传递方式更新实参的长处，引用传递有不同于前两种参数传递方式。在下面的例题中充分展示引用传递的优点。,引用参数传递,【例7.5】引用传递方式交换数据。 / 7-5.cpp #include using namespace std; void swap(int ,a=3, b=2,引用参数传递,

8、【例7.6】引用传递方式计算圆的周长和面积。 / 7-6.cpp #include using namespace std; #define PI 3.14159 void CircleFun(double const ,圆的周长=62.8318, 面积=314.159,返回引用的函数,函数可以返回一个引用，将函数说明为返回一个引用的主要目的是为了将该函数用在赋值运算符的左边，对被调用函数的返回值。,返回引用的函数,【例7.7】猴子吃桃问题。 / 7-7.cpp #include using namespace std; int ,1 4 10 22 46 94 190 382 766 153

9、4 猴子第 1 天摘下 1534 个桃子,返回引用的函数,程序中定义的函数add1的形参ref是引用，其功能是使引用的变量增1，函数的返回值是ref引用的变量的引用。当程序运行到add1函数时，用主调函数中的变量peach初始化引用类型的形参ref。add1函数内，ref增1，实际是主调函数中的peach增1。add1函数的返回值是peach的引用。程序返回到主调函数后，对add1函数的调用进行乘复合赋值运算，实际是对peach进行的运算。通过以上的分析，可以看出，增1和乘2都是对peach进行的。 在定义返回引用的函数时，注意不要返回函数的非引用类型形参的引用，也不要返回函数内定义的变量的引

10、用。因为函数的形参和函数内定义的变量在函数调用结束后就结束它们的生存期，释放存储空间。所返回的引用也就成了无效的引用。,数组名作函数参数,形参与实参都应使用数组名，分别在被调函数和主调函数中说明数组类型，并且要求形参和实参数组的类型相同、维数相同。,数组名作函数参数,【例7.8】用函数输出数组元素值。 / 7-8.cpp #include using namespace std; void output(double b, int n) cout sizeof b = sizeof b endl; for (int i=0; in; i+) cout bi ; cout endl; int m

11、ain() double a = 1.23,2.34,3.45,4.56,5.67; int n = sizeof a/sizeof a0; cout sizeof a = sizeof a endl; output(a, n); return 0; ,sizeof a = 40 sizeof b = 4 1.23 2.34 3.45 4.56 5.67,数组名作函数参数,实参数组定义时，没有指定大小，编译系统根据数组初始化值得个数确定大小；形参数组也没有指定大小，编译器对形参数组大小不作检查，只是将实参数组的首地址传给形参数组。 从程序的运行结果可以看出，实参数组a是一个实在的数组，5个元素

12、，每个元素占8个字节，共占40个字节；形参数组b虽然形式上像一个数组，实际上不是真实的数组，是指针变量，只占4个字节，保存的是数组a的首地址，而不是数组元素。,数组名作函数参数,【例7.9】十进制整数转换为二进制、八进制和十六进制。 #include using namespace std; void transform(unsigned val,int r,char s) int d, n=0, i; / 将val转换为r进制，结果以字符形式保存在s中。 do d = val % r;/ 除r取余(除2取余,除8取余,除16取余) val /= r; if (d 0,1=1,.9=9 els

13、esn+ = d + A - 10;/ A(10),B(11),.F(15) while (0!=val); if (16=r)sn+ = x;/ 十六进制0 x开头 if (8=r | 16=r) sn+ = 0;/ 八进制0开头 sn = 0;/ 字符串以0结束 for (i=0,n-; in; i+,n-) / 前后倒置 si = (sn+=si)-si; sn -= si; ,数组名作函数参数,int main() int n; char str36; cout n; transform(n, 2,str); cout 二 进 制：strendl; transform(n, 8,str

14、); cout 八 进 制：strendl; transform(n,16,str); cout十六进制：strendl; return 0; ,输入一个整数：-1 二 进 制：11111111111111111111111111111111 八 进 制：037777777777 十六进制：0 xFFFFFFFF,数组名作函数参数,【例7.10】用函数实现二维数组转置。 / 7-9.cpp #include using namespace std; #define N 4 void Transpose(int bNN) int i,j,t; for (i=0; iN-1; i+) for (j

15、=i+1; jN; j+) t=bij; bij=bji; bji=t; ,数组名作函数参数,void output(int bNN) int i,j; for (i=0; iN; i+) for (j=0; jN; j+) cout bij ; cout endl; cout endl; int main() int aNN = 1,2,3,4,5,6,7,8,9; output(a); Transpose(a); output(a); return 0; ,1 2 3 4 5 6 0 0 7 8 9 0 0 0 0 0 1 5 7 0 2 6 8 0 3 0 9 0 4 0 0 0,案例：

16、在不同函数中共享数据,问题描述 设计一个函数完成计算了数组指定范围内元素的和，查询数组指定范围内元素的最大值位置。 要点解析 数组元素需要在主函数和被调函数中共享，函数实现了计算了数组指定范围内元素的和，查询数组指定范围内元素的最大值位置的功能。求得的结果无法通过函数的返回值带回到主函数。可以通过设计函数形参的类型，将一部分结果带回主函数。,指针函数,指针函数是指函数的返回值为指针的函数。指针可以作为函数的参数，函数的返回值也可以是指针类型的数据。指针函数的定义形式为： 数据类型标识符 *函数名(形参表) 函数体 例如： int *fun(int) 函数fun()是一个指针函数，返回值为一个整

17、型的指针，这就要求在函数体中要有返回指针或地址的语句，如： return(,指针函数,【例7.11】指针函数示例多行文本存储。 / 7-11.cpp #include #include char *creatline(char *c) char *p; int l; l=strlen(c); p = new charl+1; strcpy(p,c); return p; ,指针函数,int main() char *ch_p; int n; coutn;/ 输入文本行数 ch_p = new char *n;/ 建立指向字符串的指针数组 char ctemp255; cin.ignore(25

18、5,n);/ 跳过输入缓冲区内的无用的字符。 for(int i=0;in;i+) cout输入第i+1行文本:endl; cin.getline(ctemp, sizeof ctemp);/ 输入一行文本 ch_pi = creatline(ctemp); for(i=0;in;i+) cout第i+1行文本:ch_piendl; for(i=0;in;i+) delete ch_pi; delete ch_p； return 0; ,指向函数的指针,函数本身作为一段程序，在内存中也占有一定得存储空间，并有一个入口地址，称为函数首地址。调用函数时，就是让程序转移到函数的首地址开始执行。这个地

19、址就是函数的指针，可以用一个指针变量来存放函数的指针，该指针变量指向这个函数，称该指针变量为指向函数的指针变量，简称为函数的指针变量或函数指针。 指向函数的指针变量的定义格式为： 函数返回值类型说明符 (*指针变量名) (参数说名表)； 其中函数返回值类型说明符是指针变量所指向函数的类型，参数表示所指向函数的形式参数表，在说明指向函数的指针时，同时也要描述这个指针所指向的函数的参数类型和个数，以及函数的返回类型。应注意“*指针变量名”外的括号不能缺少，否则是在说明指针函数。下面的例子将函数说明和指向函数的指针的说明作了比较：,指向函数的指针,int fun_a(int a, int b); /

20、* 说明函数fun_a，带有两个整型形参a、b，返回值为整型 */ int *fun_b(int a, int b); /* 说明函数fun_b，带有两个整型形参a、b，返回值为整型指针 */ int (*fun_p)(int a, int b); /* 说明fun_p为指向带有两个整型形参，返回值为整型数的函数指针 */,指向函数的指针,在这个说明中，括起* fun_p的圆括号是必须的，fun_p被解释为一个指针，它指向带有两个整型参数的函数，函数返回类型为整型数。可以将一个函数原型与fun_p所指向的函数原型一样的函数的地址置给fun_p，例如，将函数 fun_a的地址置给指针变量fun_

21、p。在C+中，单独的一个函数名（其后不跟一对圆括号）被自动地转换为指向该函数的指针（函数的首地址）。当函数的地址被置入一个指针变量中时，可以通过该指针变量调用该函数。 例如： fun_p fun_a; result = (* fun_p)(5, 10); 也可以写成： result = fun_p(5, 10); 下面是一个使用指向函数的指针的例子，它简单地演示了通过指针变量调用函数的情况。,指向函数的指针,【例7.12】输出由“*”号组成的曲线。 / 7-12.cpp #include #include using namespace std; double para(double x) r

22、eturn 0.99-x*x*0.2; ,指向函数的指针,void draw(double (*pfun)(double) / 函数指针pfun指向sin、cos或para const double PI=3.14159; int angle,n; for (angle=-180; angle0;n-) cout ; cout * endl; ,指向函数的指针,int main() int item=1; while (item) cout item; switch(item) case 1 : draw(sin); break; case 2 : draw(cos); break; case

23、 3 : draw(para); break; return 0; ,1.正弦曲线；2.余弦曲线；3.抛物线；0.退出。 请选择：2 * * * * * *（这里给出的是输出结果的一小部分）,内联函数,使用函数为模块化为程序设计带来诸多优势，但是在调用函数时，系统要执行如断点现场保护、数据进栈、执行函数体、保存返回值、恢复现场和断点等工作。这些工作是调用函数的额外开销。为提高效率，C+提供了内联函数（inline function）。对于内联函数，C+编译器执行内联扩展，将函数代码直接插入每一处调用处。由此可以减少函数调用的开销，而且依然允许以结构化方式组织程序。 在函数定义是冠以关键字inl

24、ine就成为内联函数： inline 类型标识符 函数名（参数表列） 函数体 通过下面例题进一步说明内联函数的执行过程。,内联函数,【例7.13】应用内联函数，求两数中的大数。 / 7-13.cpp #include inline int max(int x,int y ) return xy?x:y; int main() coutab; cout两个整数中较大数是：max(a,b)endl; return 0; ,内联函数,使用内联函数应注意： （1）在C+程序中，除了函数体内含有循环、switch分支和复杂嵌套的if语句的函数外，所有函数均可以被说明为内联函数。 （2）定义内联函数的函数

25、体不宜过大，一般1至5行之间。 （3）关键字inline与函数定义体放在一起才能使函数成为内联，内联函数的定义必须放在对该函数调用之前。 （4）使用内联函数虽然节省了程序运行时间的开销，但却增大了代码占用内存的开销，设计程序时，应考虑运行时间与占用内存空间的平衡。 内联函数既具备了宏定义的效率，又增加了安全性，因此在程序设计中应尽量使用内联函数取代宏定义。,函数重载,所谓重载（overload）就是一词多义，函数重载（function overloading）就是用一个函数名代表不同的操作，C+提供函数重载的功能，即允许定义同名的函数。函数重载常用于不同数据类型的基础上完成类似的任务。 例如，

26、C+程序中建立三个求绝对值的函数： int abs(int); long labs(long); double dabs(double);,函数重载,三个函数所执行的操作基本一样，功能依次为求整型、长整型和双精度实型变量的绝对值。能否将求绝对值用于同一函数形式调用呢？应用函数重载功能可将它们同一定义成： int abs(int); long abs(long); double abs(double); 在使用中。C+编译器通过调用函数实参类型来判断应该调用哪一个函数，例如在下面程序中执行：,函数重载,【例7.14】重载绝对值函数。 / 7-14.CPP #include int abs(int

27、 x) return x=0? x:-x; long abs(long x) return x=0? x:-x; double abs(double x) return x=0? x:-x; int main() int a = 21; long b = 345678; double c = -3.14159265; cout|a|= abs(a)endl;/ 调用 int abs(int) cout|b|= abs(b)endl;/ 调用 long abs(long) cout|c|= abs(c)endl;/ 调用 double abs(double) cout|c|= abs(c)end

28、l;/ 调用 int abs(int) cout|3.2|= abs(3.2)endl;/ 调用 double abs(double) return 0; ,|21|= 21 |345678|= 345678 |-3.14159|= 3.14159 |c|= 99 |3.2|= 3.2,函数重载,在大多数情况下，主要根据参数表的参数类型的匹配情况选择所调用的重载函数。如果找不到相应的函数声明，则调用最便于类型转换的那个函数。在上面程序中语句： cout|c|= abs(c)endl;/调用 int abs(int) 在使用函数重载时应注意： （1）重载函数必须在参数个数或类型上有所不同； 下面

29、的声明是错误的 void fun(int); int fun(int);/ 重载函数的参数个数或类型相同 如下的重载函数声明是正确的： int fun(int); int fun(int, int); int fun(int, int, int); （2）重载函数应执行类似的功能，如果两个功能相去甚远的函数定义为重载，则不足取。,带有缺省参数值的函数,在C+中，可以为函数的参数定义缺省值（简称缺省参数）。 在函数定义时，在形式参数的说明中给出初值，这样在调用函数时可省略实参，当不给出实参时，函数按形参的缺省值运行。 【例7.15】带有缺省参数值的函数演示。 / 7-15.cpp #includ

30、e void fun_out(int a=10000) coutaendl; int main() cout*endl; fun_out(20000); cout*endl; fun_out();/ 相当于 delay(10000) cout*endl; return 0; ,* 20000 * 10000 *,带有缺省参数值的函数,【例7.16】函数缺省参数的用法演示。 /7-16.cpp #include int add(int x,int y=10); / 函数原型说明，形参缺省值为已有初值得变量 int sub(int x=100,int y=200); / 函数原型说明，形参缺省值为

31、表达式和函数调用 void main() int a(30),b(50); couta= a ,b= bendl; coutsub(a,b)= sub(a,b)endl; coutadd(20)= add(20)endl; coutadd(20,b)= add(20,b)endl; coutsub()= sub()endl; coutsub(b*3,add(40)= sub(b*3,add(40)endl; int add(int x,int y) return x+y; int sub(int x,int y) return x-y; ,a= 30 ,b= 50 sub(a,b)= -20

32、add(20)= 30 add(20,b)= 70 sub()= -100 sub(b*3,add(40)= 100,带有缺省参数值的函数,缺省参数既可以在函数原型中声明，也可以在函数定义中声明，但都应在使用该函数之前声明。当函数有多个参数时，缺省参数必须连续放在后面。调用带缺省函数时，缺省实参不能夹在中间。例如 int fun(int a,int b,int c,int d=100); / 函数缺省参数定义正确。 int fun(int a,int b,int c=200,int d=100); / 函数缺省参数定义正确。 int fun(int a, int b=300,int c=200

33、,int d=100); / 函数缺省参数定义正确。 int fun(int a=400, int b,int c,int d=100); / 函数缺省参数定义在中间，定义错误。,带有缺省参数值的函数,对于函数原型： int fun(int a, int b=300,int c=200,int d=100); 可以使用如下方式调用： fun(400); fun(400,300); fun(400,300,200); fun(400,300,200,100); 下面的对缺省实参函数的调用是错误的： fun();/ 至少应有一个形参 fun(1 ,2 , , 4);/ 缺省实参不能夹在中间,变量的

34、作用域,一个标识符在程序中能够被引用的那个区域称为作用域。 C+中有五种作用域： 本节介绍前四种作用域。,作用域,文件作用域,在函数和类之外定义或说明的标识符具有文件作用域，其作用域从说明点开始，在文件结束处结束。 如果标识符出现在头文件的文件作用域中，则它的作用域扩展到嵌入了这个头文件的程序文件中，直到该程序文件末尾，任何函数都可以访问这些标识符。文件作用域包含该文件中所有的其他作用域。 在同一作用域中不能说明相同的标识符。 在文件作用域中说明的变量称作全局变量。例如在下列定义说明中： int i;/全局变量i拥有文件作用域 void fun_a( ) int main( ) ;i=20;

35、/在主函数中访问变量i,块作用域,块是函数中一对花括号（包括函数定义所使用的花括号）所括起的一段区域。在块内说明的标识符具有块作用域，它开始于标识符被说明的地方，并在标志该块结束的右花括号处结束。函数是一个块，复合语句也是一个块，如果一个块内有一个嵌套块，并且该块内的一个标识符在嵌套块开始之前说明，则这个标识符的作用域包含嵌套块。 在块作用域中说明的变量称作局部变量。函数的形参具有块作用域，其开始点在标志函数定义开始的第一个左花括号处，结束于标志函数定义结束的右花括号处，在函数中定义的变量也具有块作用域，它们都是局部变量。,块作用域,void fun(int x ) int y3; int z

36、=y+2; . int k; 函数只能在文件作用域中进行定义，但可以在文件作用域或块作用域内进行函数说明。标识符的作用域和其可见性经常是相同的，但并非始终如此。下例演示了全局变量和局部变量可见性。,块作用域,【例7.17】全局变量和局部变量可见性演示。 /7-17.cpp #include int i;/ 全局变量i具有文件作用域 void f(int j) cout在函数f内:i= it ,块作用域,void main() i=5; / 块作用域 int i; i=7;/ 局部变量i赋值 couti= it / 输出全局变量i的值和地址 / 文件作用域终止,i= 7 int b,c;/ b和

37、c也是自动变量。,动态生存期,（2）寄存器变量 寄存器变量存放在CPU的寄存器中，使用时不需要访问内存，而直接从寄存器中读写，从而提高了效率。寄存器变量用关键字register定义。例如： register int d; 寄存器变量只限于整型、字符型和指针型的局部变量。寄存器变量具有动态生存期，而且数目有限，如果没有足够多的寄存器使用，编译程序自动将register型变量转化为auto型变量。 （3）形式参数 函数的形式参数，在函数定义时并不给形参分配存储单元，只是在函数被调用时，才予以分配，函数调用完毕立即释放。形参可以是自动变量，也可以是寄存器变量。例如： void fun(registe

38、r int a, auto int b) ,静态生存期,具有静态生存期的变量在程序运行期间一直存在。静态生存期的变量，如果定义时未指定初始值，则系统将它们初始化为0。以下类型的变量具有动态生存期： （1）静态局部变量 在局部变量的定义前加上static存储类别的声明就构成了静态局部变量。静态局部变量具有以下特点： 静态局部变量的定义及赋初值语句写在函数内，作用域与自动变量相同。 静态局部变量属于静态存储方式，具有静态生存期，即生存期为整个程序。 静态局部变量在它的整个生存期内只赋初值一次。 第一次调用静态局部变量所在的函数时，静态局部变量保存着初始值，调用结束后，静态局部变量继续存在，变量的值

39、不丢失。再次调用该函数时，静态局部变量不再赋初值，继续保存着前一次调用后留下的值。,静态生存期,【例7.18】猴子吃桃问题。 / 7-18.cpp #include using namespace std; void peach() int a = 1; static int b = 1; cout 0; day-) peach(); return 0; ,1 1 1 4 1 10 1 22 1 46 1 94 1 190 1 382 1 766 1 1534,静态生存期,【例7.19】输出Fibonacci数列30个数。 / 7-19.cpp #include #include using

40、namespace std; void fib(bool newline) static a(1), b(1); cout setw(8) a setw(8) b; if (newline) cout endl; a += b; b += a; int main() for (int i=1; i=15; i+) fib(!(i%3); return 0; ,1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 5

41、14229 832040,静态生存期,（2）外部变量 外部变量（即全局变量）分配在静态存储区，具有静态生存期。有时需要用extern来声明外部变量，以扩展外部变量的作用域。 在一个文件内声明外部变量 外部变量的有效范围只限于定义处到文件终了，如果在定义点之前使用，则应使用extern对该变量作“外部变量声明”。表示该外部变量是已经定义的外部变量。 在多文件程序中声明外部变量。 一个C+程序可以由多个源程序文件组成。当一个文件中定义的函数引用另一个文件中定义的外部变量时，需要在函数所在的文件中，使用extern对相应变量进行声明。,静态生存期,【例7.20】外部变量的定义与声明。 / 7-20(

42、1).cpp #include using namespace std; void fun();/ 函数声明 extern double gLength, gWidth, gPerim, gArea; / 声明外部变量，文件内扩展 int main() gLength=5; gWidth= 6; fun(); cout 周长= gPerim ，面积= gArea endl; return 0; double gLength, gWidth, gPerim, gArea;/ 定义外部变量,静态生存期,/ 7-20(2).cpp extern double gLength, gWidth, gPe

43、rim, gArea; / 声明外部变量，扩展到其他文件 void fun() gPerim = 2 * (gLength + gWidth); gArea = gLength * gWidth; ,静态生存期,（3）静态全局变量 在全局变量的定义前加上static存储类别的声明就构成了静态全局变量，也称为静态外部变量。静态全局变量的存储方式和生存期与外部变量相同。两者不同之处在于作用域的扩展上。静态全局变量只能在文件内扩展，不能扩展到其他文件。例如： 在file1.cpp中定义的静态全局变量，只能在文件内扩展： extern int x;/ 可以在文件内扩展 static int x;/ 静

44、态全局变量 在file2.cpp中，就不能声明外部变量： extern int x;/ 编译能通过，连接时出错,内部函数与外部函数,C+中所有的函数是平行定义的，函数的本质是外部的。这些函数分散在多个文件中，可以根据函数是否允许在多个文件中使用，将函数分为内部函数和外部函数，分别用static和extern来定义和声明。 1. 内部函数 内部函数又称静态函数，只能在定义它的文件中被调用，而不能被其他文件中的函数所调用。在函数定义前面使用static关键字，内部函数定义形式为： static 类型标识符 函数名(形参表) 例如： static int fun_a(int x,int y) ; 函数fun_a()，只能被它所在文件中函数调用，保证了函数的独立性。对于外部变量也可以使用static来定义，例如,内部函数与外部函数,static double fun_sum(double ,int); static int a； void main() ;