C语言程序设计形成性作业3-4

C语言程序设计形成性作业三
一、选择题
1.在下面的（C）函数声明语句存在语法错误。

A．AA(int a,int b); B．AA(int ,int) C．AA(int a;int b) D．AA(int a,int) 2．在下面的（C）不能作为函数的返回类型。

A．void B．int C．new D．long
3．下面正确的函数原型语句是（B）。

A．int Function(void a); B．void Function(int);
C．int Function(a); D．void int(double a);
4．函数调用func(exp1,exp2),exp3*exp4-exp5)中所含实参的个数为（B）个。

A．1 B．2 C．4 D．5
5．下面的标识符中，（C）是文件级作用域。

A．函数形参B．语句标号C．外部静态类标识符D．自动类标识符
6．下面的标识符中，（B）具有全局级作用域。

A．函数形参B．全局变量C．内部静态类标识符D．自动变量符
7．假定p是一个指向float型数据的指针，则p+1所指数据的地址比p所指数据的地址大（C）字节。

A．1 B．2 C．4 D．8
8．假定a为一个字符数组名，则a[8]的地址比该数组的首地址大（B）个字节。

A．4 B．8 C．16 D．32
9．假定a为一个数组名，则下面的（B）表示有错误。

A．a[i] B．*a++ C．*a D．*(a+1)
10．用calloc函数创建具有10个整型元素的一维数组的正确语句是（C）。

A．int *p=calloc(10,2); B．int *p=callo(10;
C．int *p=calloc(10,4); D．int *p=malloc(10);
11．假定变量m定义为“int m=7;”，则定义p的正确语句为（B）。

A．int p=&m; B．int *p=&m; C．int &p=*m; D．int *p=m;
12．假定k是一个double类型的变量，则定义指向k的变量p的正确语句为（D）。

A．double p=&k; B．double *p=&k;
C．double &p=*k; D．char *p=”Thank you!”;
13．假定一条定义语句为“int a[10],x,*pa=a;”，若要把数组a中下标为3的元素赋值给x，则不正确的语句为（D）。

A．x=pa[3]; B．x=*(a+3); C．a=a[3]; D．x=*pa+3;
14．假定有定义“int b[10];int *pb;”，则不正确的赋值语句为（D）。

A．pb=b; B．pb=&b[0]; C．pb=b+2; D．pb=b[5];
15．假定指针变量p定义为“int *p=new int(100);”，要释放p所指向的动态内存，应使用语句（A）。

A．delete[p]; B．delete *p; C．delete &p; D．delete []p;
16．假定指针变量p定义为“int *p=calloc(30,sizeof(int));”，要释放p所指向的动态内存，应使用语句（D）。

A．delete[p]; B．deldete(p); C．free[]p; D．free(p);
二、填空题
1．在C语言中，一个函数由函数头和_函数体_组成。

2．在函数外定义的变量称为全局变量，若没有被初始化则系统隐含对它所赋的初值为_0_。

3．如果一个函数只允许同一程序文件中的函数调用，则应在访函数定义前加上的C保留字为_static_。

4．如果一个函数直接或间接地调用自身，这样的调用被称为_递归_调用。

5．调用系统函数时，要先使用#include命令包含该函数的原型语句所在_头_文件。

6．函数形参的作用域是该函数的_函数体_。

7．假定p所指对象的值为25，p+1所指对象的值为46，则*p++的值为_25_。

8．假定p所指对象的值为25，p+1所指对象的值为46，则*++p的值为_46_。

9．假定p所指对象的值为25，p+1所指对象的值为46，则执行“*(p++);”语句后，p所指对象的值为_46_。

10．假定a是一个指针数组，则a+1所指对象的地址比a地址大_4*i _字节。

11．若要把一个整型指针p转换为字符指针，则采用的强制转换表达式为_(char*)p _。

12．假定一个数据对象为int*类型，则指向该对象的指针类型为_ int**_。

13．假定p是一个指向整数对象的指针，则用_&p _表示指针变量p的地址。

14．若p指向x，则_*p _与x的等价的。

15．NULL是一个符号常量，通常作为空指针值，它值为_0_。

三、写出下列每个程序运行后的输出结果
1. #include<stdio.h>
void SB(char ch){
switch (ch){
case 'A':case 'a':
printf("WW");break;
case 'B':case 'b':
printf("GG");break;
case 'C':case 'c':
printf("PP");break;
default:printf("BB");break;
}
}
void main(){
char a1='b',a2='C',a3='f';
SB(a1);SB(a2); SB(a3);SB('A');
printf("\n");
}
GG PP BB WW
2. #include<stdio.h>
#include<stdlib.h>
double SD(int a,int b,char op){
double x;
switch(op){
case '+':x=a+b;break;
case '-':x=a-b;break;
case '*':x=a*b;break;
case '/':if(b)x=(double)a/b;
else exit(1);
break;
default:{("运算符错！\n");exit(1);}
}
return x;
}
void main(){
int x=20,y=8;
printf("%3.2lf ",SD(x,y,'-'));
printf("%3.2lf ",SD(x,y,'*'));
printf("%3.2lf ",SD(x,y,'/'));
}
12.00 160.00 3.50
3. #include<stdio.h>
void WF(int x,int y){
x=x+y;
y=x+y;
printf("subs:x,y=%d,%d\n",x,y);
}
void main(){
int x=18,y=23;
printf("main:x,y=%d,%d\n",x,y);
WF(x,y);
x=2*x;
printf("main:x,y=%d,%d\n",x,y);
}
main: x,y=18, 23
subs: x,y=41, 64
main: x,y=36, 23
4. #include<stdio.h>
#include<string.h>
void fun(char ss[]);
void main(){
char s[15]="567891234";
fun(s);
printf("%s\n",s);
}
void fun(char ss[]){
for(i=0;i<n/2;i++){
char c=ss[i];
ss[i]=ss[n-1-i];
ss[n-1-i]=c;
}
}
432198765
5. #include<stdio.h>
void InsertSort(int a[],int n)
{
int i,j,x;
for(i=1;i<n;i++){//进行n次循环
x=a[i];
for(j=i-1;j>=0;j--)//为x顺序向前寻找合适的插入位置if(x>a[j])a[j+1]=a[j];
else break;
a[j+1]=x;
}
}
void main()
{
int i;
int a[6]={20,15,32,47,36,28};
InsertSort(a,6);
for(i=0;i<6;i++)printf("%d ",a[i]);
printf("\n");
}
47 36 32 28 20 15
6. #include<stdio.h>
void main(){
int a[8]={3,5,7,9,11,13,15,17};
int i,*p=a;
for(i=0;i<8;i++){;
printf("%5d ",*p++);
if( (i+1)%4==0 )printf("\n");
}
}
3 5 7 9
11 13 15 17
7. #include<stdio.h>
int i,s=0;
for(i=0;i<n;i++)
s+=a[i];
return s;
}
void main(){
int a[]={5,10,15,20,25,30};
int b=LA(a,4);
int c=LA(a+2,3);
printf("%d %d\n",b,c);
}
50 60
8. #include<stdio.h>
int LB(int *a,int n){
int i,s=1;
for(i=0;i<n;i++)s*=*a++;
return s;
}
void main(){
int a[]={1,2,3,4,2,4,5,2};
int b=LB(a,4)+LB(&a[3],4);
printf("b=%d\n",b);
}
b=184
四、写出下列每个函数的功能
1. #include<stdio.h>
int WB(int a[],int n,int x){
for(int i=0;i<n;i++)
if(a[i]==x)return 1;
return 0;
}
从数组a中顺序查找值为x的元素，若查找成功则返回1，否则返回0。

2. #include<stdio.h>
int WC(int a[],int n,int k){
int c=0;for(int i=0;i<n;i++)
if(a[i]>=k)c++;
return c;
}
统计出数组a中大于等于值为k的元素个数并返回。

3. #include<stdio.h>
#include<stdlib.h>
#include<time.h>
const int N=10;
int ff(int x,int y){
int z;
printf("%d + %d = ",x,y);
scanf("%d",&z);
if(x+y==z)return 1;else return 0;
}
void main()
{
int i,a,b,c=0;
srand(time(0)); //初始化随机数系列
for(i=0;i<N;i++){
a=rand()%20+1; //rand90函数产生0-32767之间的一个随机数
b=rand()%20+1;
c+=ff(a,b);
}
printf("得分：%d\n",c*10);
}
让计算机产生出10道操作数为20以内随机整数的加法题供用户计算，每道题10分，计算完成后打印出得分。

4. int fun6(int m,int n,int b=2)
{
if(m<b && n<b)return m*n;
else if(m%b==0 && n%b==0)return b*fun6(m/b,n/b,b);
else return fun6(m,n,++b);
}
一个递归函数过程，求出两个自然数m和n的最小公倍数。

5. #include<stdio.h>
#include<stdlib.h>
void LI(int n){
int * a=(int *)malloc(n*sizeof(int));
int i;
for(i=0;i<n;i++)scanf("%d",a+i);
for(i=n-1;i>=0;i--)printf("%d ",*(a+i));
printf("\n");
free(a);
}
把从键盘上输入的n个整数按与输入的相反次序显示出来。

6. #include<stdio.h>
int LK(double a[],int n){
double s=0;int i,m=0;
for(i=0;i<n;i++)s+=a[i];
s/=n;
for(i=0;i<n;i++)if(a[i]>=s)m++;
return m;
求出并返回数组a的n个元素中大于等于平均值的元素个数。

答案为隐藏文字
一、选择题
2.假定有“struct BOOK{char title[40];float price;};struct BOOK *book;”，则不正确的语句为
（A）。

A．struct BOOK *x=malloc(book); B．struct BOOK x={“C++ Programming”,27.0}; C．struct BOOK *x=malloc(sizeof(BOOK)); D．struct BOOK **x=&book;
3.假定有“struct BOOK{char title[40];float price;} book;”，则正确的语句为（B）。

A．struct BOOK x=&book; B．struct BOOK *x=&book;
C．struct BOOK x=calloc(BOOK); D．struct BOOK *x=BOOK;
3．表示文件结束的符号常量为（C）。

A．eof B．Eof C．EOF D．feof
4．C语言中系统函数fopen()是（D）一个数据文件的函数。

A．读取B．写入C．关闭D．打开
5．从一个数据文件中读入以换行符结束的一行字符串的函数为（B）。

A．gets() B．fgets() C．getc() D．fgetc()
6．向一个二进制文件写入信息的函数fwrite()带有（D）参数。

A．1 B．2 C．3 D．4
二、填空题
1．假定一个结构类型的定义为“struct A{int a,b;A*c;};”，则该类型的大小为___12_______字节。

2．假定一个结构类型的定义为“struct B{int a[5],char *b;};”，则该类型的大小为___24_______字节。

3．假定一个结构类型的定义为“struct D{int a;union{int b;double c;};struct D* d[2];};”，则该类型的大小为___20_______字节。

4．假定要动态分配一个类型为struct Worker的具有n个元素的数组，并由r指向这个动态数组，则使用语句的表达式为struct Worker* r=__(Worker*)malloc(n*sizeof(Worker));_____。

5．假定要访问一个结构x中的由a指针成员所指向的对象，则表示方法为__x.(*a)___。

6．假定要访问一个结构指针p所指向对象中的b指针成员所指的对象，则表示方法为_____ *(p->b)___
7．与结构成员访问表达式(*fp).score等价的表达式是__fp->score______。

三、写出下列每个程序运行后的输出结果
1. #include<stdio.h>
struct Worker{
char name[15]; //姓名
int age; //年龄
float pay; //工资
};
void main(){
struct Worker x={"wanghua",52,23.50};
struct Worker y,*p;
y=x;p=&x;
printf("%s %d %6.2f\n",,y.age,y.pay);
printf("%s %d %6.2f\n",p->name,p->age,p->pay);
}
输出结果为：
wanghua 52 23.50
wanghua 52 23.50
Press any key to continue
2. #include<stdio.h>
#include<string.h>
struct Worker{
char name[15]; //姓名
int age; //年龄
float pay; //工资
};
void main(){
struct Worker x;
char *t="louting";
int d=38;float f=493;
strcpy(,t);
x.age=d;x.pay=f;
x.age++;x.pay*=2;
printf("%s %d %6.2f\n",,x.age,x.pay);
}
输出结果为：
louting 39 986.00
Press any key to continue
3. #include<stdio.h>
#include<string.h>
struct Worker{
char name[15]; //姓名
int age; //年龄
float pay; //工资
};
int Less(struct Worker r1,struct Worker r2){
if(r1.age<r2.age)return 1;
else return 0;
}
void main(){
struct Worker a[4]={{"abc",25,420},{"def",58,638},{"ghi",49,560},{"jkl",36,375}};
struct Worker x=a[0];
int i;
for(i=1;i<4;i++)
if(Less(x,a[i]))x=a[i];
printf("%s %d %6.2f\n",,x.age,x.pay);
}
输出结果为：
def 58 638.00
Press any key to continue
四、写出下列每个函数的功能
1.
void QA(struct Worker a[],int n){
int i;
for(i=0;i<n;i++)
scanf("%s %d %f",&a[i].name,a[i].age,a[i].pay);
}
假定结构struct Worker的定义如下：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Worker{
char name[15]; //姓名
int age; //年龄
float pay; //工资
};
函数功能为：
输入struct Worker 类型的对象a[n]的各个元素的值
2. struct StrNode *QB(int n){
StrNode * f,*p;
if(n==0)return NULL;
f=(StrNode*)malloc(sizeof(struct StrNode));
scanf("%s",f->name);
p=f;
while(--n){
p=p->next=(StrNode*)malloc(sizeof(struct StrNode));
scanf("%s",p->name);
}
p->next=NULL;
return f;
}
假定结构struct StrNode的定义如下：
struct StrNode{
char name[5];
struct StrNode *next;
};
函数功能为：
建立一个具有n个结点，每个结点的类型是StrNode的链表
3. struct IntNode* FindMax(struct IntNode *f)
{
struct IntNode *p=f;
if(!f)return NULL;
f=f->next;
while(f){
if(f->data < p->data)p=f;
f=f->next;
}
return p;
}
假定结构struct StrNode的定义如下：
struct IntNode{
int data;
struct IntNode * next;
};
函数功能为：
在一个具有n个结点，每个结点的类型是IntNode的链表中寻找data值最大的结点
4. int Count(struct IntNode *f)
{
int c=0;while(f){
c++;
f=f->next;
}
return c;
}
假定结构struct StrNode的定义如下：
struct IntNode{
int data;
struct IntNode * next;
};
函数功能为：
计算一个具有n个结点，每个结点的类型是IntNode的链表的结点数
5. struct IntNode* Input(int n)
{
struct IntNode *f,*p;
f=(IntNode*)malloc(sizeof(struct IntNode));
if(n==0)return NULL;
f->next=NULL;
printf("从键盘输入%d 个整数：",n);
while(n--){
scanf("%d",&(f->data));
p=f;
f=(IntNode*)malloc(sizeof(struct IntNode));
f->next=p;
}
return f->next;
}
假定结构struct StrNode的定义如下：
struct IntNode{
int data;
struct IntNode * next;
};
函数功能为：
在类型为IntNode的链表后输入n个结点的数据
6. #include<stdio.h>
#include<stdlib.h>
#include<string.h>
void JA(char* fname)
{
FILE* fout=fopen(fname,"w");
char a[20];
printf("");
while(1){
scanf("%s",a);
if(strcmp(a,"end")==0)break;
fputs(a,fout);
fputc('\n',fout);
}
fclose(fout);
}
void main()
{
char *p="d:\\xxk\\xuxk1.txt";
JA(p);
}
函数功能为：
在已经存在的d:\xxk文件夹下（如不存在此文件夹程序运行会出错）打开xuxk1.txt文件，并向其中输入一系列长度小于20的字符串，直到输入字符串end结束。