程序设计基础C语言科学出版社第七章函数.docx

程序设计基础C语言科学出版社第七章函数.docx

《程序设计基础C语言科学出版社第七章函数.docx》由会员分享，可在线阅读，更多相关《程序设计基础C语言科学出版社第七章函数.docx（18页珍藏版）》请在冰点文库上搜索。

程序设计基础C语言科学出版社第七章函数

程序设计基础，C语言，科学出版社教材版。

第七章——函数

1.0题

（1.0）

#include

intf（intx）

{

staticintk=0;

x+=k++;

returnx;

}

voidmain（）

{

printf（"%d\n",f（f

（1）））;

}

/*staticintk说明k是静态局部变量x+=k++，x=1;k=0;x=x+（k++）,k=1，x=1+0=1，f

（1）=x=1,f（f

（1））=1+1=2*/

（2.0）

#include

intc,a=4;

func（inta,intb）

{

c=a*b;

a=b-1;

b++;

return（a+b+1）;

}

voidmain（）

{

intb=2,p=0;

c=1;

p=func（b,a）;

printf（"%d,%d,%d,%d\n",a,b,c,p）;

}

/*func函数中c=a*b=4*2=8a=b-1=3b=5return（9）*/

/*c,和a,都为全局变量，它的值保留上一次操作后的结果*/

/*main函数中，a=4,b=2,c=8,p=9*/

（3.0）

#include

voidnum（）

{

externintx,y;

inta=15,b=10;

x=a-b;

y=a+b;

}

intx,y;

voidmain（）

{

inta=7,b=5;

x=a+b;

y=a-b;

num（）;

printf（"%d,%d\n",x,y）;

}

/*x,y即是全局变量，又是num函数里面的局部变量，x,y在num函数中被屏蔽，extern扩大了x,y的作用域，所以x,y的值为上一次操作后的结果，及是num函数里面的值x=15-10=5y=25*/

（4.0）

#include

intn=1;

voidfunc（）

{

staticintx=4;

inty=10;

x=x+2;

n=n+10;

y=y+n;

printf（"FUNC:

x=%2d,y=%2d,n=%2d\n",x,y,n）;

}

voidmain（）

{

staticintx=5;

inty=n;

printf（"MAIN:

x=%2d,y=%2d,n=%2d\n",x,y,n）;

func（）;

}

/*n为全局变量，x则是main和func函数中的静态全局变量*/

/*main函数中，x=5,y=1,n=1*/

/*func函数，x=6,y=21,n=11*/

（5）

#include

#defineXYZ"String_XYZ"

main（）

{

printf（"XYZ=%s,%s\n",XYZ,"XYZ"）;

}

/*XYX=String_XYZ，"XYX"%s结果就是打印“XYZ”，所以就算XYZ.*/

2题编写一个函数求表达式1-1/2+1/3-1/4+1/5-1/6+~~``~~`~~+1/n的值。

#include

#include

floatcount（intn）

{floatsum=0.0;

inti;

for（i=1;i<=n;i++）

{if（i%2==0）

{sum=sum-1.0/（float）i;

}

else

{sum=sum+1.0/（float）i;

}

}

returnsum;

}

voidmain（）

{inta;

floatb;

printf（"请输入一个整数：

"）;

scanf（"%d",&a）;

b=count（a）;

printf（"表达式的值=%f",b）;

printf（"\n"）;

}

3题

#include

intf1（inta,intb）;//最大公约数函数

intf2（inta,intb）;//最小公倍数函数

intf1（inta,intb）//最大公约数

{

intmax,min,t;

if（a>b）

max=a,min=b;

elsemax=b,min=a;

for（t=b;t!

=0;）

{

t=max%min;

max=min;

min=t;

}

returnmax;

}

intf2（inta,intb）//最小公倍数

{

ints,y;

y=f1（a,b）;

s=a*b/y;

returns;

}

voidmain（）

{

inta,b,c;

printf（"输入二个数,逗号隔开"）;

scanf（"%d,%d",&a,&b）;

c=f1（a,b）;

printf（"最大公约数为：

%d\n",c）;

printf（"最小公倍数是:

%d\n",f2（a,b））;

}

4.0编写一个函数，实现一个给定的4*4的二维数组行列互换。

#include"stdio.h"

#defineM4

#defineN4

voidy（intstr[][N],inta,intb）;//变换函数

voidp（intstr[][N],inta,intb）;//打印函数

voidmain（）

{

inti,j;

intstr[M][N];

printf（"输入数组中的数\n"）;

for（i=0;i

for（j=0;j

scanf（"%d",&str[i][j]）;

printf（"输入的数组是：

\n"）;

p（str,M,N）;

printf（"变化后的数组是：

\n"）;

y（str,M,N）;

}

voidy（intstr[][N],inta,intb）//变换函数

{

inti,j;

ints[N][M];

for（i=0;i

for（j=0;j

s[j][i]=str[i][j];

for（i=0;i

{

for（j=0;j

printf（"%5d",s[i][j]）;

printf（"\n"）;

}

//p（s,N,M）;为什么这个打印函数用不了？

？

}

voidp（intstr[][N],inta,intb）//打印函数

{

inti,j;

for（i=0;i

{

for（j=0;j

printf（"%5d",str[i][j]）;

printf（"\n"）;

}

}

5.0题

#include

longintsum（intn）;

voidmain（）

{

intx;

printf（"输入数:

"）;

scanf（"%d",&x）;

printf（"和为:

%ld\n",sum（x））;

}

longintsum（intn）

{

inti;

longintsum1=0;

for（i=0;i<=n;i++）

sum1=sum1+（i*i+1）;

returnsum1;

}

6.0题已知用梯形法求函数f（x）的定积分的近似公式如下：

h=

f（x）=x*x+1

积分区间[0,1],n=100,即求

#include"stdio.h"

floats（inta,intb,intn）;

floatsum（inta,intb,intn）;

voidmain（）

{

floats0=s（0,1,100）;

printf（"%f\n",s0）;

}

floats（inta,intb,intn）

{

floats1;

floath=（b-a）/n;

floatfa=a*a+1;

floatfb=b*b+1;

s1=h*（fa+fb）/2+sum（a,b,n）;

returns1;

}

floatsum（inta,intb,intn）

{

inti;

floats2=0;

floath=（b-a）/n;

floaty=a+i*h;

for（i=1;i

s2=s2+（y*y+1）;

returns2;

}

7题

用函数实现将任一一个十进制正整数转化为对应的二进制数。

十进制的输入和对应的二进制输出均由主函数完成，转化工作由自定义函数完成。

#include

#include

#include

voidput_01to（unsignedshortintb,char*p_data_2,unsignedshortintarrlen）

{//当前的二进制数字存放在该数组最左边，即第1个元素单元，所以已有的单元需右移一个，然后再放

unsignedshortintlen_2;

inti;

len_2=strlen（p_data_2）;//计算当前字符串长度，即已有的二进制位数

if（len_2==arrlen）

{printf（"二进制数的位数太长了，不能转换！

\n"）;

}

else

{

for（i=len_2;i>0;i--）//右移一位

{*（p_data_2+i）=*（p_data_2+i-1）;

}

//填写当前二进制数字

if（b==1）

*p_data_2='1';

else

*p_data_2='0';

*（p_data_2+len_2+1）='\0';//补字符串结束标志

}

}

voidzhuanhuan_10_to_2（unsignedintdata_10,char*p_data_2,unsignedshortintarrlen）

//在C语言中没有二进制数的表达方式，所以用数组存储二进制数字

//此转换用递归的函数调用，注意计算机导论中的十进制整数到二进制数的转换原理

//次处只考虑十进制整数转换

{unsignedintten;//商

unsignedshortintyushu;//余数

if（data_10!

=0）//此时递归转换结束

{ten=data_10/2;

yushu=data_10%2;

put_01to（yushu,p_data_2,arrlen）;//将余数即二进制数字放入二进制数组

zhuanhuan_10_to_2（ten,p_data_2,arrlen）;//继续转换

}

}

voidmain（）

#definearrBlen100

{

inta,abs_a;

charb_arr[arrBlen];

b_arr[0]='\0';

printf（"请输入一个数据：

"）;

scanf（"%d",&a）;

abs_a=abs（a）;

zhuanhuan_10_to_2（abs_a,b_arr,arrBlen）;

if（a<0）

{printf（"-"）;

}

printf（"%s",b_arr）;

printf（"\n"）;

}

8题

写一个函数，输入一段英文，将字符串中最长的单词输出。

/*本题是输入一段英文，所以不知道这段英文有多长，所以必须用动态分配空间的方法，同样也不知道单词有多少个字母

故均用动态的方法解决存储问题,请参考5-1动态方式2.c

*/

#include

#include

#include

structcharpointer

{char*p_str;//指向英文字符串的某个字符，该指针前字符表示读取过了，该指针指以后的字符，包含该指针指向的字符是未读取的字符，

//每次读取一个单词均从该指针指向的字符开始，逐个向后读取

char*p_maxword;//指向最大单词

char*p_curword;//指向当前单词

};

char*addchar（char*p,charch,intcharnum）

{//添加一个字符空间

if（p==NULL）

{//此时说明以前没有

p=（char*）malloc（sizeof（char）*1）;

}

else

{//此时说明不是第1个字符，即不是第1次动态分配空间，而是在上次分配的空间基础上增加空间

p=（char*）realloc（p,sizeof（char）*（charnum+1））;

}

if（p!

=NULL）

{*（p+charnum-1）=ch;

}

returnp;

}

structcharpointergetword（structcharpointerpp）

{intwordchars=1;

//去掉单词前面的单词分隔符号，例如空格、标点符号等，也就是说单词只能是大小写字母

while（!

（（'A'<=*pp.p_str&&*pp.p_str<='Z'）||（'a'<=*pp.p_str&&*pp.p_str<='z'）））

{if（*pp.p_str=='\0'）

{break;//读到英文尾了

}

else

{pp.p_str++;

}

}

//从此处开始读字母字符

while（（'A'<=*pp.p_str&&*pp.p_str<='Z'）||（'a'<=*pp.p_str&&*pp.p_str<='z'））

{pp.p_curword=addchar（pp.p_curword,*pp.p_str,wordchars）;

wordchars++;

pp.p_str++;

}

pp.p_curword=addchar（pp.p_curword,'\0',wordchars）;

returnpp;

}

char*getmaxword（char*p_chars）

{structcharpointercurpointer;

curpointer.p_str=p_chars;

curpointer.p_curword=NULL;

curpointer.p_maxword=NULL;

curpointer=getword（curpointer）;//获取第一个单词

curpointer.p_maxword=curpointer.p_curword;//第一个单词作为当前最大的单词

curpointer.p_curword=NULL;

curpointer=getword（curpointer）;//获取第2个单词

while（strlen（curpointer.p_curword）!

=0）//==0则说明单词字符串已读完

{

if（strlen（curpointer.p_curword）>strlen（curpointer.p_maxword））//此时说明当前识别出的单词是最大的单词

{free（curpointer.p_maxword）;//释放已分配给最大单词的空间

curpointer.p_maxword=curpointer.p_curword;//改指针指向

}

else

{free（curpointer.p_curword）;//释放当前单词空间

}

curpointer.p_curword=NULL;//当前单词指向为空,还原curpointer.p_curword的初始值为NULL

curpointer=getword（curpointer）;//获取第3个及以后的单词

}

returncurpointer.p_maxword;

}

char*getwords（）

{char*str,curchar;

unsignedintcharnum=0;

str=NULL;

printf（"请输入一段英文：

"）;

curchar=getchar（）;

while（curchar!

=10）//Enter的效果是回车换行，其ACSII值是10

{charnum++;

str=addchar（str,curchar,charnum）;

curchar=getchar（）;

}

if（str!

=NULL）

{str=addchar（str,'\0',charnum+1）;

}

returnstr;

}

voidmain（）

{char*p_str,*p_word;

p_str=getwords（）;

//printf（"%s%s\n%d",p_str,p_str,strlen（p_str））;

//return;

if（p_str!

=NULL）

{p_word=getmaxword（p_str）;

printf（"%s",p_word）;

}

free（p_str）;

free（p_word）;

printf（"\n"）;

}

9题

#include

voidmain（）

{

intyear,month,day;

intnum;

printf（"输入年，月，日，用逗号隔开\n"）;

scanf（"%d,%d,%d",&year,&month,&day）;

switch（month）

{

case1:

num=day;break;

case2:

num=31+day;break;

case3:

num=60+day;break;

case4:

num=91+day;break;

case5:

num=121+day;break;

case6:

num=152+day;break;

case7:

num=182+day;break;

case8:

num=213+day;break;

case9:

num=244+day;break;

case10:

num=274+day;break;

case11:

num=305+day;break;

case12:

num=335+day;break;

}

if（（year%4==0&&year%100!

=0）||（year%400==0））

printf（"改日是该年的第%d天\n",num）;

elseif（month>2）printf（"改日是该年的第%d天\n",num-1）;

else

printf（"改日是该年的第%d天\n",num）;

}