第7章 用函数实现模块化程序设计
输出以下的结果，用函数调用实现。
******************
How do you do!
******************
#include <stdio.h>
int main()
{ void print_star();
void print_message();
print_star();
print_message();
print_star();
return 0;
}
void print_star()
{ printf(“******************\n”); }
void print_message()
{ printf(“ How do you do!\n”); }
为什么要用函数
说明：
1、一个Ｃ程序由一个或多个程序模块组成，每一个程序模块作为一个源程序文件。对较大的程序，一般不希望把所有内容全放在一个文件中，而是将它们分别放在若干个源文件中，由若干个源程序文件组成一个C程序。这样便于分别编写、分别编译，提高调试效率。一个源程序文件可以为多个C程序共用。
2、一个源程序文件由一个或多个函数以及其他有关内容（如预处理指令、数据声明与定义等）组成。一个源程序文件是一个编译单位，在程序编译时是以源程序文件为单位进行编译的，而不是以函数为单位进行编译的。
3、Ｃ程序的执行是从main函数开始的，如果在main函数中调用其他函数，在调用后流程返回到main函数，在main函数中结束整个程序的运行。
4、所有函数都是平行的，即在定义函数时是分别进行的，是互相独立的。一个函数并不从属于另一个函数，即函数不能嵌套定义。函数间可以互相调用，但不能调用main函数。main函数是被操作系统调用的。
5、从用户使用的角度看，函数有两种。
库函数，它是由系统提供的，用户不必自己定义而直接使用它们。应该说明，不同的C语言编译系统提供的库函数的数量和功能会有一些不同，当然许多基本的函数是共同的。
用户自己定义的函数。它是用以解决用户专门需要的函数。
6、从函数的形式看，函数分两类。
无参函数。无参函数一般用来执行指定的一组操作。无参函数可以带回或不带回函数值，但一般以不带回函数值的居多。
有参函数。在调用函数时，主调函数在调用被调用函数时，通过参数向被调用函数传递数据，一般情况下，执行被调用函数时会得到一个函数值，供主调函数使用。
C语言要求，在程序中用到的所有函数，必须“先定义，后使用”
指定函数名字、函数返回值类型、函数实现的功能以及参数的个数与类型，将这些信息通知编译系统。
输入两个整数，要求输出其中值较大者。要求用函数来找到大数。
int max(int x,int y)
{
int z;
z=x>y?x:y;
return(z);
}
————————————————————————————————————————
#include <stdio.h>
int main()
{ int max(int x,int y);
int a,b,c;
printf(“two integer numbers: ");
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“max is %d\n”,c);
}
int max(int x, int y)
{
int z;
z=x>y? x:y;
return(z);
}
输入两个实数，用一个函数求出它们之和。
#include <stdio.h>
int main()
{ float add(float x, float y);
float a,b,c;
printf("Please enter a and b:");
scanf("%f,%f",&a,&b);
c=add(a,b);
printf("sum is %f\n",c);
return 0;
}
float add(float x,float y)
{ float z;
z=x+y;
return(z);
}
输入4个整数，找出其中最大的数。用函数的嵌套调用来处理。
#include <stdio.h>
int main()
{ int max4(int a,int b,int c,int d);
int a,b,c,d,max;
printf(“4 interger numbers:");
scanf("%d%d%d%d",&a,&b,&c,&d);
max=max4(a,b,c,d);
printf("max=%d \n",max);
return 0;
}
int max4(int a,int b,int c,int d)
{ int max2(int a,int b);
int m;
m=max2(a,b);
m=max2(m,c);
m=max2(m,d);
return(m);
}
int max2(int a,int b)
{ if(a>=b) return a;
else return b;
}
函数的递归调用
在调用一个函数的过程中又出现直接或间接地调用该函数本身，称为函数的递归调用。
Ｃ语言的特点之一就在于允许函数的递归调用。
例7.6 有5个学生坐在一起
问第5个学生多少岁？他说比第4个学生大2岁
问第4个学生岁数，他说比第3个学生大2岁
问第3个学生，又说比第2个学生大2岁
问第2个学生，说比第1个学生大2岁
最后问第1个学生，他说是10岁
请问第5个学生多大
#include <stdio.h>
int main()
{
int age(int n);
printf("NO.5,age:%d\n",age(5));
return 0;
}
int age(int n)
{
int c;
if(n==1)
c=10;
else
c=age(n-1)+2;
return(c);
}
用递归方法求ｎ!。
#include <stdio.h>
int main()
{ int fac(int n);
int n; int y;
printf("input an integer number:");
scanf("%d",&n);
y=fac(n);
printf("%d!=%d\n",n,y);
return 0;
}
int fac(int n)
{ int 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);
}
Hanoi（汉诺）塔问题。古代有一个梵塔，塔内有3个座A、B、C，开始时Ａ座上有64个盘子，盘子大小不等，大的在下，小的在上。有一个老和尚想把这64个盘子从Ａ座移到Ｃ座，但规定每次只允许移动一个盘，且在移动过程中在3个座上都始终保持大盘在下，小盘在上。在移动过程中可以利用B座。要求编程序输出移动一盘子的步骤。
思路：
要把64个盘子从A座移动到C座，需要移动大约264 次盘子。一般人是不可能直接确定移动盘子的每一个具体步骤的
老和尚会这样想：假如有另外一个和尚能有办法将上面63个盘子从一个座移到另一座。那么，问题就解决了。此时老和尚只需这样做：
(1) 命令第2个和尚将63个盘子从A座移到B座
(2) 自己将1个盘子（最底下的、最大的盘子）从A座移到C座
(3) 再命令第2个和尚将63个盘子从B座移到C座
将n个盘子从A座移到C座可以分解为以下3个步骤：
(1) 将A上n-1个盘借助C座先移到B座上
(2) 把A座上剩下的一个盘移到C座上
(3) 将n-1个盘从B座借助于Ａ座移到C座上
编写程序。
用hanoi函数实现第1类操作（即模拟小和尚的任务）
用move函数实现第2类操作（模拟大和尚自己移盘）
函数调用hanoi(n,one,two.three)表示将n个盘子从“one”座移到“three”座的过程(借助“two”座)
函数调用move(x,y)表示将1个盘子从x 座移到y 座的过程。x和y是代表A、B、C座之一，根据每次不同情况分别取A、B、C代入
#include <stdio.h>
int main()
{ void hanoi(int n,char one, char two,char three);
int m;
printf(“the number of diskes:");
scanf("%d",&m);
printf("move %d diskes:\n",m);
hanoi(m,‘A‘,‘B‘,‘C‘);
}
void hanoi(int n, char one, char two, char three)
{ void move(char x,char y);
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)
{
printf("%c-->%c\n",x,y);
}
有一个一维数组score，内放10个学生成绩，求平均成绩。
#include <stdio.h>
int main()
{ float average(float array[10]);
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("%5.2f\n",aver);
return 0;
}
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);
}
有两个班级，分别有35名和30名学生，调用一个average函数，分别求这两个班的学生的平均成绩。
#include <stdio.h>
int main()
{ float average(float array[ ],int n);
float score1[5]={98.5,97,91.5,60,55};
float score2[10]={67.5,89.5,99,69.5,77,89.5,76.5,54,60,99.5};
printf(“%6.2f\n”,average(score1,5));
printf(“%6.2f\n”,average(score2,10));
return 0;
}
float average(float array[ ],int n)
{ int i;
float aver,sum=array[0];
for(i=1;i<n;i++)
sum=sum+array[i];
aver=sum/n;
return(aver);
}
用选择法对数组中10个整数按由小到大排序。
#include <stdio.h>
int main()
{ void sort(int array[],int n);
int a[10],i;
printf("enter 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");
return 0;
}
void sort(int array[],int n)
{ int i,j,k,t;
for(i=0;i<n-1;i++) // i取值0-8
{ k=i;
for(j=i+1;j<n; j++)
if(array[j]<array[k]) k=j;
t=array[k];
array[k]=array[i];
array[i]=t;
}
}
有一个３×４的矩阵，求所有元素中的最大值。
#include <stdio.h>
int main()
{ int max_value(int array[][4]);
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));
return 0;
}
int max_value(int array[][4])
{ int i,j,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);
}
局部变量和全局变量
定义变量可能有三种情况：
在函数的开头定义
在函数内的复合语句内定义
在函数的外部定义
局部变量
在一个函数内部定义的变量只在本函数范围内有效
在复合语句内定义的变量只在本复合语句范围内有效
在函数内部或复合语句内部定义的变量称为“局部变量”
全局变量
在函数内定义的变量是局部变量，而在函数之外定义的变量称为外部变量
外部变量是全局变量(也称全程变量)
全局变量可以为本文件中其他函数所共用
有效范围为从定义变量的位置开始到本源文件结束
有一个一维数组，内放10个学生成绩，写一个函数，当主函数调用此函数后，能求出平均分、最高分和最低分。
#include <stdio.h>
float Max=0,Min=0;
int main()
{ float average(float array[ ],int n);
float ave,score[10]; int i;
printf("Please enter 10 scores:\n");
for(i=0;i<10;i++)
scanf("%f",&score[i]);
ave=average(score,10);
printf("max=%6.2f\nmin=%6.2f\n
average=%6.2f\n",Max,Min,ave);
return 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);
}
动态存储方式与静态存储方式
从变量值存在的时间(即生存期)观察，变量的存储有两种不同的方式：静态存储方式和动态存储方式
? 静态存储方式是指在程序运行期间由系统分配固定的存储空间的方式
? 动态存储方式是在程序运行期间根据需要进行动态的分配存储空间的方式
-
自动变量(auto变量)
局部变量，如果不专门声明存储类别，都是动态地分配存储空间的
调用函数时，系统会给局部变量分配存储空间，调用结束时就自动释放空间。因此这类局部变量称为自动变量
自动变量用关键字auto作存储类别的声明
int f(int a)
{
auto int b,c=3;
┇
}
-
静态局部变量(static局部变量)
希望函数中的局部变量在函数调用结束后不消失而继续保留原值，即其占用的存储单元不释放，在下一次再调用该函数时，该变量已有值(就是上一次函数调用结束时的值)，这时就应该指定该局部变量为“静态局部变量”，用关键字static进行声明
例7.16 考察静态局部变量的值。
#include <stdio.h>
int main()
{ int f(int);
int a=2,i;
for(i=0;i<3;i++)
printf(“%d\n”,f(a));
return 0;
}
int f(int a)
{ auto int b=0;
static c=3;
b=b+1;
c=c+1;
return(a+b+c);
}
每调用一次，开辟新a和b，但c不是
输出1到5的阶乘值。
#include <stdio.h>
int main()
{ int fac(int n);
int i;
for(i=1;i<=5;i++)
printf(“%d!=%d\n”,i,fac(i));
return 0;
}
int fac(int n)
{ static int f=1;
f=f*n;
return(f);
}
若非必要，不要多用静态局部变量
-
寄存器变量(register变量)
一般情况下，变量（包括静态存储方式和动态存储方式）的值是存放在内存中的
寄存器变量允许将局部变量的值放在CPU中的寄存器中
现在的计算机能够识别使用频繁的变量，从而自动地将这些变量放在寄存器中，而不需要程序设计者指定
全局变量都是存放在静态存储区中的。因此它们的生存期是固定的，存在于程序的整个运行过程
一般来说，外部变量是在函数的外部定义的全局变量，它的作用域是从变量的定义处开始，到本程序文件的末尾。在此作用域内，全局变量可以为程序中各个函数所引用。
-
在一个文件内扩展外部变量的作用域
外部变量有效的作用范围只限于定义处到本文件结束。
如果用关键字extern对某变量作“外部变量声明”，则可以从“声明”处起，合法地使用该外部变量
调用函数，求3个整数中的大者。
#include <stdio.h>
int main()
{ int max( );
extern int A,B,C;
scanf(“%d %d %d”,&A,&B,&C);
printf("max is %d\n",max());
return 0;
}
int A ,B ,C;
int max( )
{ Int m;
m=A>B?A:B;
if (C>m) m=C;
return(m);
}
-
将外部变量的作用域扩展到其他文件
如果一个程序包含两个文件，在两个文件中都要用到同一个外部变量Num，不能分别在两个文件中各自定义一个外部变量Num
应在任一个文件中定义外部变量Num，而在另一文件中用extern对Num作“外部变量声明”
在编译和连接时，系统会由此知道Num有“外部链接”，可以从别处找到已定义的外部变量Num，并将在另一文件中定义的外部变量num的作用域扩展到本文件
给定b的值，输入a和ｍ，求a*b和am的值。
文件file1.c：
#include <stdio.h>
int A;
int main()
{ int power(int);
int b=3,c,d,m; scanf("%d,%d",&A,&m);
c=A*b;
printf("%d*%d=%d\n",A,b,c);
d=power(m);
printf("%d**%d=%d\n",A,m,d);
return 0;
}
文件file2.c：
extern A;
int power(int n)
{ int i,y=1;
for(i=1;i<=n;i++)
y*=A;
return(y);
}
-
将外部变量的作用域限制在本文件中
有时在程序设计中希望某些外部变量只限于被本文件引用。这时可以在定义外部变量时加一个static声明。
一般为了叙述方便，把建立存储空间的变量声明称定义，而把不需要建立存储空间的声明称为声明
内部函数与外部函数
如果一个函数只能被本文件中其他函数所调用，它称为内部函数。
在定义内部函数时，在函数名和函数类型的前面加static，即:
static 类型名 函数名(形参表)
如果在定义函数时，在函数首部的最左端加关键字extern，则此函数是外部函数，可供其他文件调用。
如函数首部可以为
extern int fun (int a, int b)
如果在定义函数时省略extern，则默认为外部函数
有一个字符串，内有若干个字符，今输入一个字符，要求程序将字符串中该字符删去。用外部函数实现。
思想：
分别定义3个函数用来输入字符串、删除字符、输出字符串
按题目要求把以上3个函数分别放在3个文件中。main函数在另一文件中，main函数调用以上3个函数，实现题目的要求
#include <stdio.h>
int main()
{ extern void enter_string(char str[]);
extern void delete_string(char str[], char ch);
extern void print_string(char str[]);
char c,str[80];
enter_string(str);
scanf(“%c”,&c);
delete_string(str,c);
print_string(str);
return 0;
}
————————————————————————————————
void enter_string(char str[80])
{ gets(str); }
————————————————————————————————
void delete_string(char str[],char ch)
{ int i,j;
for (i=j=0;str[i]!=‘\0‘;i++)
if (str[i]!=ch) str[j++]=str[i];
str[j]=‘\0‘;
}
————————————————————————————————
void print_string(char str[])
{ printf("%s\n",str); }