Microsoft Word - 第05章 函数

Transcription

1 第 5 章函数 5.1 函数概述 对于一个较大的程序, 为便于实现一般应将其分为若干个程序模块, 每一个模块实现一个特定的功能 在 C 语言中, 由函数实现模块的功能 函数是 C 程序的构成基础 一个 C 程序可由一个主函数 main() 和若干个子函数构成 像 printf() scanf() 这样的函数是由系统提供的, 其他函数则由用户编写 函数的实现, 将有利于信息隐藏及数据共享, 节省开发时间, 增强程序的可靠性 本章将介绍函数的定义 声明以及调用等内容 此外还将介绍有关作用域和存储类别的概念, 使读者能够了解变量 函数的作用域及生存期, 进而提高对变量和函数的灵活运用能力 先举一个简单的函数调用的例子 例 5-1 简单函数调用 void printstar() printf("******************\n"); void print_message() printf(" Welcome to C\n"); printstar(); print_message(); printstar(); 运行结果为 : ****************** Welcome to C ******************

2 函数可以是系统预定义的, 也可以是用户定义的 前者称为系统函数或标准库函数, 后者称为用户自定义函数 printstar() 和 printf_message() 是用户自定义的函数, 分别用来输出一行 * 号和一行信息 任何一个 C 程序都是从主函数即 main() 的开花括号开始执行, 一直到 main() 的闭花括号为止 在执行过程中, 如果遇到一个函数调用语句, 则暂时中断 main() 函数的执行, 将流程转到被调函数, 执行完被调函数再返回到主函数中断处继续执行, 直到 main() 函数执行完为止 5.2 函数的定义与调用 函数的定义 一个函数必须定义后才能使用 所谓定义函数, 就是编写完成函数功能的程序块 一个 C 函数由函数头与函数体两部分组成, 其一般形式如下 : [< 数据类型 >] < 函数名 > ([ 形式参数列表 ]) /* 函数头 */ 语句 /* 函数体 */ 方括号内的 < 数据类型 > 说明等可以省略, 以下同 下面的例子说明函数的结构 例 5-2 求两个数中的较小值 int min(int x, int y) /* 函数定义 : 求两个数中的较小值 */ return( x < y? x : y ); int a, b, c; printf("please input two integers:\n"); scanf("%d%d", &a, &b); c=min(a, b); /* 函数调用 */ printf("the min is:%d\n", c); 87 第 5 章 函 数

3 C 程序设计基础 ( 第 2 版 ) 运行情况如下 : 88 Please input two integers: 4 6<Enter> the min is:4 1. 函数头函数头的组成形式如下 : [< 数据类型 >] < 函数名 > ([ 形式参数列表 ]) < 数据类型 > 规定函数返回值的类型 如 int min(int x, int y), 表示函数 min 将返回一个 int 类型的值 若 < 数据类型 > 缺省, 有的编译系统表示函数返回值为 int 型, 但有的编译系统不支持默认 int 无返回值的类型是 void 类型, 如例 5-1 中的 printstar() 函数就定义为 void 类型, 代表无返回值 函数名是函数的标识, 它应是一个有效的 C 标识符 C 标准不允许在同一个程序中出现同名的自定义函数名, 但允许自定义函数名与系统库函数名相同, 但不提倡 ; 此外, 不允许自定义函数名与同一程序中的全局变量名 ( 在所有函数外定义及声明的变量称为全局变量, 见 节 ) 相同, 但允许与局部变量名 ( 在某个函数体内声明的变量称为局部变量, 见 节 ) 相同, 也允许与函数的形式参数名相同, 但也不提倡 形式参数简称形参 形参列表是包含在圆括号中的 0 个或多个以逗号分隔的变量定义 它规定了函数将从调用函数中接收几个数据及它们的类型 之所以称为形参, 是因为在定义函数时系统并不为这些参数分配存储空间, 只有被调用, 向它传递了实际参数 ( 简称实参 ) 时才为形参分配存储空间 如例 5-2, 变量 a b 是实参, 而变量 x y 是形参 2. 函数体一个函数体是用花括号括起来的语句序列 它描述了函数实现一个功能的过程, 并要在最后执行一个函数返回 返回的作用是 : 将流程从当前函数返回其上级 ( 调用函数 ); 撤销函数调用时为各参数及变量分配的内存空间 ; 向调用函数返回最多一个值 一般来说, 函数返回由返回语句来实现 如例 5-2 中的 return( x < y? x : y ); 就可以执行上述三个功能 return 语句的一般形式为 : 或 或 return 表达式 ; return ( 表达式 ); return;

4 包含表达式的返回语句实现过程如下 (1) 先计算出表达式的值 (2) 如果表达式的类型与函数的返回值类型不相同, 则将表达式的类型自动转换为函数的类型, 这种转换是强制性的 (3) 将计算出的表达式的值返回到调用处作为调用函数的值 (4) 将程序执行的控制由被调函数转向调用函数, 执行调用函数后面的语句 关于 return 语句的使用说明如下 (1) 有返回值的 return 语句, 用它可以返回一个表达式的值, 从而实现函数之间的信息传递 (2) 无返回值的函数返回值类型部分需使用关键字 void 该函数中可以有 return 语句, 也可以无 return 语句 当被调函数中无 return 语句时, 程序执行完函数体的最后一条语句后返回调用函数, 相当于函数体的右括号有返回功能 (3) 一个函数体中可以有多个 return 语句, 但每次只能通过一个 return 语句执行返回操作 例 5-3 返回一个整数的绝对值 int abs(int x) if(x>=0) return x; else return -x; 一个函数体中有多个 return 语句时, 如例 5-3 中有两个 return 语句, 每个 return 语句的返回值类型都应与函数定义一致, 否则将自动转换 函数可以只执行一个功能而不向调用函数返回任何值, 如例 5-1 中的 printstar() 函数就是这样 如果有 return 语句, 这时 return 语句后的表达式是空的, 它只执行将流程返回以及撤销函数中定义的动态变量 ( 包含参数变量 ) 空的 return 语句位于函数末尾时可以缺省, 由函数体后的花括号执行返回功能 C 语法规定在一个函数定义的内部不允许出现另一个函数定义, 即不允许嵌套定义 函数的调用 调用函数是实现函数功能的手段 在程序中, 一个函数调用另一个函数即将程序执行流程转移到被调函数 要正确实现函数间的相互调用必须满足以下条件 (1) 被调函数必须已定义且允许调用 (2) 给出满足函数运行时要求的参数 (3) 如果调用函数在前, 定义函数在后, 必须对被调函数进行原型声明 ( 见 5.3 节相关内容 ) 函数的调用形式如下 : 89 第 5 章 函 数

5 C 程序设计基础 ( 第 2 版 ) < 函数名 > ( 实参列表 ) 90 其中, 实参列表是由 0 个 1 个或多个实参构成, 多个参数之间用逗号分隔, 每个参数是一个表达式 即使实参列表中没有参数, 括号也不能省略 实参是用来在调用函数时给形参初始化的, 一般要求在函数调用时, 实参的个数和类型必须与形参的个数和类型一致, 即个数相等, 类型相同 实参对形参的初始化是按其位置对应进行, 即第一个实参的值赋给第一个形参, 第二个实参的值赋给第二个形参, 以此类推 例 5-2 中的值传递如图 5-1 所示, 相当于在函数参数传递时有 int x=a; int y=b; 图 5-1 值传递 C 语言中的函数调用是传值调用 使用这种方式调用, 实参可以是常量 变量和表达式 系统先计算实参表达式的值, 再将实参的值按位置对应地赋给形参, 即对形参进行初始化 因此, 传值调用的实现是系统将实参复制一个副本给形参, 形参和实参分别占用不同的存储单元 在被调函数中可以改变形参, 但这只影响形参的值, 而不影响调用函数中实参的值, 也就是说是单向值传递 所以传值调用的特点是形参值的改变不影响实参 下面举一个函数调用的例子 例 5-4 理解函数调用 void swap(int x, int y) int t; t=x; x=y; y=t; printf("x=%d, y=%d\n", x, y); int a=4, b=5; swap(a, b); printf("a=%d, b=%d\n", a, b); 运行结果为 : x=5, y=4 a=4, b=5

6 从该程序的结果看, 在 swap() 函数中, 形参 x 和 y 的值交换了, 而在 main() 函数中, 实参 a 和 b 的值并没有发生变化, 可见 swap() 函数中形参值的改变并没有影响实参 a 和 b 的值 函数的参数 当一个函数带有多个参数时, 标准 C 语言没有规定在函数调用时实参的求值顺序, 而由编译器根据对代码进行优化的需要自行规定对实参的求值顺序 有的编译器规定自左至右, 有的编译器规定自右至左, 这种对求值顺序的不同规定对一般参数来讲没有影响 但是, 如果实参表达式中存在带有副作用的运算符时, 就有可能产生由于求值顺序不同而造成的二义性 下面是一个由于使用求值顺序不同的编译器造成二义性的例子 例 5-5 使用求值顺序不同的编译器造成二义性 int fun(int a, int b) return b; int x=5, y=6; int z=fun(--x, x+y); printf("z=%d\n", z); 该程序中, 调用如下 : z=fun(--x, x+y); 其中, 实参是两个表达式 x 和 x+y 如果编译器对实参求值顺序是自左至右的,x+y 的值为 10, 结果 z 的值也为 10 如果编译器对实参求值顺序是自右至左的,x+y 的值为 11, z 的值也为 11 z 的值由于实参值的不同, 调用 fun() 函数后返回值也不同, 于是造成了在不同编译器下输出不同的结果 克服这种二义性的方法是改变 fun() 函数的两个实参的写法, 尽量避免二义性的出现 如 main() 函数可改写如下 : int x=5, y=6; int w=--x; int z=fun(w, x+y); 91 第 5 章 函 数

7 C 程序设计基础 ( 第 2 版 ) 92 printf("z=%d\n", z); 可见, 修改后对函数 fun() 的两个实参表达式, 无论求值顺序怎样结果都是一样的 这样就避免了二义性的出现 在 VS2010 中函数参数的求值顺序是自左至右的 5.3 函数的原型声明 在 C 语言中, 当函数定义在前 调用在后时, 调用前可以不必声明 ; 如果一个函数的定义在后, 调用在前, 此时在调用前必须声明函数的原型 按照上述原则, 凡是被调函数都在调用函数之前定义, 可以对函数不加声明 但是, 这样做在安排函数顺序时要花费很多精力, 在复杂的调用中, 一定要考虑好谁先谁后, 否则将发生错误 为了避免这个问题, 并且使程序逻辑结构清晰, 常常将主函数放在程序开头, 这样就需要在函数调用之前对被调函数进行原型声明 函数原型声明的一种方法是将函数原型声明放在函数调用之前, 另一种方法是将函数原型声明放在所有函数之前 函数原型声明的一般格式如下 : [< 数据类型 >] < 函数名 > ([ 形式参数列表或形式参数类型列表 ]); 这种声明类似于定义函数时的函数头 这里, 类型是该函数返回值的类型, 函数原型声明中可以仅给出每个参数的类型, 也可以指明每个参数名及其类型 声明函数原型的目的是告诉编译程序该函数的返回值类型 参数个数和各个参数的类型, 以便其后调用该函数时, 编译程序对该函数调用时的参数类型 个数 顺序及函数的返回值进行有效性检查 下面是一个使用原型声明的例子 例 5-6 使用原型声明 int min(int, int); /* 函数原型声明 */ int a, b, c; printf("please input two integers:\n"); scanf("%d%d", &a, &b); c=min(a, b); /* 函数调用 */ printf("the min is:%d\n", c); int min(int x, int y) /* 函数定义 : 求两个数中的较小值 */ int z;

8 z = x < y? x : y; return(z); 上例中的原型声明也可以写成 : int min(int x, int y); /* 变量名不用 x,y 而用其他变量名也可以 */ 注意 : 在 C 语言中函数的原型声明是一个语句, 其后的分号不可缺少 ; 函数的原型声明可以放在主函数中, 也可以放在所有函数前, 且对一个函数的原型声明次数没有限制 函数原型中可以只依次声明参数类型而不给出参数名的原因将在 节中说明 下面再举一个例子进一步说明函数的使用 例 5-7 验证哥德巴赫猜想 : 一个大偶数可以分解为两个素数之和 试编写程序, 将 96~100 的全部偶数分解成两个素数之和 #include<math.h> int prime(int a) int i, k; k=(int)sqrt(a); for (i=2; i<=k; i++) if (a%i==0) return 1; int a, b, m; for (m=96; m<=100; m=m+2) for (a=2; a<=m/2; a++) if (prime(a)) b=m-a; if (prime(b)) printf("%d=%d+%d\n", m, a, b); break; /* 如果没有 break, 则找出所有组合 */ 93 第 5 章 函 数

9 C 程序设计基础 ( 第 2 版 ) 运行结果为 : 94 96= = = 函数的嵌套调用和递归调用 函数的嵌套调用 C 语言的函数定义都是互相平行的 独立的 C 语言规定不能嵌套定义函数, 但可以嵌套调用函数 所谓嵌套调用是在调用一个函数的过程中又调用另一个函数, 如图 5-2 所示 图 5-2 嵌套调用图示 图 5-2 表示的是两层嵌套 ( 包含 main() 函数共三层 ), 其执行过程如下 : 1 执行 main() 函数的开头部分 ; 2 遇调用函数 fun1() 的语句, 流程转去执行 fun1() 函数 ; 3 执行 fun1() 函数的开头部分 ; 4 遇调用函数 fun2() 的语句, 流程转去执行 fun2() 函数 ; 5 执行 fun2() 的函数体 ; 6 返回调用 fun2() 函数处, 即返回 fun1() 函数 ; 7 继续执行 fun1() 函数尚未执行的部分, 直到 fun1() 函数结束 ; 8 返回 main() 函数中调用 fun1() 函数处 ; 9 继续执行 main() 函数的剩余部分直到结束 嵌套调用是经常使用的, 下面举例说明 例 5-8 编写程序, 求两个数 a b 的最大公约数和最小公倍数 利用辗转相除法 ( 又称欧几里得算法 ) 如下 : 1 求 a 除以 b 的余数 r; 2 如余数 r 为 0, 则 b 是最大公约数, 算法结束, 否则执行下一步 ; 3 将除数作为新的被除数, 余数作为新的除数, 即令 a=b,b=r, 转 1

10 int gcd(int x, int y) int r; while ((r=x%y)!=0) x=y; y=r; return(y); int lcm(int x, int y) int bs, ys; ys=gcd(x, y); /* 调用求最大公约数的函数 */ bs=x*y/ys; return bs; int x, y, g, bs; printf("please input two integers:\n"); scanf("%d%d", &x, &y); g=gcd(x, y); bs=lcm(x, y); printf("the greatest common divisor:%d\nthe lease common multiple:%d\n", g, bs); 运行结果如下 : Please input two integers: 21 35<Enter> the greatest common divisor:7 the lease common multiple:105 程序中的 gcd() 和 lcm() 函数均是定义在调用之前, 故没有进行单独的函数原型声明 例 5-9 k 编写程序, 输入 k 和 n, 求出多项式 i 的值 long int sum_of_power(int k, int n),power(int m, int n);/* 声明函数的原型 */ n i=1 95 第 5 章 函 数

11 C 程序设计基础 ( 第 2 版 ) 96 int k, n; printf("please input k and n:"); scanf("%d%d",&k, &n); printf("sum of %d power of integers from 1 to %d =", k, n); printf("%d\n", sum_of_power(k,n)); long int sum_of_power(int k, int n) int i; long int sum=0; for (i=1; i<=n; i++) sum+=power(i,k); return sum; long int power(int m, int n) int i; long int product=1; for(i=1; i<=n; i++) product*=m; return product; 运行情况如下 : Please input k and n:5 10<Enter> sum of 5 power of integers from 1 to 10 = 由于 i k 可能是一个比较大的数, 故将 power() 函数中的 product 变量声明为 long int 类型 例 5-10 用弦截法求方程 x 4 +4x 3 3x 2 +5x+6=0 的根 方法如下 1 确定求值区间 输入两个不同点 x 1 x 2, 直到 f (x 1 ) 和 f (x 2 ) 异号为止 注意,x 1 x 2 的值不应相差太大, 以保证 (x 1, x 2 ) 区间内只有一个根 2 连接 f (x 1 ) 和 f (x 2 ) 两点, 此线 ( 称为弦 ) 交 X 轴于点 x, 如图 5-3 所示

12 x 点坐标可用下式求出 : 图 5-3 弦截法示意图 x1 f(x 2) x2 f(x 1) x f(x ) f(x ) 2 1 再求出 f (x) 3 若 f (x) 与 f (x 1 ) 同号, 则根必在 (x, x 2 ) 区间内, 此时将 x 作为新的 x 1 如果 f (x) 与 f (x 2 ) 同号, 则表示根在 (x 1, x) 区间内, 将 x 作为新的 x 2 4 重复步骤 2 和 3, 直到 f (x) < 为止 ( 为一个很小的数, 例如 10 6 ) 此时认为 f (x) 0 分别用以下几个函数来实现各部分的功能 (1) 用 f (x) 来求 x 的函数 :x 4 +4x 3 3x 2 +5x+6=0 (2) 用函数 xpoint(x1, x2) 求 f (x 1 ) 和 f (x 2 ) 的连线与 X 轴的交点 x 的坐标 (3) 用函数 root(x1, x2) 求 (x 1, x 2 ) 区间的实根 显然执行 root() 函数过程中要用到函数 xpoint(), 而执行 xpoint() 函数过程中要用到 f() 函数 #include<math.h> double f(double x); /* 声明函数的原型 */ double xpoint(double x1, double x2); /* 声明函数的原型 */ double root(double x1, double x2); /* 声明函数的原型 */ /* 主函数 */ double x1, x2, x, f1, f2; do printf("input x1, x2:\n"); scanf("%lf%lf", &x1, &x2); f1=f(x1); f2=f(x2); while( (f1*f2)>=0 ); x=root(x1, x2); 97 第 5 章 函 数

13 C 程序设计基础 ( 第 2 版 ) printf("a root of equation is %lf \n", x); 98 double f(double x) /* 定义函数, 求 f(x)=x 4 +4x 3-3x 2 +5x+6 */ return((((x+4.0)*x-3.0)*x+5.0)*x+6.0); double xpoint(double x1, double x2) /* 定义 xpoint() 函数, 求出弦与 X 轴交点 */ return((x1*f(x2)-x2*f(x1))/(f(x2)-f(x1))); double root(double x1, double x2) /* 定义 root() 函数, 求近似根 */ double x, y, y1; y1=f(x1); do x=xpoint(x1, x2); y=f(x); if ( y*y1>0 ) y1=y; x1=x; else x2=x; while( fabs(y)>=1e-6); return(x); 运行结果如下 : input x1, x2: 10-2<Enter> A root of equation is 从例 5-10 中可以看到 : (1) 在定义函数时, 函数名为 f xpoint root 的三个函数是相互独立的, 并不相互从属 这三个函数均定义为双精度实型 (2) 在 main() 函数外对上述三个函数进行了原型声明 (3) 程序从 main() 函数开始执行 先执行一个 do-while 循环, 作用是 : 输入 x1 和 x2, 判别 f(x1) 和 f(x2) 是否异号, 如果不是异号则重新输入 x1 和 x2, 直到满足 f(x1) 与 f(x2) 异号为止 然后调用 root(x1, x2) 求根 x 调用 root() 函数的过程中, 要调用 xpoint() 函数求 f(x1) 与 f(x2) 连线的交点 x; 在调用 xpoint() 函数过程中要用到求函数 f 在 x1 和 x2 时的相应的函数值 f(x1) 和 f(x2) 这就是函数的嵌套调用, 如图 5-4 所示

14 图 5-4 求方程的根的嵌套调用图示 (4) 在 root() 函数中要用到求绝对值的函数 fabs(), 它是对实型数求绝对值的标准数学库函数, 因此在文件开头有 #include<math.h>, 即把数学库函数的函数原型声明等信息包含进来 函数的递归调用 在一个函数的执行过程中直接或间接地调用该函数本身, 称为函数的递归调用 C 语言中允许函数的递归调用 在调用函数 f() 的过程中, 又要调用 f() 函数, 这是直接调用本函数, 称为直接递归调用, 如图 5-5 所示 在调用函数 f1() 的过程中要调用函数 f2(), 而在函数 f2() 的执行过程中又要调用函数 f1(), 这是间接调用函数 f1(), 称为间接递归调用, 如图 5-6 所示 f( ) f( ) f1( ) f2( ) f2( ) f1( ) 图 5-5 函数的直接递归调用 图 5-6 函数的间接递归调用 程序中不应该出现无终止的递归调用, 而只应出现有限次的 有终止的递归调用 这可以用 if 语句来控制, 只有在某一条件成立时才继续执行递归调用, 否则就不再继续 下面举例说明递归调用的过程 例 5-11 递归计算 n! 其中 n! 可以递归地描述为 : 非法 n<0 n!= 1 n=0 或 n=1 n*(n 1)! n>1 float fac(int); int n; float y; 99 第 5 章 函 数

15 C 程序设计基础 ( 第 2 版 ) 100 printf("please input an integer number:\n"); scanf("%d", &n); y=fac(n); if(n>=0) printf("%d!=%f\n", n, y); float fac(int n) /* 该函数求 n! */ float f; if (n<0) printf("n<0,data error!\n"); return(-1); else if (n==0 n==1) f=1; else f=fac(n-1)*n; return(f); 运行结果如下 : Please input an integer number: 4<Enter> 4!= 递归调用的具体过程如图 5-7 所示 图 5-7 求 n! 的递归调用图示例 5-12 用递归实现求两个数的最大公约数 用前面介绍的辗转相除法求两个数的最大公约数的过程可以递归地描述为 : b a%b=0 gcd(a,b)= gcd(b, a%b) a%b 0 int gcd(int,int); /* 在所有函数外进行函数原型声明 */

16 int a, b, g; printf("please input two integers :a, b\n"); scanf("%d%d", &a, &b); g=gcd(a, b); printf("the greatest common divisor of %d and %d is %d\n", a, b, g); int gcd(int a, int b) if(a%b==0) return b; else return gcd(b, a%b); 运行结果如下 : Please input two integers :a, b 21 35<Enter> the greatest common divisor of 21 and 35 is 7 例 5-13 汉诺塔 (Tower of Hanoi) 问题 问题是 : 古代有一个梵塔, 塔内有 3 根钻石做的柱子, 其中一根柱子上有 64 个金子做的盘子 64 个盘子从下到上按照由大到小的顺序叠放 僧侣的工作是将这 64 个盘子从柱子 1 上移动到柱子 3 上 移动的规则如下 (1) 每次只能移动一个盘子 (2) 移动的盘子必须放在其中一根柱子上 (3) 大盘子在移动过程中不能放在小盘子上 本例的目标是编写一个程序, 该程序可以输出将盘子从柱子 1 上转移到柱子 3 上的过程中每一步移动的顺序 下面用递归来思考 (1) 考虑柱子 1 上只有 1 个盘子的情况, 这样盘子可以从柱子 1 上直接移动到柱子 3 上 (2) 考虑柱子 1 上有 2 个盘子的情况, 方法如下 1 将第 1 个盘子从柱子 1 上移动到柱子 2 上 2 第 2 个盘子从柱子 1 上移动到柱子 3 上 3 将第 1 个盘子从柱子 2 上移动到柱子 3 上 (3) 考虑柱子 1 上包含 3 个盘子的情况, 这样可以一直推广到 64 个盘子的情况 ( 实际上, 可以推广到任意数目的盘子 ) 假设柱子 1 上有 3 个盘子, 方法如下 1 为了将盘子 3 移动到柱子 3 上, 前两个盘子必须先移动到柱子 2 上, 然后将盘子 3 从柱子 1 上移动到柱子 3 上 2 为了将前两个盘子从柱子 2 上移动到柱子 3 上, 使用如上相同的策略 这一次要函 数 101 第 5 章

17 C 程序设计基础 ( 第 2 版 ) 102 将柱子 1 作为中间柱子 将这个问题推广到 64 个盘子的情形, 方法如下 1 将上面的 63 个盘子从柱子 1 上移动到柱子 2 上 2 再将盘子 64 从柱子 1 上移动到柱子 3 上 3 现在, 前面的 63 个盘子都在柱子 2 上 为了将盘子 63 从柱子 2 上移动到柱子 3 上, 首先要将前 62 个盘子从柱子 2 上移动到柱子 1 上, 接着再将盘子 63 从柱子 2 上移动到柱子 3 上 按照相似的过程移动剩下的 62 个盘子 经过上面的讨论, 得到该递归算法如下 假设柱子 1 上有 n 个盘子, 并且 n 1 1 以柱子 3 作为中间柱子, 将前 n 1 个盘子从柱子 1 上移动到柱子 2 上 2 将盘子 n 从柱子 1 上移动到柱子 3 上 3 以柱子 1 作为中间柱子, 将前 n 1 个盘子从柱子 2 上移动到柱子 3 上 void hanoi(int, char, char, char); void move(char, char); int m; printf("input the number of diskes:\n"); scanf("%d", &m); printf("the step to moving %d diskes:\n", m); hanoi(m, 'A', 'B', 'C'); void hanoi( int n, char one, char two, char three) 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 getone, char putone)

18 printf("%c-->%c\n", getone, putone); 运行结果如下 : input the number of diskes: 3<Enter> The step to moving 3 diskes: A-->C A-->B C-->B A-->C B-->A B-->C A-->C 若将 n 个盘子从柱子 1 上移到柱子 3 上, 那么要移动 2 n 1 次 例如 n=64, 要移动 次 如果一个人一秒钟能正确地移动一个盘子, 那么要用 年才能移完所有的盘子 下面采用数学归纳法证明要移动 2 n 1 次 (1) 当 n=1 时, 即柱子 1 上只有一个盘子时, 只要移动一次即可, 满足 2 1 1=1, 公式成立 (2) 假设 n=k 时公式成立, 即柱子 1 上有 k 个盘子时, 要移动 2 k 1 次 (3) 当 n=k+1 时, 即柱子 1 上有 k+1 个盘子时, 首先将柱子 1 上面的 k 个盘子移到柱子 2 上, 这需要移动 2 k 1 次 ; 然后将柱子 1 上剩下的一个盘子直接移动到柱子 3 上, 需要移动 1 次 ; 最后将柱子 2 上的 k 个盘子移到柱子 3 上需要 2 k 1 次, 所以总的移动次数为 2 k k 1=2 k+1 1, 显然公式成立 请读者自己分析例 5-12 和例 5-13 中递归调用的执行过程 何时应采用递归解决问题呢? 要满足如下两个条件 (1) 能把问题规模变小 可将要解决的问题转化为一个新的问题, 而新的问题的解法仍与原来的解法相同, 只是所处理的问题规模有规律地递减, 如 n!=n*(n 1)! 这时可应用这个转化过程使问题得到解决 (2) 能确定终结条件 必须有一个明确的结束递归的条件, 如 n==0 n==1 时,n! 的值为 1 需要说明的是, 对于同一个问题既可采用循环解决又可采用递归解决时, 采用循环的效率要高于递归, 因为递归需要大量的额外开销 5.5 使用 C 系统函数 C 的编译系统提供了很多函数供编程者调用 本节将介绍使用系统函数的方法 C 将系统函数的原型声明分类放在不同的.h 文件 ( 又称头文件 ) 中 例如, 有关数学的常用函数, 如求绝对值函数 求平方根函数和三角函数等, 函数原型声明放在 math.h 文件中 ; 判断字母 数字 大写字母 小写字母等函数原型声明放在 ctype.h 文件中 ; 有关字函 数 103 第 5 章

19 C 程序设计基础 ( 第 2 版 ) 104 符串处理的函数原型声明放在 string.h 文件中 ; 等等 因此, 编程者在使用 C 系统函数时应注意以下几点 (1) 了解 C 提供了哪些系统库函数 不同的 C 编译系统提供的系统函数不同 ; 同一种 C 编译系统的不同版本所提供的系统函数的多少也不一定相同 只有了解系统所提供的系统函数后, 才能根据需要选用 阅读 C 编译系统的使用手册可以了解该系统所提供的系统函数, 手册中会给出各种系统函数的功能 函数的参数 返回值以及函数的使用方法 另外, 也可以通过联机帮助了解一些系统函数的简单情况 (2) 必须知道某个系统函数的声明在哪个头文件中 因为要调用某个系统函数, 必须将该系统函数的声明所在的头文件包含在调用的程序中, 否则将出现连接错误 例如, 当使用 sqrt() 函数求某个数的平方根时, 就需要在程序中包含 math.h 头文件 (3) 调用一个函数时, 一定要将该函数的功能 函数的返回值及各参数的含义弄清楚, 否则难以正确调用该函数 例 5-14 将输入的三个字母转换成大写字母后输出 #include<ctype.h> /* A */ #define N 3 int i; char c; printf("please input %d characters:\n", N); for(i=0; i<n; i++) scanf("%c", &c); if(islower(c)) /* B */ c-=32; printf("%c\t", c); printf("\n"); 如果缺少 A 行, 在有些编译器中会报错, 而在 VS2010 则出现一个警告信息 : warning C4013: 'islower' 未定义 因为这里使用了 islower() 函数 (B 行 ), 所以要包含 ctype.h 头文件 islower() 函数用于判断参数字符 c 是否是小写字母, 若是则返回非 0 整数, 否则返回 0 在解决一些商业和科学问题时, 要求采用取样技术 例如, 汽车加油站的汽车流量模

20 型要求有统计模型 另外, 类似计算机游戏等应用也只能由统计学描述 所有这些统计学模型都要求产生随机数 次序不能被预知的一系列数 在大多数情况下只能产生伪随机数, 这对要完成的任务是充分随机的 所有的 C 语言编译器为产生随机数提供了两个函数 : rand() 和 srand(), 它们的函数原型声明在 stdlib.h 头文件中 rand() 函数生成一系列随机数, srand() 函数为 rand() 函数设定一个开始的 种子 值 如果不采用 srand() 函数或者其他等效的技术, 则每次运行程序,rand() 函数将总是产生相同的随机数序列 例 5-15 产生 10 个随机数并输出 #include<stdlib.h> #include<time.h> #define N 10 int i; double randnumber; srand(time(null)); /* A:time() 生成一个时间值, 用作 " 种子 " */ for(i=0; i<n; i++) randnumber=rand(); printf("%8.0lf\n", randnumber); 注意 A 行,time(NULL) 返回从 1970 年 1 月 1 日 00:00:00 开始到目前为止的秒数 ( 具体请参考有关库函数手册 ), 然后 srand() 函数使用这个值初始化 rand() 函数 下面是例 5-15 程序的一次运行结果 : 每次执行该程序, 都将产生不同的 10 个随机数, 请读者思考其原因 105 第 5 章 函 数

21 C 程序设计基础 ( 第 2 版 ) 5.6 作用域和存储类别 106 作用域即作用范围, 它是指所定义的标识符在哪一个区间内有效, 即在哪一个区间内可以使用 在程序中出现的各种标识符, 它们的作用域是不同的 C 语言的作用域分为四种 : 块作用域 文件作用域 函数原型作用域和函数作用域 存储类别决定了何时为变量分配存储空间及该存储空间所具有的特征 在定义变量时, 应指定变量的存储类别 作用域 标识符只能在声明它或定义它的范围内进行存取, 而在该范围之外不可以进行存取 下面逐一介绍这四种作用域 1. 块作用域 C 语言中把用花括号括起来的一部分程序称为块 在一个块中声明的标识符, 其作用域从声明点开始到该块结束为止 例如 : float f(int a) /* 函数 f */ int b, c; a b c 有效 /* 主函数 */ int m, n; f(m); m n 有效 在一个函数内部定义的变量或在一个块中定义的变量称为局部变量 如上例中的所有变量均为局部变量 在一个函数内定义的局部变量, 在退出函数时, 局部变量就不存在了 ; 在块内定义的变量, 在退出该块时, 块作用域内的局部变量也就不存在了 例 5-16 分析下列程序的输出结果 void swap(int a, int b) printf("(2)%d\t%d\n", a,b); if(a<b)

22 int t; /* t 是局部变量, 具有块作用域, 退出该复合语句后 t 不能使用 */ t=a; a=b; b=t; printf("(3)%d\t%d\n", a, b); int a, b; printf("please input two integers:\n"); scanf("%d%d", &a, &b); printf("(1)%d\t%d\n", a, b); swap(a, b); printf("(4)%d\t%d\n", a, b); 运行结果如下 : Please input two integers: 12 34<Enter> (1)12 34 (2)12 34 (3)34 12 (4)12 34 说明 : (1) 形参是局部变量 例如 swap() 函数中的形参 a b, 只是在 swap() 函数内有效, 其他函数不能调用 (2) 主函数 main() 中定义的局部变量 a b 只在主函数中有效,swap() 函数中定义的 a b 只在 swap() 函数中有效 尽管它们的名字相同, 但代表不同的对象, 在内存中占不同的存储单元, 互不干扰 (3) 具有块作用域的标识符在其作用域内, 将屏蔽在本块有效的同名标识符, 即局部定义优先 下面的例子说明了局部变量同名时局部定义优先 例 5-17 理解局部定义优先 函 数 107 第 5 章

23 C 程序设计基础 ( 第 2 版 ) int a=1, b=2; /* 块 A 开始 */ a; ++b; int b=4, c; c=a+b; /* c 只能在该复合语句内使用 */ printf("a=%d,b=%d,c=%d\n", a, b, c); printf("a=%d,b=%d\n", a, b); 块 B 块 A 根据以上规则, 块 B 中定义的变量 b 屏蔽了块 A 内的变量 b 因此, 在块 B 内使用的变量 b 是本块内定义的变量 b, 而不是块 A 内定义的变量 b 一旦退出块 B, 块 B 内定义的变量 b c 就不存在了 程序运行结果如下 : a=2, b=4, c=6 a=2, b=3 2. 文件作用域文件是 C 语言的编译单位 文件作用域是在所有函数外声明的, 其作用域从声明点开始, 一直延伸到本文件结束 通常把超出一个函数的作用域称为全局作用域, 其他几种不超出一个函数的作用域称为局部作用域 在函数外定义的变量称为全局变量 全局变量的默认作用域是 : 从定义全局变量的位置开始到该源程序文件结束, 即符合标识符先定义后使用的原则 当全局变量出现先引用后定义时, 要用 extern 对全局变量做外部声明, 其方法在后面介绍 ( 见例 5-20) 当在块作用域内的变量与全局变量同名时, 局部变量优先 3. 函数原型作用域在函数原型的参数列表中声明的参数名, 其作用域只在该函数原型内, 称为函数原型作用域 因此, 在函数原型中声明的标识符可以与函数定义中声明的标识符不同 由于所声明的标识符与该函数的定义及调用无关, 因此可以在函数原型声明中只做参数的类型声明, 而省略参数名 例如 : float max(float a, float b); /* 函数 max() 的原型声明 */ float max(float x, float y) /* 函数 max() 的定义 */

24 由于可以省略函数原型声明中的参数名, 因此函数 max() 的原型声明也可以写成 : float max(float, float); 4. 函数作用域作为 goto 语句转移目标的标志, 标号具有函数作用域 在本函数内所给出的标号, 无论它在什么地方, 都可以用 goto 语句引用它 但是不能用 goto 语句把流程转到其他函数体内 语句标号是唯一具有函数作用域的标识符 例如 : void f1() label1: if( ) goto label1; if( ) goto label2; /* A */ void f2() label2: 编译上述程序时, 会指出 A 行的标号 label2 没有定义 存储类别 前面已经介绍了, 从变量的作用域角度来分, 可以分为全局变量和局部变量 从变量值存在的时间角度来分, 可以分为静态存储变量和动态存储变量 存储类别规定了变量在整个程序运行期间的存在时间 ( 即生存期 ) 一个 C 源程序经编译和连接后, 产生可执行程序 要执行该程序, 系统必须为程序分配内存空间, 并将程序装入所分配的内存空间内 一个程序在内存中占用的存储空间可以分为三个部分 : 程序区 静态存储区和动态存储区, 程序区如图 5-8 所示 程序区用来存放可执行程序的代码 变量一般存储在静态存储区和静态存储区动态存储区中 分配在静态存储区中的变量为静态变量, 分配在动态存动态存储区储区中的变量为动态变量 将变量存放在哪个区中是由变量的存储类别所决定的, 而存储类别是由程序设计者根据程序设计的需要指定的 下图 5-8 程序在内存面分别介绍局部变量和全局变量的存储类别 中占用的存储空间 1. 局部变量的存储类别在 C 语言中, 局部变量的存储类别有以下三种 : 自动变量 (auto) 函 数 109 第 5 章

25 C 程序设计基础 ( 第 2 版 ) 110 静态变量 (static) 寄存器变量 (register) 在声明或定义时, 存储类别声明符应放在数据类型声明符之前 格式如下 : [< 存储类别 >] < 数据类型 > < 标识符 >[=< 初始化表达式 >]; 1) 自动变量自动变量被分配在动态存储区中 在程序执行期间, 当执行到变量作用域开始处时, 系统动态地为变量分配存储空间, 而当执行到作用域结束处, 系统收回这种变量所占用的存储空间 自动变量用关键字 auto 进行存储类别声明, 例如 : int f(int a) auto int b, c=2; /* 定义 b c 为自动变量 */ 关键字 auto 可以省略, 即局部变量的默认存储类别是 auto 在本节之前介绍的函数以及函数形式参数中定义的变量都没有存储类别声明, 默认指定为自动变量 在本例的函数体中, auto int b, c=2; 与 int b, c=2; 等价 注意 : 对于自动变量, 若没有明确地赋初值, 则其初值是不确定的 如上例中的 b 没有确定的初值 2) 静态变量局部静态变量被分配在静态存储区中 有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值, 即占用的存储单元不释放, 则在下一次调用该函数时, 该变量已有值, 就是上一次函数调用结束时的值 这时就应该指定该局部变量为静态存储类别, 用关键字 static 进行声明 下面通过例子说明它的特点 例 5-18 考察局部静态变量的值 int fun (int x) static int a=3; /* 定义局部静态变量 */ a+=x; return(a); int k=2, m=1, n; n=fun(k);

26 printf("first: n=%d\n", n); n=fun(m); printf("second: n=%d\n", n); 程序运行结果为 : first: n=5 second: n=6 在第一次调用 fun() 函数时 a 的初值为 3, 第一次调用结束时,a 的值为 5 由于 a 是局部静态变量, 在函数调用结束后, 系统并不释放变量的空间, 仍保留 a 的值为 5, 则在第二次调用 fun() 函数时,a 的初值为 5( 上次调用结束时的值 ) 对局部静态变量的几点说明如下 1 局部静态变量属于静态存储类别, 在静态存储区内分配存储单元 在程序整个运行期间始终存在 2 局部静态变量的初始化仅在程序开始执行时处理一次, 在程序运行时它的值始终存在 以后每次调用函数时不再重新分配空间和赋初值, 而保留上次函数调用结束时的值 而自动变量赋初值是在函数调用时进行的, 每调用一次函数会重新分配空间并赋一次初值 3 局部静态变量的默认初值为 0( 对数值型变量 ) 或空字符 '\0'( 对字符变量 ) 4 虽然局部静态变量在函数调用结束后仍然存在, 但其他函数不能引用它 若要保留函数上一次调用结束时的值, 则需要用局部静态变量 例如, 用例 5-19 的方法求 n! 例 5-19 打印 1~5 的阶乘值 int fac(int n); int i; for (i=1; i<=5; i++) printf("%d!=%d\n", i, fac(i)); int fac(int n) static int f=1; 111 第 5 章 函 数

27 C 程序设计基础 ( 第 2 版 ) 112 f=f*n; return(f); 程序运行结果为 : 1!=1 2!=2 3!=6 4!=24 5!=120 每次调用 fac(i), 打印出一个 i!, 同时保留这个 i! 的值以便下次再乘以 (i+1) 得到 (i+1) 的阶乘 如果将上述程序中的 static 去掉, 则程序运行结果变为 : 1!=1 2!=2 3!=3 4!=4 5!=5 显然结果是不正确的 原因是将变量 f 声明成自动变量后, 每调用一次 fac() 函数, 变量 f 都重新分配空间并赋值为 1 由于多次调用后无法控制局部静态变量的值, 因此建议编程时不用 3) 寄存器变量一般情况下, 变量的值存放在内存中 当程序中用到一个变量的值时, 由控制器发出指令将内存中该变量的值送到运算器的寄存器中进行运算, 如果需要保存数据, 再将寄存器中的数据送到内存中 如果有一些变量使用频繁, 则为了节省时间, 可以将这些变量存放在 CPU 的寄存器中 例如 : int fac(register int n) register int f=1, i; for(i=1; i<=n; i++) f*=i; return f; 由于寄存器的存取速度远远快于内存的存取速度, 显然将变量放在寄存器中可以提高执行效率 这种变量称为寄存器变量, 用关键字 register 声明 由于 register 与 auto 声明的变量仅存储位置不同, 如果编译器不支持寄存器变量或者

28 声明的寄存器变量超出计算机的寄存器的个数, 那么声明为 register 存储类的变量被自动地切换到 auto 存储类 由于现代的 C 编译器能决定哪些变量应存放在寄存器中, 因此 register 声明符已很少使用 2. 全局变量的存储类别全局变量 ( 即外部变量 ) 是在函数的外部定义的, 它的作用域为从变量的定义处开始, 到本程序文件的末尾结束 在此作用域内, 全局变量可以为程序中各个函数所引用 全局变量均为静态存储, 即编译时将全局变量分配在静态存储区, 在程序执行期间, 对应的存储空间不会释放 如果在定义一个全局变量时赋初值, 则系统在给它分配空间时赋初值 如果在定义一个全局变量时没有赋初值, 那么系统在给它分配空间时, 将它初始化为 全局变量的作用域的扩展和限制 全局变量的作用域是从定义处到源文件结束处 但是, 可以使用修饰词 extern 和 static 对其作用域进行扩展和限制 extern 用于扩展全局变量的作用域,static 用于限制全局变量的作用域 1. 全局变量作用域的扩展 extern 有以下两种使用方式 1) 将全局变量的作用域扩展到其定义之前如果全局变量不在文件的开头定义, 其作用范围只限于从定义处到文件尾部 如果在定义点之前的函数想引用该变量, 则应该在引用之前用关键字 extern 对该变量进行引用声明, 以扩展全局变量的作用域, 表示该变量是一个已经定义的全局变量 有了此声明, 就可以从声明处起, 合法地使用该全局变量 例 5-20 用 extern 声明全局变量, 扩展全局变量的作用域 int min(int a, int b) /* 定义 min() 函数 */ int c ; c=a<b?a:b ; return(c); extern int a, b; /* A: 声明全局变量 */ printf("%d\n", min(a, b)); int a=3, b=5; /* B: 定义全局变量 */ 113 第 5 章 函 数

29 C 程序设计基础 ( 第 2 版 ) 114 在本程序文件的 B 行定义了全局变量 a b, 并且位置在 main() 函数之后 在 main() 函数的 A 行用 extern 对 a b 进行引用声明, 表示 a b 是已经定义的全局变量, 这样在 main() 函数中就可以合法地使用全局变量 a b 如果不用 extern 声明, 编译时会出错, 因为系统认为 a b 未定义 一般做法是将全局变量的定义放在引用它的所有函数之前, 这样可以避免在函数中再加一个 extern 声明 用 extern 声明全局变量时, 可以不写类型名,VS2010 中可以这样使用, 但有些编译器并不支持该使用方法 2) 将源文件中全局变量的作用域扩展到其他源文件中一个 C 程序可以由多个源程序文件组成 在一个文件中想引用另一个文件中已定义的全局变量, 可以用下面的方法解决 如果一个程序中包含两个文件, 在两个文件中都要用到同一个全局变量 num, 这时不能分别在两个文件中各自定义全局变量 num, 否则在进行程序的连接时会出现 重复定义 错误 正确的做法是 : 在一个文件中定义变量 num, 而在另一个文件中用 extern 对 num 进行全局变量声明, 即 : extern int num; 这样, 在编译和连接时, 系统会知道 num 是一个已在其他地方定义的全局变量, 并将在另一文件中定义的全局变量的作用域扩展到本文件, 在本文件中可以合法地引用它 如图 5-9 所示, 有两个程序 f1.c 和 f2.c,c 行定义变量 分配存储空间,A 行声明变量 不分配存储空间, 这两行中的变量是同样的变量, 即将文件 f2.c 中的全局变量 x 和 y 的作用域扩展到了文件 f1.c 中 图 5-9 全局变量作用域的扩展和限制下面举例说明 例 5-21 用 extern 将全局变量的作用域扩展到其他文件 本程序的作用是输入 x 和 y, 求 x y 的值 本程序由两个程序文件 Li0521_1.c 和 Li0521_2.c 构成 Li0521_1.c 中的内容为 :

30 int x; /* 定义全局变量 */ int my_pow(int); /* 对调用函数进行声明 */ int z, y; printf("enter the number x and its power y:\n"); scanf("%d%d", &x, &y); z=my_pow(y); printf("%d ** %d=%d\n", x, y, z); Li0521_2.c 文件中的内容为 : extern int x; /* 声明 x 是一个已定义的全局变量 */ int my_pow(int y) int i, z=1; for(i=1; i<=y; i++) z=z*x; return (z); 可以看到,Li0521_2.c 文件中的开头有一个 extern 声明, 说明在本文件中出现的变量 x 是一个已经在其他文件中定义过的全局变量, 本文件不必再次为它分配内存, 可以直接使用该变量 假如程序有四个源程序文件, 在一个文件中定义外部整型变量 x, 其他三个文件都可以引用 x, 但必须在其他三个文件中都加上一个 extern int x; 声明 在各文件经过编译后, 再将各目标文件连接成一个可执行文件 但是, 使用这样的全局变量应十分谨慎, 因为在执行一个文件中的函数时, 可能会改变全局变量的值, 从而影响其在另一文件中的应用 如上所述,extern 既可以用来在本文件中将全局变量的作用域扩展到定义它之前, 又可以将全局变量的作用域从一个文件扩展到其他文件, 那么系统是如何处理的呢? 在编译时遇到 extern, 系统先在本文件中寻找全局变量的定义, 如果找到, 就在本文件中扩展作用域 ; 如果找不到, 就在连接时从其他文件寻找全局变量的定义, 如果找到, 就将作用域扩展到本文件, 如果找不到, 按出错处理 2. 全局变量作用域的限制有时在程序设计中希望某些全局变量只限于被本文件引用, 而不能被其他文件引用 这时可以在定义全局变量时加一个 static 声明 115 第 5 章 函 数

31 C 程序设计基础 ( 第 2 版 ) 116 例如在图 5-9 中,f1.c 文件中的 B 行定义的变量 a b 只能在 f1.c 中使用 ;f2.c 文件中的 D 行定义的变量 a b 也只能在 f2.c 文件中使用 虽然两个文件中的 a 和 b 同名, 但它们各自拥有不同的存储空间, 是不同的变量 需要指出的是, 对全局变量加 static 声明并不意味着这时才是静态存储 ( 存放在静态存储区中 ), 而不加 static 的是动态存储 ( 存放在动态存储区中 ) 这两种形式的全局变量都是静态存储方式, 只是作用范围不同, 都是在编译时分配存储空间的 5.7 程序的多文件组织 在编写大型程序时, 为了方便程序的设计与调试, 往往将一个程序分成若干模块, 把实现相关功能的程序和数据放在一个文件中 当一个完整的程序的若干函数被存放在两个及两个以上文件中时, 称为程序的多文件组织 这种多文件组织的程序如何进行编译和连接? 一个文件中的函数如何调用另一个文件中的函数? 这是本节要介绍的内容 内部函数和外部函数 一个 C 程序可由多个源程序文件组成, 根据函数能否被其他源文件中的函数调用, 将函数分为内部函数和外部函数 1. 内部函数如果一个函数只能被本文件中的其他函数调用, 称它为内部函数 在定义内部函数时, 在函数类型的前面加上 static 即可 形式如下 : static < 类型标识符 > < 函数名 > (< 形参列表 >) 如 : static int fun(int x, int y) 使用内部函数, 可以使函数只局限于所在文件, 如果在不同的文件中有同名的内部函数, 将互不干扰 这样不同的人可以编写不同的函数, 而不必担心所用函数是否会与其他文件中的函数同名 通常把只能由同一文件使用的函数和外部变量放在一个文件中, 在它们前面都加上 static 使之局部化, 其他文件不能引用 2. 外部函数一个源程序文件中定义的函数不仅可以在本文件中使用, 而且可以在其他文件中使用, 这种函数称为外部函数 C 语言规定, 在默认情况下, 所有函数都是外部函数 但是, 有时为了强调本源文件中调用的函数是在其他源文件中定义的 ( 或者本文件中定义的函数可以被其他源文件中的函数调用 ), 在进行函数原型声明 ( 或函数定义 ) 时, 应在函数类型前加 extern 修饰 形式如下 : extern int fun(int x, int y) 如图 5-10 所示, 在程序文件 z1.c 中定义了函数 fun(), 在程序文件 z2.c 中要调用文件

32 z1.c 中已定义了的函数 fun(), 则在调用前增加函数原型声明 z1.c z2.c int fun(int x, int y) extern int fun(int, int); k=fun(x, y); 图 5-10 外部函数调用 例 5-22 用如下公式计算排列函数 n! p(n, k) (n k)! 在 Li0522_1.c 文件中定义求阶乘的函数, 在 Li0522_2.c 文件中调用求阶乘函数 Li0522_1.c 文件内容如下 : int fac(int n) /* 返回 n!=n*(n-1)*(n-2)* *2*1 */ int f; if(n<0) f=1; while(n>1) f*=n--; return f; Li0522_2.c 文件内容如下 : extern int fac(int); /* 调用在 Li0522_1.c 中定义的函数, 要加原型声明 */ int n, k, p; printf("please input n and k(n>=k):\n"); scanf("%d%d", &n, &k); p=fac(n)/fac(n-k); printf("p(%d, %d)=%d\n", n, k, p); 运行文件, 结果如下 : 117 第 5 章 函 数

33 C 程序设计基础 ( 第 2 版 ) 118 Please input n and k(n>=k): 5 2<Enter> p(5,2)= 多文件组织的编译和连接 当一个完整的程序由多个源程序文件组成时, 如何将这些文件进行编译并连接成一个可执行的程序文件呢? 不同的计算机系统处理方法可能是不同的 通常有以下几种处理方法 1. 用包含文件的方式在定义 main() 函数的文件中, 将组成同一程序的其他文件包含进来 ( 关于文件包含的含义请参看第 6 章 ), 由编译程序对这些源程序文件一起编译, 并连接成一个可执行文件 这种方法适用于编写较小型的程序, 不适用于编写大型程序, 因为对任何一个文件进行微小修改, 均要重新编译所有的文件, 然后才能连接 2. 使用工程文件的方法将组成一个程序的所有文件都加到工程文件中, 由编译器自动完成多文件组织的编译和连接 如在 VS2010 中, 可以建立项目文件 方法如下 (1) 先编辑相关文件, 例如 Li0522_1.c Li0522_2.c, 存储在磁盘上 (2) 使用 文件 菜单中的 新建 命令建立一个项目, 再使用 项目 菜单中的 添加现有项 命令将 Li0522_1.c Li0522_2.c 两个文件添加到项目中 (3) 使用 生成 菜单中的 生成解决方案 命令对程序进行编译 (4) 使用 调试 菜单中的 开始执行 ( 不调试 ) 命令执行该程序 有关 VS2010 的详细使用方法请查阅相关资料 设计大型程序时, 建议使用这种方法 当修改某一个源程序文件后, 编译器只需要对已修改的源程序文件重新编译, 而没有必要对其他源程序文件重新编译, 因此可以大大提高编译和连接的效率 习题 5 1. 编写被调函数, 求四个数的平均值, 在主函数中调用该函数求四个数的平均值 2. 编写被调函数, 统计输入的整数序列中的奇数个数和偶数个数, 在主函数中调用该函数求输入的整数序列中的奇数个数和偶数个数 3. 编写被调函数, 判断一个数是不是回文数, 在主函数中调用该函数判断一个数是否为回文数并输出相关信息 所谓回文数即正读和反读是相同的数, 如 是一个回文数 4. 下列公式用来计算笛卡儿平面上的两点 (x 1, y 1 ) 和 (x 2, y 2 ) 间的距离 d (x x ) (y y )

34 给定圆心和圆上一点的坐标, 利用上述公式计算圆的半径 编写程序, 输入圆心和圆上一点的坐标, 然后输出圆的半径 直径 周长和面积, 要求用函数实现求两点间的距离 5. 组合函数 C(n, k) 在给定的 n 个元素的集合中, 求不同的 k 个元素的子集的个数 该函数可以用以下公式计算 要求编写求阶乘及组合的函数, 在主函数中调用求组合的函数 n! C(n,k) = k!(n k)! 6. 编写一个被调函数, 用下面的公式求 e x 的近似值 在主函数中输入 x 及精度 10 6 ( 要求最后一项小于 10 6 ), 求 e x 2 3 n x x x x x e = ! 2! 3! n! 7. 编写被调函数, 求出 1000 以内的素数 在主函数中调用该函数输出 1000 以内的素数, 要求每行输出 5 个素数 8. 一个数如果恰好等于它的因子之和, 就称这个数为完数 例如,6 的因子为 1 2 3, 而 6=1+2+3, 因此 6 是完数 编写程序找出 1000 之内的所有完数, 并按下面格式输出其因子 : 6 its factors are: 编写两个函数, 分别求两个整数的最大公约数和最小公倍数, 用主函数调用这两个函数 要求不用递归算法实现 10. 编写一个递归函数, 将一个整数的每个位上的数字按相反的顺序输出 例如, 输入 1234, 输出 用递归函数实现求 Fibonacci 数列的前 n 项,n 为函数的参数 Fibonacci 数列的公式为 : 1 n 1 fib(n) 1 n 2 fib(n 1) fib(n 2) n 用递归函数实现求 n 阶勒让德多项式的值, 递归公式为 : 1 n 0 p n (x) x n 1 ((2 n 1) xp n 1(x) (n 1) p n 2(x)) / n n 编写一个程序, 输入一个十进制数, 输出相应的二进制数 设计一个递归函数来实现数制转换 119 第 5 章 函 数

35 C 程序设计基础 ( 第 2 版 ) 14. 编写两个函数, 分别输出以下两个图形 120 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 15. 用矩形法求函数 b (1 x) x d x 在区间 [a, b] 内的定积分 矩形法求定积分的示意图 a 如图 5-11 所示 矩形法的几何意义是将区间 [a, b] 分成若干等份, 求全部小区间的矩形面积之和 图 5-11 矩形法求定积分的示意图