• 1. 第7章 函数与预处理7.1 概述 7.2 定义函数的一般形式 7.3 函数参数和函数的值 7.4 函数的调用 *7.5 内置函数 *7.6 函数的重载 *7.7 函数模板 *7.8 有默认参数的函数 7.9 函数的嵌套调用 7.10 函数的递归调用 7.11 局部变量和全局变量 7.12 变量的存储类别 7.13 变量属性小结 7.14 内部函数和外部函数
  • 2. 一个较大的程序不可能完全由一个人从头至尾地完成,更不可能把所有的内容都放在一个主函数中。为了便于规划、组织、编程和调试,一般的做法是把一个大的程序划分为若干个程序模块(即程序文件),每一个模块实现一部分功能。不同的程序模块可以由不同的人来完成。在程序进行编译时,以程序模块为编译单位,即分别对每一个编译单位进行编译。如果发现错误,可以在本程序模块范围内查错并改正。在分别通过编译后,才进行连接,把各模块的目标文件以及系统文件连接在一起形成可执行文件。7.1 概述
  • 3. 在一个程序文件中可以包含若干个函数。无论把一个程序划分为多少个程序模块,只能有一个main函数。程序总是从main函数开始执行的。在程序运行过程中,由主函数调用其他函数,其他函数也可以互相调用。在C++面向对象的程序设计中,主函数以外的函数大多是被封装在类中的。 主函数或其他函数可以通过类对象调用类中的函数。无论是C还是C++,程序中的各项操作基本上都是由函数来实现的,程序编写者要根据需要编写一个个函数,每个函数用来实现某一功能。因此,我们必须掌握函数的概念以及学会设计和使用函数。
  • 4. “函数”这个名词是从英文function翻译过来的,其实function的原意是“功能”。顾名思义,一个函数就是一个功能。 在实际应用的程序中,主函数写得很简单,它的作用就是调用各个函数,程序各部分的功能全部都是由各函数实现的。主函数相当于总调度,调动各函数依次实现各项功能。 开发商和软件开发人员将一些常用的功能模块编写成函数,放在函数库中供公共选用。程序开发人员要善于利用库函数,以减少重复编写程序段的工作量。
  • 5. 图7.1是一个程序中函数调用的示意图。 图7.1
  • 6. 例7.1 在主函数中调用其他函数。 #include using namespace std; void printstar(void) //定义printstar函数 { cout<<″****************************** ″<
  • 7. 运行情况如下: ****************************** Welcome to C++! ****************************** 从用户使用的角度看,函数有两种: (1) 系统函数,即库函数。这是由编译系统提供的,用户不必自己定义这些函数,可以直接使用它们。 (2) 用户自己定义的函数。用以解决用户的专门需要。 从函数的形式看,函数分两类: (1) 无参函数。调用函数时不必给出参数。 (2) 有参函数。在调用函数时,要给出参数。在主调函数和被调用函数之间有数据传递。
  • 8. 定义无参函数的一般形式为 类型标识符 函数名([void]) {声明部分 语句 } 例7.1中的printstar和print_message函数都是无参函数。用类型标识符指定函数的类型,即函数带回来的值的类型。7.2 定义函数的一般形式 7.2.1 定义无参函数的一般形式
  • 9. 定义有参函数的一般形式为 类型标识符 函数名(形式参数表列) {声明部分 语句 } 例如: int max(int x,int y) //函数首部,函数值为整型,有两个整型形参 {int z; //函数体中的声明部分 z=x>y?x:y; //将x和y中的大者的值赋给整型变量z return (z); //将z的值作为函数值返回调用点 } C++要求在定义函数时必须指定函数的类型。7.2.2 定义有参函数的一般形式
  • 10. 在调用函数时,大多数情况下,函数是带参数的。主调函数和被调用函数之间有数据传递关系。前面已提到:在定义函数时函数名后面括号中的变量名称为形式参数(formal parameter,简称形参),在主调函数中调用一个函数时,函数名后面括号中的参数(可以是一个表达式)称为实际参数(actual parameter,简称实参)。7.3 函数参数和函数的值 7.3.1 形式参数和实际参数
  • 11. 例7.2 调用函数时的数据传递。 #include using namespace std; int max(int x,int y) //定义有参函数max {int z; z=x>y?x:y; return(z); } int main( ) {int a,b,c; cout<<″please enter two integer numbers:″; cin>>a>>b; c=max(a,b); //调用max函数,给定实参为a,b。函数值赋给c cout<<″max=″<
  • 12. 运行情况如下: please enter two integer numbers:2 3↙ max=3 图7.2
  • 13. 有关形参与实参的说明: (1) 在定义函数时指定的形参,在未出现函数调用时,它们并不占内存中的存储单元,因此称它们是形式参数或虚拟参数,表示它们并不是实际存在的数据,只有在发生函数调用时,函数max中的形参才被分配内存单元,以便接收从实参传来的数据。在调用结束后,形参所占的内存单元也被释放。 (2) 实参可以是常量、变量或表达式,如max(3, a+b);但要求a和b有确定的值。以便在调用函数时将实参的值赋给形参。 (3) 在定义函数时,必须在函数首部指定形参的类型(见例7.2程序第3行)。
  • 14. (4) 实参与形参的类型应相同或赋值兼容。例7.2中实参和形参都是整型,这是合法的、正确的。如果实参为整型而形参为实型,或者相反,则按不同类型数值的赋值规则进行转换。例如实参a的值为3.5,而形参x为整型,则将3.5转换成整数3,然后送到形参b。字符型与整型可以互相通用。 (5) 实参变量对形参变量的数据传递是“值传递”,即单向传递,只由实参传给形参,而不能由形参传回来给实参。在调用函数时,编译系统临时给形参分配存储单元。请注意: 实参单元与形参单元是不同的单元。图7.3表示将实参a和b的值2和3传递给对应的形参x和y。
  • 15. 图7.3 图7.4 调用结束后,形参单元被释放,实参单元仍保留并维持原值。因此,在执行一个被调用函数时,形参的值如果发生改变,并不会改变主调函数中实参的值。例如,若在执行max函数过程中形参x和y的值变为10和15,调用结束后,实参a和b仍为2和3,见图7.4。
  • 16. (1) 函数的返回值是通过函数中的return语句获得的。return语句将被调用函数中的一个确定值带回主调函数中去。 return语句后面的括号可以要,也可以不要。return后面的值可以是一个表达式。 (2) 函数值的类型。既然函数有返回值,这个值当然应属于某一个确定的类型,应当在定义函数时指定函数值的类型。 (3) 如果函数值的类型和return语句中表达式的值不一致,则以函数类型为准,即函数类型决定返回值的类型。对数值型数据,可以自动进行类型转换。7.3.2 函数的返回值
  • 17. 函数名([实参表列]) 如果是调用无参函数,则“实参表列”可以没有,但括号不能省略。如果实参表列包含多个实参,则各参数间用逗号隔开。实参与形参的个数应相等,类型应匹配(相同或赋值兼容)。实参与形参按顺序对应,一对一地传递数据。但应说明,如果实参表列包括多个实参,对实参求值的顺序并不是确定的。7.4 函数的调用 7.7.1 函数调用的一般形式
  • 18. 按函数在语句中的作用来分,可以有以下3种函数调用方式: 1. 函数语句 把函数调用单独作为一个语句,并不要求函数带回一个值,只是要求函数完成一定的操作。如例7.1中的printstar( ); 2. 函数表达式 函数出现在一个表达式中,这时要求函数带回一个确定的值以参加表达式的运算。如c=2*max(a,b); 3. 函数参数 函数调用作为一个函数的实参。如 m=max(a,max(b,c)); //max(b,c)是函数调用,其值作为外层max函数调用的一个实参7.7.2 函数调用的方式
  • 19. 在一个函数中调用另一个函数(即被调用函数)需要具备哪些条件呢? (1) 首先被调用的函数必须是已经存在的函数。 (2) 如果使用库函数,一般还应该在本文件开头用#include命令将有关头文件“包含”到本文件中来。 (3) 如果使用用户自己定义的函数,而该函数与调用它的函数(即主调函数)在同一个程序单位中,且位置在主调函数之后,则必须在调用此函数之前对被调用的函数作声明。 所谓函数声明(declare),就是在函数尚在未定义的情况下,事先将该函数的有关信息通知编译系统,以便使编译能正常进行。7.7.3 对被调用函数的声明和函数原型
  • 20. 例7.3 对被调用的函数作声明。 #include using namespace std; int main( ) {float add(float x,float y); //对add函数作声明 float a,b,c; cout<<″please enter a,b:″; cin>>a>>b; c=add(a,b); cout<<″sum=″<
  • 21. 运行情况如下: please enter a,b:123.68 456.45↙ sum=580.13 注意:对函数的定义和声明不是同一件事情。定义是指对函数功能的确立,包括指定函数名、函数类型、形参及其类型、函数体等,它是一个完整的、独立的函数单位。而声明的作用则是把函数的名字、函数类型以及形参的个数、类型和顺序(注意,不包括函数体)通知编译系统,以便在对包含函数调用的语句进行编译时,据此对其进行对照检查(例如函数名是否正确,实参与形参的类型和个数是否一致)。 其实,在函数声明中也可以不写形参名,而只写形参的类型,如
  • 22. float add(float,float); 这种函数声明称为函数原型(function prototype)。使用函数原型是C和C++的一个重要特点。它的作用主要是: 根据函数原型在程序编译阶段对调用函数的合法性进行全面检查。如果发现与函数原型不匹配的函数调用就报告编译出错。它属于语法错误。用户根据屏幕显示的出错信息很容易发现和纠正错误。 函数原型的一般形式为 (1) 函数类型 函数名(参数类型1,参数类型2…); (2) 函数类型 函数名(参数类型1 参数名1,参数类型2 参数名2…);
  • 23. 第(1)种形式是基本的形式。为了便于阅读程序,也允许在函数原型中加上参数名,就成了第(2)种形式。但编译系统并不检查参数名。因此参数名是什么都无所谓。上面程序中的声明也可以写成 float add(float a,float b); //参数名不用x、y,而用a、b 效果完全相同。 应当保证函数原型与函数首部写法上的一致,即函数类型、函数名、参数个数、参数类型和参数顺序必须相同。在函数调用时函数名、实参类型和实参个数应与函数原型一致。
  • 24. 说明: (1) 前面已说明,如果被调用函数的定义出现在主调函数之前,可以不必加以声明。因为编译系统已经事先知道了已定义的函数类型,会根据函数首部提供的信息对函数的调用作正确性检查。 有经验的程序编制人员一般都把main函数写在最前面,这样对整个程序的结构和作用一目了然,统览全局,然后再具体了解各函数的细节。此外,用函数原型来声明函数,还能减少编写程序时可能出现的错误。由于函数声明的位置与函数调用语句的位置比较近,因此在写程序时便于就近参照函数原型来书写函数调用,不易出错。所以应养成对所有用到的函数作声明的习惯。这是保证程序正确性和可读性的重要环节。
  • 25. (2) 函数声明的位置可以在调用函数所在的函数中,也可以在函数之外。如果函数声明放在函数的外部,在所有函数定义之前,则在各个主调函数中不必对所调用的函数再作声明。例如: char letter(char,char); //本行和以下两行函数声明在所有函数之前且在函数外部 float f(float,float); //因而作用域是整个文件 int i(float, float); int main( ) {…} //在main函数中不必对它所调用的函数作声明 char letter(char c1,char c2) //定义letter函数 {…} float f(float x,float y) //定义f函数 {…} int i(float j,float k) //定义i函数 {…} 如果一个函数被多个函数所调用,用这种方法比较好,不必在每个主调函数中重复声明。
  • 26. 调用函数时需要一定的时间和空间的开销。图7.5表示函数调用的过程: 图7.5*7.5 内置函数 Inline functions
  • 27. C++提供一种提高效率的方法,即在编译时将所调用函数的代码直接嵌入到主调函数中,而不是将流程转出去。这种嵌入到主调函数中的函数称为内置函数(inline function),又称内嵌函数。在有些书中把它译成内联函数。 指定内置函数的方法很简单,只需在函数首行的左端加一个关键字inline即可。
  • 28. 例7.4 函数指定为内置函数。 #include using namespace std; inline int max(int,int, int); //声明函数,注意左端有inline int main( ) {int i=10,j=20,k=30,m; m=max(i,j,k); cout<<″max=″<a) a=b; //求a,b,c中的最大者 if(c>a) a=c; return a; }
  • 29. 由于在定义函数时指定它为内置函数,因此编译系统在遇到函数调用“max(i,j,k)”时,就用max函数体的代码代替“max(i,j,k)”,同时将实参代替形参。这样,程序第6行 “m=max(i,j,k);”就被置换成 if (j>i) i=j; if(k>i) i=k; m=i; 注意: 可以在声明函数和定义函数时同时写inline,也可以只在其中一处声明inline,效果相同,都能按内置函数处理。 使用内置函数可以节省运行时间,但却增加了目标程序的长度。因此一般只将规模很小(一般为5个语句以下)而使用频繁的函数(如定时采集数据的函数)声明为内置函数。
  • 30. 内置函数中不能包括复杂的控制语句,如循环语句和switch语句。 应当说明: 对函数作inline声明,只是程序设计者对编译系统提出的一个建议,也就是说它是建议性的,而不是指令性的。并非一经指定为inline,编译系统就必须这样做。编译系统会根据具体情况决定是否这样做。 归纳起来,只有那些规模较小而又被频繁调用的简单函数,才适合于声明为inline函数。
  • 31. 在编程时,有时我们要实现的是同一类的功能,只是有些细节不同。例如希望从3个数中找出其中的最大者,而每次求最大数时数据的类型不同,可能是3个整数、3个双精度数或3个长整数。程序设计者往往会分别设计出3个不同名的函数,其函数原型为: int max1(int a,int b, int c); //求3个整数中的最大者 double max2(double a,double b,double c); //求3个双精度数中最大者 long max3(long a,long b,long c); //求3个长整数中的最大者 C++允许用同一函数名定义多个函数,这些函数的参数个数和参数类型不同。这就是函数的重载(function overloading)。即对一个函数名重新赋予它新的含义,使一个函数名可以多用。*7.6 Function overloading(函数重载)
  • 32. 对上面求最大数的问题可以编写如下的C++程序。 例7.5 求3个数中最大的数(分别考虑整数、双精度数、长整数的情况)。 #include using namespace std; int main( ) {int max(int a,int b,int c); //函数声明 double max(double a,double b,double c); //函数声明 long max(long a,long b,long c); //函数声明 int i1,i2,i3,i; cin>>i1>>i2>>i3; //输入3个整数 i=max(i1,i2,i3); //求3个整数中的最大者 cout<<″i_max=″<>d1>>d2>>d3; //输入3个双精度数 d=max(d1,d2,d3); //求3个双精度数中的最大者 cout<<″d_max=″<>g1>>g2>>g3; //输入3个长整数
  • 33. g=max(g1,g2,g3); //求3个长整数中的最大者 cout<<″g_max=″<a) a=b; if(c>a) a=c; return a; } double max(double a,double b,double c) //定义求3个双精度数中的最大者的函数 {if(b>a) a=b; if(c>a) a=c; return a; } long max(long a,long b,long c) //定义求3个长整数中的最大者的函数 {if(b>a) a=b; if(c>a) a=c; return a; }
  • 34. 运行情况如下: 185 -76 567↙ (输入3个整数) 56.87 90.23 -3217.78↙ (输入3个实数) 67854 -912456 673456↙ (输入3个长整数) i_max=567 (输出3个整数的最大值) d_max=90.23 (输出3个双精度数的最大值) g_max=673456 (输出3个长整数的最大值) 上例3个max函数的函数体是相同的,其实重载函数并不要求函数体相同。重载函数除了允许参数类型不同以外,还允许参数的个数不同。
  • 35. 例7.6 编写一个程序,用来求两个整数或3个整数中的最大数。如果输入两个整数,程序就输出这两个整数中的最大数,如果输入3个整数,程序就输出这3个整数中的最大数。 #include using namespace std; int main( ) {int max(int a,int b,int c); //函数声明 int max(int a,int b); //函数声明 int a=8,b=-12,c=27; cout<<″max(a,b,c)=″<a) a=b;
  • 36. if(c>a) a=c; return a; } int max(int a,int b) //此max函数的作用是求两个整数中的最大者 {if(a>b) return a; else return b; } 运行情况如下: max(a,b,c)=27 max(a,b)=8 两次调用max函数的参数个数不同,系统就根据参数的个数找到与之匹配的函数并调用它。 参数的个数和类型可以都不同。但不能只有函数的类型不同而参数的个数和类型相同。例如:
  • 37. int f(int); //函数返回值为整型 long f(int); //函数返回值为长整型 void f(int); //函数无返回值 在函数调用时都是同一形式,如“f(10)”。编译系统无法判别应该调用哪一个函数。重载函数的参数个数、参数类型或参数顺序3者中必须至少有一种不同,函数返回值类型可以相同也可以不同。 在使用重载函数时,同名函数的功能应当相同或相近,不要用同一函数名去实现完全不相干的功能,虽然程序也能运行,但可读性不好,使人莫名其妙。
  • 38. C++提供了函数模板(function template)。所谓函数模板,实际上是建立一个通用函数,其函数类型和形参类型不具体指定,用一个虚拟的类型来代表。这个通用函数就称为函数模板。凡是函数体相同的函数都可以用这个模板来代替,不必定义多个函数,只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型,从而实现了不同函数的功能。看下面的例子就清楚了。 例7.7 将例7.6程序改为通过函数模板来实现。*7.7 函数模板(function template)
  • 39. #include using namespace std; template //模板声明,其中T为类型参数 T max(T a,T b,T c) //定义一个通用函数,用T作虚拟的类型名 {if(b>a) a=b; if(c>a) a=c; return a; } int main( ) {int i1=185,i2=-76,i3=567,i; double d1=56.87,d2=90.23,d3=-3217.78,d; long g1=67854,g2=-912456,g3=673456,g; i=max(i1,i2,i3); //调用模板函数,此时T被int取代 d=max(d1,d2,d3); //调用模板函数,此时T被double取代 g=max(g1,g2,g3); //调用模板函数,此时T被long取代 cout<<″i_max=″<
  • 40. 运行结果与例7.5相同。为了节省篇幅,数据不用cin语句输入,而在变量定义时初始化。 程序第3~8行是定义模板。定义函数模板的一般形式为 template < typename T> 或 template 通用函数定义 通用函数定义 在建立函数模板时,只要将例7.5程序中定义的第一个函数首部的int改为T即可。即用虚拟的类型名T代替具体的数据类型。在对程序进行编译时,遇到第13行调用函数max(i1,i2,i3),编译系统会将函数名max与模板max相匹配,将实参的类型取代了函数模板中的虚拟类型T。此时相当于已定义了一个函数:
  • 41. int max(int a,int b,int c) {if(b>a) a=b; if(c>a) a=c; return a; } 然后调用它。后面两行(14,15行)的情况类似。 类型参数可以不只一个,可以根据需要确定个数。如 template 可以看到,用函数模板比函数重载更方便,程序更简洁。但应注意它只适用于函数的参数个数相同而类型不同,且函数体相同的情况,如果参数的个数不同,则不能用函数模板。
  • 42. 一般情况下,在函数调用时形参从实参那里取得值,因此实参的个数应与形参相同。有时多次调用同一函数时用同样的实参,C++提供简单的处理办法,给形参一个默认值,这样形参就不必一定要从实参取值了。如有一函数声明 float area(float r=6.5); 指定r的默认值为6.5,如果在调用此函数时,确认r的值为6.5,则可以不必给出实参的值,如 area( ); //相当于area(6.5); 如果不想使形参取此默认值,则通过实参另行给出。如*7.8 Default parameter values默认的形参值
  • 43. area(7.5); //形参得到的值为7.5,而不是6.5 这种方法比较灵活,可以简化编程,提高运行效率。 如果有多个形参,可以使每个形参有一个默认值,也可以只对一部分形参指定默认值,另一部分形参不指定默认值。如有一个求圆柱体体积的函数,形参h代表圆柱体的高,r为圆柱体半径。函数原型如下: float volume(float h,float r=12.5); //只对形参r指定默认值12.5 函数调用可以采用以下形式: volume(45.6); //相当于volume(45.6,12.5) volume(37.2,10.4) //h的值为37.2,r的值为10.4 实参与形参的结合是从左至右顺序进行的。因此指定默认值的参数必须放在形参表列中的最右端,否则出错。例如:
  • 44. void f1(float a,int b=0,int c,char d=′a′); //不正确 void f2(float a,int c,int b=0, char d=′a′); //正确 如果调用上面的f2函数,可以采取下面的形式: f2(3.5, 5, 3, ′x′) //形参的值全部从实参得到 f2(3.5, 5, 3) //最后一个形参的值取默认值′a′ f2(3.5, 5) //最后两个形参的值取默认值,b=0,d=′a′ 可以看到,在调用有默认参数的函数时,实参的个数可以与形参的个数不同,实参未给定的,从形参的默认值得到值。利用这一特性,可以使函数的使用更加灵活。例如例7.7求2个数或3个数中的最大数。也可以不用重载函数,而改用带有默认参数的函数。
  • 45. 例7.8 求2个或3个正整数中的最大数,用带有默认参数的函数实现。 #include using namespace std; int main( ) {int max(int a, int b, int c=0);//函数声明,形参c有默认值 int a,b,c; cin>>a>>b>>c; cout<<″max(a,b,c)=″<a) a=b; if(c>a) a=c; return a; }
  • 46. 运行情况如下: 14 -56 135↙ max(a,b,c)=135 max(a,b)=14 在使用带有默认参数的函数时有两点要注意: (1) 如果函数的定义在函数调用之前,则应在函数定义中给出默认值。如果函数的定义在函数调用之后,则在函数调用之前需要有函数声明,此时必须在函数声明中给出默认值,在函数定义时可以不给出默认值(如例7.8)。 (2) 一个函数不能既作为重载函数,又作为有默认参数的函数。因为当调用函数时如果少写一个参数,系统无法判定是利用重载函数还是利用默认参数的函数,出现二义性,系统无法执行。
  • 47. C++不允许对函数作嵌套定义,也就是说在一个函数中不能完整地包含另一个函数。在一个程序中每一个函数的定义都是互相平行和独立的。 虽然C++不能嵌套定义函数,但可以嵌套调用函数,也就是说,在调用一个函数的过程中,又调用另一个函数。见图7.6。 图7.67.9 函数的嵌套调用Nested function call
  • 48. 在程序中实现函数嵌套调用时,需要注意的是: 在调用函数之前,需要对每一个被调用的函数作声明(除非定义在前,调用在后)。 例7.9 用弦截法求方程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,见图7.7。
  • 49. 图7.7
  • 50. x点坐标可用下式求出: x=x1·f(x2)-x2·f(x1) f(x2)-f(x1) 再从x求出f(x)。 (3) 若f(x)与f(x1)同符号,则根必在(x, x2)区间内,此时将x作为新的x1。如果f(x)与f(x2)同符号,则表示根在( x1,x)区间内,将x作为新的x2。 (4) 重复步骤 (2) 和 (3), 直到 |f(x)|<ξ为止, ξ为一个很小的正数, 例如10-6。此时认为 f(x)≈0。 这就是弦截法的算法,在程序中分别用以下几个函数来实现以上有关部分功能: (1) 用函数f(x)代表x的函数:x3-5x2+16x-80。
  • 51. (2) 用函数xpoint (x1,x2)来求(x1,f(x1))和(x2,f(x2))的连线与x轴的交点x的坐标。 (3) 用函数root(x1,x2)来求(x1,x2)区间的那个实根。显然,执行root函数的过程中要用到xpoint函数,而执行xpoint函数的过程中要用到f函数。 根据以上算法,可以编写出下面的程序: #include #include #include using namespace std; double f(double); //函数声明 double xpoint(double, double); //函数声明 double root(double, double); //函数声明 int main( ) { double x1,x2,f1,f2,x;
  • 52. do {cout<<″input x1,x2:″; cin>>x1>>x2; f1=f(x1); f2=f(x2); } while(f1*f2>=0); x=root(x1,x2); cout<
  • 53. double xpoint(double x1, double x2) //定义xpoint函数,求出弦与x轴交点 {double y; y=(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1)); //在xpoint函数中调用f函数 return y; } double root(double x1, double x2) //定义root函数,求近似根 {double x,y,y1; y1=f(x1); do {x=xpoint(x1,x2); //在root函数中调用xpoint函数 y=f(x); //在root函数中调用f函数 if (y*y1>0) {y1=y; x1=x; } else x2=x; }while(fabs(y)>=0.00001); return x; }
  • 54. 运行情况如下: input x1,x2:2.5 6.7↙ A root of equation is 5.0000000 对程序的说明: (1) 在定义函数时,函数名为f,xpoint和root的3个函数是互相独立的,并不互相从属。这3个函数均定为双精度型。 (2) 3个函数的定义均出现在main函数之后,因此在main函数的前面对这3个函数作声明。 习惯上把本程序中用到的所有函数集中放在最前面声明。 (3) 程序从main函数开始执行。函数的嵌套调用见图7.8。
  • 55. 图7.8 (4) 在root函数中要用到求绝对值的函数fabs,它是对双精度数求绝对值的系统函数。它属于数学函数库,故在文件开头用#include 把有关的头文件包含进来。
  • 56. 在调用一个函数的过程中又出现直接或间接地调用该函数本身,称为函数的递归(recursive)调用。C++允许函数的递归调用。例如: int f(int x) {int y,z; z=f(y); //在调用函数f的过程中,又要调用f函数 return (2*z); } 以上是直接调用本函数,见图7.9。 图7.10表示的是间接调用本函数。在调用f1函数过程中要调用f2函数,而在调用f2函数过程中又要调用f1函数。7.10 函数的递归调用Recursion
  • 57. 图7.9 图7.10 从图上可以看到,这两种递归调用都是无终止的自身调用。显然,程序中不应出现这种无终止的递归调用,而只应出现有限次数的、有终止的递归调用,这可以用if语句来控制,只有在某一条件成立时才继续执行递归调用,否则就不再继续。 包含递归调用的函数称为递归函数。
  • 58. 例7.10 有5个人坐在一起,问第5个人多少岁?他说比第4个人大两岁。问第4个人岁数,他说比第3个人大两岁。问第3个人,又说比第2个人大两岁。问第2个人,说比第1个人大两岁。最后问第1个人,他说是10岁。请问第5个人多大? 每一个人的年龄都比其前1个人的年龄大两岁。即 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 (n=1) age(n)=age(n-1)+2 (n>1)
  • 59. 可以看到,当n>1时,求第n个人的年龄的公式是相同的。因此可以用一个函数表示上述关系。图7.11表示求第5个人年龄的过程。 图7.11
  • 60. 可以写出以下C++程序,其中的age函数用来实现上述递归过程。 #include using namespace std; int age(int); //函数声明 int main( ) //主函数 { cout<
  • 61. 运行结果如下: 18 函数调用过程如图7.12所示。 图7.12
  • 62. 例7.11 用递归方法求n!。 求n!可以用递推方法,即从1开始,乘2,再乘3……一直乘到n。 求n!也可以用递归方法,即5!=4!×5,而4!=3!×4,…,1!=1。可用下面的递归公式表示: n!= 1 (n=0,1) n·(n-1)! (n>1) 有了例7.10的基础,很容易写出本题的程序: #include using namespace std; long fac(int); //函数声明 int main( ) {int n; //n为需要求阶乘的整数 long y; //y为存放n!的变量
  • 63. cout<<″please input an integer :″; //输入的提示 cin>>n; //输入n y=fac(n); //调用fac函数以求n! cout<1时,进行递归调用 return f; //将f的值作为函数值返回 }
  • 64. 运行情况如下: please input an integer:10↙ 10!=3628800 许多问题既可以用递归方法来处理,也可以用非递归方法来处理。在实现递归时,在时间和空间上的开销比较大,但符合人们的思路,程序容易理解。
  • 65. 上一节已介绍了变量的一种属性——作用域,作用域是从空间的角度来分析的,分为全局变量和局部变量。 变量还有另一种属性——存储期(storage duration,也称生命期)。存储期是指变量在内存中的存在期间。这是从变量值存在的时间角度来分析的。存储期可以分为静态存储期(static storage duration)和动态存储期(dynamic storage duration)。这是由变量的静态存储方式和动态存储方式决定的。7.11 Storage Classes(存储类型) 7.11.1 动态存储方式与静态存储方式
  • 66. 所谓静态存储方式是指在程序运行期间,系统对变量分配固定的存储空间。而动态存储方式则是在程序运行期间,系统对变量动态地分配存储空间。 先看一下内存中的供用户使用的存储空间的情况。这个存储空间可以分为三部分,即: (1) 程序区 (2) 静态存储区 (3) 动态存储区 图7.13
  • 67. 数据分别存放在静态存储区和动态存储区中。全局变量全部存放在静态存储区中,在程序开始执行时给全局变量分配存储单元,程序执行完毕就释放这些空间。在程序执行过程中它们占据固定的存储单元,而不是动态地进行分配和释放。 在动态存储区中存放以下数据: ①函数形式参数。在调用函数时给形参分配存储空间。②函数中的自动变量(未加static声明的局部变量,详见后面的介绍)。③函数调用时的现场保护和返回地址等。 对以上这些数据,在函数调用开始时分配动态存储空间,函数结束时释放这些空间。在程序执行过程中,这种分配和释放是动态的,如果在一个程序中两次调用同一函数,则要进行两次分配和释放,而两次分配给此函数中局部变量的存储空间地址可能是不相同的。
  • 68. 如果在一个程序中包含若干个函数,每个函数中的局部变量的存储期并不等于整个程序的执行周期,它只是整个程序执行周期的一部分。根据函数调用的情况,系统对局部变量动态地分配和释放存储空间。 在C++中变量除了有数据类型的属性之外,还有存储类别(storage class) 的属性。存储类别指的是数据在内存中存储的方法。存储方法分为静态存储和动态存储两大类。具体包含4种:自动的(auto)、静态的(static)、寄存器的(register)和外部的(extern)。根据变量的存储类别,可以知道变量的作用域和存储期。
  • 69. 函数中的局部变量,如果不用关键字static加以声明,编译系统对它们是动态地分配存储空间的。函数的形参和在函数中定义的变量(包括在复合语句中定义的变量)都属此类。在调用该函数时,系统给形参和函数中定义的变量分配存储空间,数据存储在动态存储区中。在函数调用结束时就自动释放这些空间。如果是在复合语句中定义的变量,则在变量定义时分配存储空间,在复合语句结束时自动释放空间。因此这类局部变量称为自动变量(auto variable)。自动变量用关键字auto作存储类别的声明。例如:7.11.2 自动变量
  • 70. int f(int a) //定义f函数,a为形参 {auto int b,c=3; //定义b和c为整型的自动变量 ┆ } 存储类别auto和数据类型int的顺序任意。关键字auto可以省略,如果不写auto,则系统把它默认为自动存储类别,它属于动态存储方式。程序中大多数变量属于自动变量。本书前面各章所介绍的例子中,在函数中定义的变量都没有声明为auto,其实都默认指定为自动变量。在函数体中以下两种写法作用相同: ① auto int b,c=3; ② int b,c=3;
  • 71. 有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值,即其占用的存储单元不释放,在下一次该函数调用时,该变量保留上一次函数调用结束时的值。这时就应该指定该局部变量为静态局部变量(static local variable)。7.11.3 用static声明静态局部变量
  • 72. 例7.12 静态局部变量的值。 #include using namespace std; int f(int a) //定义f函数,a为形参 {auto int b=0; //定义b为自动变量 static int c=3; //定义c为静态局部变量 b=b+1; c=c+1; return a+b+c; } int main( ) {int a=2,i; for(i=0;i<3;i++) cout<
  • 73. 运行结果为 7 8 9 先后3次调用f函数时,b和c的值如书中表7.1所示。 图7.14
  • 74. 对静态局部变量的说明: (1) 静态局部变量在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量(即动态局部变量)属于动态存储类别,存储在动态存储区空间(而不是静态存储区空间),函数调用结束后即释放。 (2) 为静态局部变量赋初值是在编译时进行值的,即只赋初值一次,在程序运行时它已有初值。以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的值。而为自动变量赋初值,不是在编译时进行的,而是在函数调用时进行,每调用一次函数重新给一次初值,相当于执行一次赋值语句。
  • 75. (3) 如果在定义局部变量时不赋初值的话,对静态局部变量来说,编译时自动赋初值0(对数值型变量)或空字符(对字符型变量)。而对自动变量来说,如果不赋初值,则它的值是一个不确定的值。这是由于每次函数调用结束后存储单元已释放,下次调用时又重新另分配存储单元,而所分配的单元中的值是不确定的。 (4) 虽然静态局部变量在函数调用结束后仍然存在,但其他函数是不能引用它的,也就是说,在其他函数中它是“不可见”的。 在什么情况下需要用局部静态变量呢? (1) 需要保留函数上一次调用结束时的值。例如可以用下例中的方法求n!。
  • 76. 例7.13 输出1~5的阶乘值(即1!,2!,3!,4!,5!)。 #include using namespace std; int fac(int); //函数声明 int main( ) {int i; for(i=1;i<=5;i++) cout<
  • 77. 运行结果为 1!=1 2!=2 3!=6 4!=24 5!=120 每次调用fac(i),就输出一个i,同时保留这个i!的值,以便下次再乘(i+1)。 (2) 如果初始化后,变量只被引用而不改变其值,则这时用静态局部变量比较方便,以免每次调用时重新赋值。 但是应该看到,用静态存储要多占内存,而且降低了程序的可读性,当调用次数多时往往弄不清静态局部变量的当前值是什么。因此,如不必要,不要多用静态局部变量。
  • 78. 一般情况下,变量的值是存放在内存中的。当程序中用到哪一个变量的值时,由控制器发出指令将内存中该变量的值送到CPU中的运算器。经过运算器进行运算,如果需要存数,再从运算器将数据送到内存存放。如图7.15所示。 图7.157.11.4 用register声明寄存器变量
  • 79. 为提高执行效率,C++允许将局部变量的值放在CPU中的寄存器中,需要用时直接从寄存器取出参加运算,不必再到内存中去存取。这种变量叫做寄存器变量,用关键字register作声明。例如,可以将例7.14中的fac函数改写如下: int fac(int n) {register int i,f=1; //定义i和f是寄存器变量 for(i=1;i<=n;i++) f=f*i; return f; } 定义f和i是存放在寄存器的局部变量,如果n的值大,则能节约许多执行时间。 在程序中定义寄存器变量对编译系统只是建议性(而不是强制性)的。当今的优化编译系统能够识别使用频繁的变量,自动地将这些变量放在寄存器中。
  • 80. 全局变量(外部变量)是在函数的外部定义的,它的作用域为从变量的定义处开始,到本程序文件的末尾。在此作用域内,全局变量可以为本文件中各个函数所引用。编译时将全局变量分配在静态存储区。 有时需要用extern来声明全局变量,以扩展全局变量的作用域。7.11.5 用extern声明外部变量
  • 81. 1. 在一个文件内声明全局变量 如果外部变量不在文件的开头定义,其有效的作用范围只限于定义处到文件终了。如果在定义点之前的函数想引用该全局变量,则应该在引用之前用关键字extern对该变量作外部变量声明,表示该变量是一个将在下面定义的全局变量。有了此声明,就可以从声明处起,合法地引用该全局变量,这种声明称为提前引用声明。
  • 82. 例7.14 用extern对外部变量作提前引用声明,以扩展程序文件中的作用域。 #include using namespace std; int max(int,int); //函数声明 void main( ) {extern int a,b; //对全局变量a,b作提前引用声明 cout<y?x:y; return z; }
  • 83. 运行结果如下: 15 在main后面定义了全局变量a,b,但由于全局变量定义的位置在函数main之后,因此如果没有程序的第5行,在main函数中是不能引用全局变量a和b的。现在我们在main函数第2行用extern对a和b作了提前引用声明,表示a和b是将在后面定义的变量。这样在main函数中就可以合法地使用全局变量a和b了。如果不作extern声明,编译时会出错,系统认为a和b未经定义。一般都把全局变量的定义放在引用它的所有函数之前,这样可以避免在函数中多加一个extern声明。
  • 84. 2. 在多文件的程序中声明外部变量 如果一个程序包含两个文件,在两个文件中都要用到同一个外部变量num,不能分别在两个文件中各自定义一个外部变量num。正确的做法是:在任一个文件中定义外部变量num,而在另一文件中用extern对num作外部变量声明。即 extern int num; 编译系统由此知道num是一个已在别处定义的外部变量,它先在本文件中找有无外部变量num,如果有,则将其作用域扩展到本行开始(如上节所述),如果本文件中无此外部变量,则在程序连接时从其他文件中找有无外部变量num,如果有,则把在另一文件中定义的外部变量num的作用域扩展到本文件,在本文件中可以合法地引用该外部变量num。
  • 85. 分析下例: file1.cpp file2.cpp extern int a,b; int a=3,b=4; int main( ) ┆ {cout<
  • 86. 有时在程序设计中希望某些外部变量只限于被本文件引用,而不能被其他文件引用。这时可以在定义外部变量时加一个static声明。例如: file1.cpp file2.cpp static int a=3; extern int a; int main ( ) int fun (int n) { { ┆ ┆ a=a*n; ┆ } } 7.11.6 用static声明静态外部变量
  • 87. 这种加上static声明、只能用于本文件的外部变量(全局变量)称为静态外部变量。这就为程序的模块化、通用性提供了方便。如果已知道其他文件不需要引用本文件的全局变量,可以对本文件中的全局变量都加上static,成为静态外部变量,以免被其他文件误用。 需要指出,不要误认为用static声明的外部变量才采用静态存储方式(存放在静态存储区中),而不加static的是动态存储(存放在动态存储区)。实际上,两种形式的外部变量都用静态存储方式,只是作用范围不同而已,都是在编译时分配内存的。
  • 88. 函数本质上是全局的,因为一个函数要被另外的函数调用,但是,也可以指定函数只能被本文件调用,而不能被其他文件调用。根据函数能否被其他源文件调用,将函数区分为内部函数和外部函数。7.12 内部函数和外部函数
  • 89. 如果一个函数只能被本文件中其他函数所调用,它称为内部函数。在定义内部函数时,在函数名和函数类型的前面加static。函数首部的一般格式为 static 类型标识符 函数名(形参表) 如 static int fun(int a,int b) 内部函数又称静态(static)函数。使用内部函数,可以使函数只局限于所在文件。如果在不同的文件中有同名的内部函数,互不干扰。通常把只能由同一文件使用的函数和外部变量放在一个文件中,在它们前面都冠以static使之局部化,其他文件不能引用。7.12.1 内部函数
  • 90. (1) 在定义函数时,如果在函数首部的最左端冠以关键字extern,则表示此函数是外部函数,可供其他文件调用。 如函数首部可以写为 extern int fun (int a, int b) 这样,函数fun就可以为其他文件调用。如果在定义函数时省略extern,则默认为外部函数。本书前面所用的函数都是外部函数。 (2) 在需要调用此函数的文件中,用extern声明所用的函数是外部函数。7.12.2 外部函数
  • 91. 例7.15 输入两个整数,要求输出其中的大者。用外部函数实现。 file1.cpp(文件1) #include using namespace std; int main( ) {extern int max(int,int); //声明在本函数中将要调用在其他文件中定义的max函数 int a,b; cin>>a>>b; cout<y?x:y; return z; }
  • 92. 运行情况如下: 7 -34↙ 7 在计算机上运行一个含多文件的程序时,需要建立一个项目文件(project file),在该项目文件中包含程序的各个文件。详细情况请参阅本书的配套书《C++程序设计习题解答与上机指导》。 通过此例可知:使用extern声明就能够在一个文件中调用其他文件中定义的函数,或者说把该函数的作用域扩展到本文件。extern声明的形式就是在函数原型基础上加关键字extern。由于函数在本质上是外部的,在程序中经常要调用其他文件中的外部函数,为方便编程,C++允许在声明函数时省写extern。例7.16程序main函数中的函数声明可写成
  • 93. int max(int,int); 这就是我们多次用过的函数原型。由此可以进一步理解函数原型的作用。用函数原型能够把函数的作用域扩展到定义该函数的文件之外(不必使用extern)。只要在使用该函数的每一个文件中包含该函数的函数原型即可。函数原型通知编译系统:该函数在本文件中稍后定义,或在另一文件中定义。 利用函数原型扩展函数作用域最常见的例子是#include命令的应用。在#include命令所指定的头文件中包含有调用库函数时所需的信息。例如,在程序中需要调用sin函数,但三角函数并不是由用户在本文件中定义的,而是存放在数学函数库中的。按以上的介绍,必须在本文件中写出sin函数的原型,否则无法调用sin函数。sin函数的原型是
  • 94. double sin(double x); 本来应该由程序设计者在调用库函数时先从手册中查出所用的库函数的原型,并在程序中一一写出来,但这显然是麻烦而困难的。为减少程序设计者的困难,在头文件cmath中包括了所有数学函数的原型和其他有关信息,用户只需用以下#include命令: #include 即可。这时,在该文件中就能合法地调用各数学库函数了。