利用函数实现模块化程序设计
- 1，一个简单的调用函数举例
- 2，用函数找到两个整数之间的较大者
- 3，用函数求出两个实数之和。
- 4，输入四个整数，用函数的嵌套找出其中最大的数。
- 5，用递归法求n!
- 6，汉诺塔问题
- 7，输入10个数，要求输出其中值最大的元素和该数是第几个数（不为数组排序规则）
- 8，有一个一维数组score，内放10个学生成绩，利用函数求平均成绩。
- 9，有一个一维数组score，内放10个学生成绩，利用函数求平均成绩，最大，最小。
- 10，用函数表现静态变量与自动变量的区别
- 11，输出1到n的阶乘值
- 12，给定b的值，输入a和m，求a*b的值和a^m的值
- 13，写两个函数，分别求两个整数的最大公约数和最小公倍数，用主函数调用这两个函数，并输出结果。
- 14，从主函数输入a,b,c的值，求方程ax^2^+bx+c=0的根，用3个函数分别求当b^2^-4ac>0,=0,<0时的根，并输出结果。
- 15，写一个判断素数的函数，在主函数输入一个整数，输出是否为素数的信息。
- 16，写一个函数，使输入的一个字符串按反序存放，在主函数中输入和输出字符串
1，一个简单的调用函数举例
#include"stdio.h"
int main()
{
void xingxing();//声明xingxing函数
void hua();//声明hua函数
xingxing();//调用xingxing函数
hua();//调用hua函数
xingxing();//调用xingxing函数
return 0;
}
void xingxing()//定义xingxing函数
{
printf("************\n");
}
void hua()//定义hua函数
{
printf("hello world!\n");
}
运行结果：
************
hello world!
************
2，用函数找到两个整数之间的较大者
#include"stdio.h"
int max(int x,int y)
{
int z;
z=x>y?x:y;//将x与y之间的较大者赋值给z
return(z);
}
int main()
{
int max(int x,int y);
int a,b,c;
printf("输入两整数：");
scanf("%d%d",&a,&b);
c=max(a,b);
printf("较大者为%d",c);
return 0;
}
运行结果：
输入两整数：99 999
较大者为999
3，用函数求出两个实数之和。
#include"stdio.h"
float add(float x,float y)
{
float z;
z=x+y;
return(z);
}
int main()
{
float add(float x,float y);
float a,b,c;
printf("输入两数：");
scanf("%f%f",&a,&b);
c=add(a,b);
printf("和为%f",c);
return 0;
}
运行结果：
输入两数：3 4
和为7.000000
4，输入四个整数，用函数的嵌套找出其中最大的数。
#include"stdio.h"
int max2(int a,int b)
{
return (a>=b?a:b);
}
int max4(int a,int b,int c,int d)
{
int max2(int a,int b);
return max2(max2(max2(a,b),c),d);//函数调用作为函数参数
}
int main()
{
int max4(int a,int b,int c,int d);
int a,b,c,d,m;
printf("输入四整数：");
scanf("%d%d%d%d",&a,&b,&c,&d);
m=max4(a,b,c,d);
printf("最大数为%d",m) ;
return 0;
}
运行结果：
输入四整数：1 6 9 18
最大数为18
5，用递归法求n!
#include"stdio.h"
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);
}
int main()
{
int fac(int n);
int y,n;
printf("输入整数：");
scanf("%d",&n);
y=fac(n);
printf("%d!=%d",n,y);
return 0;
}
运行结果：
输入整数：3
3!=6
6，汉诺塔问题
#include"stdio.h"
int main()
{
void jh(int n,char o,char t,char th);
int m;
printf("输入盘子数：");
scanf("%d",&m);
printf("%d个盘子的移动步骤：\n",m);
jh(m,'A','B','C');
return 0;
}
void jh(int n,char o,char t,char th)
{
void move(char x,char y);
if(n==1)
move(o,th);
else
{
jh(n-1,o,th,t);
move(o,th);
jh(n-1,t,o,th);
}
}
void move(char x,char y)
{
printf("%c-->%c\n",x,y);
}
运行结果：
输入盘子数：4
4个盘子的移动步骤：
A-->B
A-->C
B-->C
A-->B
C-->A
C-->B
A-->B
A-->C
B-->C
B-->A
C-->A
B-->C
A-->B
A-->C
B-->C
7，输入10个数，要求输出其中值最大的元素和该数是第几个数（不为数组排序规则）
#include"stdio.h"
int main()
{
int max(int x,int y);
int a[10],m,n,i;
printf("输入十个整数：\n");
for(i=0;i<10;i++)
{
scanf("%d",&a[i]);
}
for(i=1,m=a[0],n=0;i<10;i++)
{
if(max(m,a[i])>m)
{
m=max(m,a[i]);
n=i;
}
}
printf("最大数为%d,在其中第%d个",m,n+1);
return 0;
}
int max(int x,int y)
{
return(x>y?x:y);
}
运行结果：
输入十个整数：
9 10 20 25 61 42 32 11 2 7
最大数为61,在其中第5个
8，有一个一维数组score，内放10个学生成绩，利用函数求平均成绩。
#include"stdio.h"
#define n 10 //n最大为100
//改动n的值，即改动学生人数
float average(float array[100])
{
int i;
float aver,sum=array[0];
for(i=1;i<n;i++)
{
sum=sum+array[i];
}
aver=sum/n;
return(aver);
}
int main()
{
float average(float array[100]);
float score[100],aver;
int i;
printf("输入n人成绩：\n");
for(i=0;i<n;i++)
{
scanf("%f",&score[i]);
}
aver=average(score);
printf("平均成绩为 %5.2f\n",aver);
return 0;
}
运行结果：
输入n人成绩：
10 12 13 16 15 41 90 10 10 52
平均成绩为 26.90
9，有一个一维数组score，内放10个学生成绩，利用函数求平均成绩，最大，最小。
#include"stdio.h"
#define n 10 //n最大为100
//改动n的值，即改动学生人数
float max=0,min=0;
float average(float array[100])
{
int i;
float aver,sum=array[0];
max=min=array[0];
for(i=1;i<n;i++)
{
if(array[i]>max)
max=array[i];
if(array[i]<min)
min=array[i];
sum=sum+array[i];
}
aver=sum/n;
return(aver);
}
int main()
{
float average(float array[100]);
float score[100],aver;
int i;
printf("输入n人成绩：\n");
for(i=0;i<n;i++)
{
scanf("%f",&score[i]);
}
aver=average(score);
printf("平均成绩为%5.2f\n最大为%5.2f\n最小为%5.2f",aver,max,min);
return 0;
}
运行结果：
输入n人成绩：
10 15 16 90 91 99 10 100 60 30
平均成绩为52.10
最大为100.00
最小为10.00
10，用函数表现静态变量与自动变量的区别
#include"stdio.h"
int d(int a)
{
auto int i=0;;
i=i+1;
return(i);
}
int j(int n)
{
static int b=0;
b=b+1;
return(b);
}
int main()
{
int d(int i);
int j(int b);
int a;
int b;
int i;
for(i=0;i<3;i++)
{
printf("静态：%d ",j(a));
printf("自动：%d\n",d(b));
}
return 0;
}
运行结果：
静态：1 自动：1
静态：2 自动：1
静态：3 自动：1
静态变量与自动变量的区别主要表现在：
Ⅰ ）静态存储类型的局部变量是在静态存储区内分配内存单元，在程序的整个运行期间内都不释放空间。而自动类型的局部变量属于动态存储类型，是在动态存储区内分配存储单元的，函数调用结束后存储单元即被释放。
Ⅱ）静态局部变量是在编译时赋初始值，并且只赋一次初值，在以后每次调用函数时，只是使用上一次函数被调用结束时变量的值。而自动局部变量的初值不是在编译时赋予的，而是在函数调用时赋予的，每调用一次函数都会对变量重新赋一次初值。
Ⅲ）如果调用的静态局部变量没有对其进行赋值，则该变量的默认值为0后者为空字符串。而对于自动局部变量来说，如果不赋值，则变量的值是一个不确定的值，这是因为在函数被调用时，会为该变量分配一个存储空间，在函数结束时，存储空间被释放，这两次分配的存储空间是不一样的，存储空间中的值也是不确定的。
11，输出1到n的阶乘值
#include"stdio.h"
int f(int a)
{
static int f=1;//保留上次调用结束时的值
f=f*a;//在上次的f值的基础上再乘以n
return(f);//返回的f时n!的值
}
int main()
{
int f(int a);
int b,i;
printf("输入需要输出的阶乘数：");
scanf("%d",&b);
for(i=1;i<=b;i++)
{
printf("%d!=%d\n",i,f(i));
}
return 0;
}
运行结果：
输入需要输出的阶乘数：9
1!=1
2!=2
3!=6
4!=24
5!=120
6!=720
7!=5040
8!=40320
9!=362880
12，给定b的值，输入a和m，求a*b的值和a^m的值
//文件1
#include"stdio.h"
int A;
int main()
{
int power(int n);
int b=3,c,d,m;
printf("输入一个数a以及它的指数m:\n");
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;
}
//文件2
extern int A;
int power(int n)
{
int i,y=1;
for(i=1;i<=n;i++)
y=A*y;
return(y);
}
运行结果：
输入一个数a以及它的指数m:
3 5
3*3=9
3^5=24
13，写两个函数，分别求两个整数的最大公约数和最小公倍数，用主函数调用这两个函数，并输出结果。
#include"stdio.h"
int gy(int u,int v)//求最大公约数
{
int t,r;
if(v>u)//使较大者为被除数
{
t=u;
u=v;
v=t;
}
while((r=u%v)!=0)
{
u=v;
v=r;
}
return(v);
}
int gb(int u,int v,int h)//最小公倍数=u*v/最大公约数
{
return(u*v/h);
}
int main()
{
int gy(int u,int v);
int gb(int u,int v,int h);
int u,v;
scanf("%d%d",&u,&v);
printf("最大公约数为：%d\n",gy(u,v));
printf("最小公倍数为：%d\n",gb(u,v,gy(u,v)));
return 0;
}
运行结果：
24
188
最大公约数为：4
最小公倍数为：1128
14，从主函数输入a,b,c的值，求方程ax2+bx+c=0的根，用3个函数分别求当b2-4ac>0,=0,<0时的根，并输出结果。
#include"stdio.h"
#include"math.h"
float x1,x2,p,q,disc;
int main()
{
void da(float a,float b);
void deng(float a,float b);
void xiao(float a,float b);
float a,b,c;
printf("input a:");
scanf("%f",&a);
getchar();
printf("input b:");
scanf("%f",&b);
getchar();
printf("input c:");
scanf("%f",&c);
printf("方程：%5.2fx^2+%5.2fx+%5.2f=0\n",a,b,c);
disc=b*b-4*a*c;
printf("解：\n");
if(disc>0)
{
da(a,b);
printf("x1=%f\t\tx2=%f\n",x1,x2);
}
else if(disc==0)
{
deng(a,b);
printf("x1=%f\t\tx2=%f\n",x1,x2);
}
else
{
xiao(a,b);
printf("x1=%f+%fi\t\tx2=%f-%fi\n",p,q,p,q);
}
return 0;
}
void da(float a,float b)
{
x1=(-b+sqrt(disc))/(2*a);
x2=(-b-sqrt(disc))/(2*a);
}
void deng(float a,float b)
{
x1=x2=(-b)/(2*a);
}
void xiao(float a,float b)
{
p=-b/(2*a);
q=sqrt(-disc)/(2*a);
}
运行结果：
- 相等的实根
input a:1
input b:2
input c:1
方程： 1.00x^2+ 2.00x+ 1.00=0
解：
x1=-1.000000 x2=-1.000000
- 不等的实根
input a:2
input b:4
input c:1
方程： 2.00x^2+ 4.00x+ 1.00=0
解：
x1=-0.292893 x2=-1.707107
- 共轭的复根
input a:2
input b:4
input c:3
方程： 2.00x^2+ 4.00x+ 3.00=0
解：
x1=-1.000000+0.707107i x2=-1.000000-0.707107i
15，写一个判断素数的函数，在主函数输入一个整数，输出是否为素数的信息。
#include "stdio.h"
int main()
{
int prime(int);
int n;
printf("输入一个整数：");
scanf("%d",&n);
if(prime(n))
printf(" %d 是素数",n);
else
printf(" %d 不是素数",n);
return 0;
}
int prime(int n)
{
int flag=1,i;
for (i=2;i<n/2&&flag==1;i++)
{
if(n%i==0)
flag=0;
return(flag);
}
}
运行结果：
- 情况1
输入一个整数：17
17 是素数
- 情况2
输入一个整数：10
10 不是素数
16，写一个函数，使输入的一个字符串按反序存放，在主函数中输入和输出字符串
#include"stdio.h"
#include"string.h"
int main()
{
void inverse(char str[]);
char str[100];
printf("输入字符串： ");
scanf("%s",str);
inverse(str);
printf("倒序字符串： %s",str);
return 0;
}
void inverse(char str[])
{
char t;
int i,j;
for(i=0,j=strlen(str);i<(strlen(str)/2);i++,j--)
{
t=str[i];
str[i]=str[j-1];
str[j-1]=t;
}
}
运行结果：
输入字符串： serious
倒序字符串： suoires
226
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
