高人帮帮忙，做几道C语言的习题！！！

1：若有以下定义和语句：

union data

{int i

char c

float f

}a

int n

则以下语句正确的是（ 1 ）。

1.a=5 2.a={2,’a’,1.2} 3.printf(“%d\n”,a) 4.n=a

2：在C语言中，要求运算数必须是整形的运算符是(4 ).

1./

2.++

3.!=

4.%

3：C语言规定，数组名做实参时，它和对应形参之间的数据传递方式是：_3__

1.用户指定传递方式

2.无传递

3.单向值传递

4.地址传递

4：以下有关宏替换的叙述不正确的是（4）。

1.宏替换不占用运行时间

2.宏名无类型

3.宏替换知识字符替换

4.宏名必须用大写字母表示

5：若希望当A的值为奇数时，表达式的值为“真”，A的值为偶数时，表达式的值为“假”。则以下不能满足要求的表达式是(3).

1.A％2＝＝1

2.!(入％2＝＝0)

3.!(A％2)

4.A％2

6：下面程序段的运行结果是( 1）。

char *s=”abcde”

s+=2printf(“%d”,s)

1.cde

2.字符’c’

3.字符’c’的地址

4.无确定的输出结果

7：设有如下定义：

struct sk

{int n

float x

}data,*p

若要使P指向data中的n域， 正确的负值语句的是（3 )。

1.p=&data.n

2.*p=data.n

3.p=(struct sk*)&data.n

4.p=(struct sk*)data.n

8：利用fseek函数的正确调用形式是(1 ).

1.改变文件的位置指针

2.文件的顺序读写

3.文件的随机读写

4.以上答案均正确

9：C语言结构体类型变量在程序执行期间（1).

1.所有成员一直驻留在内存中

2.只有一个成员驻留在内存中

3.部分成员驻留在内存中

4.没有成员驻留在内存中

10：若有代数式3ae/bc，则不正确的C语言表达式是(3 )

1.a/b/c*e*3

2.3*a*e/b/c

3.3*a*e/b*c

4.a*e/c/b*3

11：以下程序段(4 ).

x=-??1 do{x=x*x} while(! x)

1.是死循环

2.循环执行二次

3.循环执行二次

4.有语法错误

12：以下程序的运行结果是（4).

＃include “stdio.h”

main()

{struct data

{int year,month,day

}today

printf(“%d\n”,sizeof(struct data))

}

1.6

2.8

3.10

4.12

// zhigong.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

char name[10]

int sex[10],number[10],result[10],a,age[10]

int good,b,c

void scan_info()

void ana()

void print()

int main(int argc, char* argv[])

{

scan_info()

ana()

print()

return 0

}

void scan_info() //从键盘接收员工所有信息

{

int a

for(a = 0a <10a++)

{

printf("请输入员工姓名\n")

scanf("%s",&(name[a]))

printf("请输入员工年龄\n")

scanf("%d",&(age[a]))

printf("请输入员工性别(用数字代替:1为男性,2为女性)\n")

scanf("%d",&(age[a]))

printf("请输入员工考号\n")

scanf("%d",&(number[a]))

printf("请输入员工成绩\n")

scanf("%d",&(result[a]))

printf("\n")

}

}

void ana()//整理员工成绩信息

{

good=0b=0c=0

for(a = 0a <10a++)

{

if(result[a] >= 85)good=good+1

if(result[a] >= 60 &&result[a] <85)b=b+1

if(result[a] <60)c=c+1

}

}

void print() //输出信息

{

for(a = 0a <10a++)

{

if(sex[a] ==1 )printf("姓名:%s,性别: 男,年龄: %d,考号: %d,成绩:%d\n",name[a],age[a],number[a],result[a])

else printf("姓名:%s,性别: 女,年龄: %d,考号: %d,成绩:%d\n",&name[a],age[a],number[a],result[a])

}

printf("\n一共有优秀等级:%d人,合格等级%d人,不合格的有%d人\n",good,b,c)

}

写的很赶,有些地方不足的你再改改,反正执行下来没问题,DOS应该能支持中文输入的吧.我用VC++编写的,如果你用TC,头文件还有注释符号你得自己改改.~

你的串号我已经记下，采纳后我会帮你制作

下面说法不正确的是（）。

调用函数时，实参可以是表达式

调用函数时，实参和形参可以共用内存单元

调用函数时，将实参的值复制给形参，使实参变量和形参变量在数值上相等

调用函数时，实参与形参的类型必须一致

~B

~~~6

下面函数调用语句含有实参的个数为（）。

func((exp1,exp2),(exp3,exp4,exp5))

1

2

3

5

~B

~~~6

在C语言中，函数调用时（）。

实参和形参各占独立的存储单元

实参和形参共用存储单元

由系统自动确定实参和形参是否共用存储单元

由用户指定实参和形参是否共用存储单元

~A

~~~6

C语言规定，程序中各函数之间（）。

既允许直接递归调用也允许间接递归调用

既不允许直接递归调用也不允许间接递归调用

允许直接递归调用不允许间接递归调用

不允许直接递归调用允许间接递归调用

~A

~~~8

下列能正确定义一维数组的选项是（）。

int a[5]={0,1,2,3,4,5}

char a[]={0,1,2,3,4,5}

char a={'A','B','C'}

int a[5]="0123"

~B

~~~8

下列叙述中错误的是（）。

对于double类型数组，不可以直接用数组名对数组进行整体输入或输出

数组名代表的是数组所占存储区的首地址，其值不可改变

在程序执行中，数组元素的下标超出所定义的下标范围时，系统将给出“下标越界”的出错信息

可以通过赋初值的方式确定数组元素的个数

~C

~~~8

有下列程序：

#include <string.h>

main()

{ char p[]={'a','b','c'},q[10]={'a','b','c'}

printf("%d%d\n",strlen(p),strlen(q))

}

下列叙述中正确的是（）。

在给p和q数组赋初值时，系统会自动添加字符串结束符，故输出的长度都为3

由于p数组中没有字符串结束符，长度不能确定，但q数组中字符串长度为3

由于q数组中没有字符串结束符，长度不能确定，但p数组中字符串长度为3

由于p和q数组中都没有字符串结束符，故长度都不能确定

~A

~~~8

若要求从键盘读入含有空格字符的字符串，应使用函数（）。

getc()

gets()

getchar()

scanf()

~B

~~~8

当用户要求输入的字符串中含有空格时，应使用的输入函数是（）。

scanf()

getchar()

gets()

getc()

~C

~~~8

当有定义语句：char s[10],若要从终端给s输入5个字符，错误的输入语句是（）。

gets(&s[0])

scanf("%s",s+1)

gets(s)

scanf("%s",s[1])

~D

~~~8

当以下叙述中错误的是（）。

gets函数用于从终端读入字符串

getchar函数用于从磁盘文件读入字符

fputs函数用于把字符串输出到文件

fwrite函数用于以二进制形式输出数据到文件

~B

下列关于字符串的叙述中正确的是（）。

C语言中有字符串类型的常量和变量

两个字符串中的字符个数相同时才能进行字符串大小的比较

可以用关系运算符对字符串的大小进行比较

空串一定比空格打头的字符串小

~D

~~~8

下面能正确进行字符串赋值的是（）。

char s[5]={"ABCDE"}

char s[5]={'A','B','C','D','E'}

char*ss="ABCDE"

char*sprintf("%s",s)

~C

~~~8

字符串"\\\"ABCDEF\"\\"的长度是（）。

15

10

7

8

~B

~~~8

下面各语句行中，能正确进行赋值字符串 *** 作的是（）。

char s[5]={'a','b','c','d','e'}

char *sgets(s)

char *s*s="ABCDEF"

char s[5]scanf("%s",&s)

~B

~~~8

设已执行预编译命令#include<string.h>,以下程序段的输出结果是（）。

char s[]="abcdefg"

printf("%d\n",strlen(s))

7

8

9

10

~A

~~~8

若已包括头文件<string.h>且已有定义char s1[18],s2={"ABCDE"}和int i，现要将字符串"ABCDE"赋给s1,下述语句错误的是（）。

strcpy(s1,s2)

strcpy(s1,"ABCDE")

s1="ABCDE"

for(i=0i<6i++)

s1[i]=s2[i]

~C

###

~~~7

*以下程序的输出结果是[<4>]。

*#include<stdio.h>

*main()

*{

* int a[5]={2,4,6,8,10},*p

* p=ap++

* printf("%d",*p)

*}

~~~7

*以下程序的输出结果是[<3 5>]。

*#include<stdio.h>

*void swap(int *a,int *b)

*{

* int *t

* t=aa=bb=t

*}

*main()

*{

* int i=3,j=5,*p=&i,*q=&j

* swap(p,q)printf("%d %d",*p,*q)

*}

~~~7

*下面程序段的运行结果是[<68>]。

*char str[]="ABCD",*p=str

*printf("%d\n",*(p+3))

###

~~~7

设已有定义：float x，则下列对指针变量p进行定义且赋初值的语句中正确的是( )。

float *p=1024

int *p=(float)x

float p=&x

float *p=&x

~D

~~~7

设有定义语句int (*f)(int)，则以下叙述正确的是( )。

f是基类型为int的指针变量

f是指向函数的指针变量，该函数具有一个int类型的形态

f是指向int类型一维数组的指针变量

f是函数名，该函数的返回值是其类型为int类型的地址

~B

~~~7

设有定义：int n1=0,n2,*p=&n2,*q=&n1，以下赋值语句中与n2=n1语句等价的是( )。

*p=*q

p=q

*p=&n1

p=*q

~A

~~~7

在16位编译系统上，若有定义int a[]={10,20,30},*p=&a，当执行p++后，下列说法错误的是( )。

p向高地址移了一个字节

p向高地址移了一个存储单元

p向高地址移了两个字节

p与n+1等价

~A

~~~7

若有定义语句：int k[2][3],*pk[3]，则下列语句中正确的是( )。

pk=k

pk[0]=&k[1][2]

pk=k[0]

pk[1]=k

~B

~~~7

若有定义：char(*p)[6]则标识符p( )。

是一个指向字符型变量的指针

是一个指针数组名

是一个指针变量，它指向一个含有6个字符型元素的一维数组

定义不合法

~C

~~~7

下面程序段的运行结果是( )。

#include<stdio.h>

void main()

{ char str[]="abc",*p=str

printf("%d\n",*(p+3))

}

67

0

字符'C'的地址

字符'C'

~B

~~~7

若有以下定义，则对a数组元素的正确引用是( )。

int a[5],*p=a

*&a[5]

*a+1

*(p+5)

*(a+2)

~D

###

~~~3

C语言中用[<非0>]表示逻辑"真"，用[<0>]表示逻辑值"假"。

~~~3

C语言中逻辑运算符[<!>]的优先级高于算术运算符。

~~~3

当a=1，b=2，c=3时，以下if语句执行后，a、b、c中的值分别为[<3>]、[<2>]、[<2>]。

if(a>c)

b=aa=cc=b

~~~3

以下程序段的输出结果是[<死循环>]

int k,n,m

n=10m=1k=1

while(k<=n) m*=2

printf("%d\n",m)

~~~3

以下程序的输出结果是[<-1>]

main()

{

int x=2

while(x--)

printf("%d\n",x)

}

~~~3

以下程序段：

s=1.0

for(k=1k<=nk++)

s=s+1.0/(k*(k+1))

printf("%f\n",s)

请填空，使下面的程序段的功能完全与之等同。

s=0.0

[<d=1.0>]

k=0

do

{

s=s+d

[<k++>]

d=1.0/(k*(k+1))

}

while[<k<=n>]

printf("%f\n",s)

~~~3

以下程序功能是：从键盘上输入若干个学生的成绩，统计并输出最高成绩和最低成绩，当输入负数时结束输入。请填空。

main()

{

float x,amax,amin

scanf("%f",&x)

amax=x

amin=x

while[<x>=0>]

{

if(x>amax) amax=x

if[<x<amin>] amin=x

scanf("%f",&x)

}

printf("\namax=%f\namin=%f\n",amax,amin)

}

~~~5

若有定义int a[3][5]则排列在数组中的第九个元素是[<a[1][3]>]

~~~5

strlen("How are you\n")的值是[<12>]

~~~5

C语言中字符串结束的标志是[<'\0'>]

~~~5

写出一个名为s的单精度实型一维数组，长度是6，所有元素初值均为0，其数组定义语句是[<float s[6]={0}>]

~~~5

strcmp("how","How")的值是[<32或者>0>]

~~~6

C语言程序执行的开始处是[<main函数>]

~~~6

C程序中的一个函数由两部分组成，即[<声明部分>]和[<执行部分>]

~~~6

为了保证被调用函数不返回任何值，其函数定义的类型应为[<void>]

~~~6

下面pi函数的功能是，根据以下公式返回满足精度ε要求的∏的值。请填空。∏/2=1+1/3+(1/3)*(2/5)+(1/3)*(2/5)*（3/7)+(1/3)*(2/5)*（3/7)*(4/9)+...

double pi(double eps)

{double s=0.0,t=1.0

int n

for([<n=1>]t>epsn++)

{

s+=t

t=n*t/(2*n+1)

}

return (2.0*[<s>])

}

~~~6

以下函数用以求x的y次方。请填空。

double fun(double x,int y)

{

int idouble z

for(i=1i[<<=y>]i++)

z=[<Z*x>]

return z

}

~~~6

以下程序的功能是计算s=0!+1!+2!+3!+...+n!。请填空。

long f(int n)

{ int ilong s

s=[<1L>]

for(i=1i<=ni++) s=[<S*i>]

return s

}

main()

{

long sint k,n

scanf("%d",&n)

s=[<0>]

for(k=0k<=nk++) s=s+[<f(k)>]

printf("%ld\n",s)

}

###

~~~3

下列运算符中优先级最高的运算符是()。

!

%

-=

&&

~A

~~~3

下列运算符中优先级最低的运算符是()。

||

!=

<=

+

~A

~~~3

为表示关系x≥y≥z,应使用的C语言表达式是()。

(x>=y)&&(y>=z)

(x>=y)AND(y>=z)

(x>=y>=z)

(x>=y)&(y>=z)

~A

~~~3

设a、b和c都是int型变量，且a=3，b=4，c=5；则以下的表达式中，值为0的表达式是()。

a&&b

a<=b

a||b+c&&b-c

!(a<b)&&!c||1

~D

~~~5

若有int s[4]={1,2,3,4}则s[s[0]+2*s[2]-s[3]]的值是()。

1

2

3

4

~D

~~~5

对数组的描述正确的是()。

数组一旦定义去大小是固定的，但数组元素的类型可以不同

数组一旦定义去大小是固定的，但数组元素的类型必须相同

数组一旦定义去大小是可变的，但数组元素的类型可以不同

数组一旦定义去大小是可变的，但数组元素的类型必须相同

~B

~~~5

对字符串"Boy"进行完整赋值的 *** 作是()

char s[3]={'B','o','y'}

char s[]="Boy"

char s[3]={"Boy"}

char s[3]s="Boy"

~B

~~~5

在c语言中引用数组元素时，其数组下标的数组类型允许是()

整型常量

整型表达式

整型常量或整型表达式

任何类型的表达式

~C

~~~5

对以下说明语句的正确理解是()

*int a[10]={6,7,8,9,10}

将5个初值依次赋给a[1]至a[5]

将5个初值依次赋给a[0]至a[4]

将5个初值依次赋给a[6]至a[10]

因为数组长度与初值的个数不相同，所以此语句不正确

~B

~~~5

以下程序段给数组所有元素输入数据，应在下划线处填入的是()

*main()

*{

*int a[10],i=0

*while(i<10) scanf("%d",_______)

*:

*:

*}

a+(i++)

&a(i+1)

a+i

&a[++i]

~D

~~~5

以下程序的输出结果是()

*main()

*{

* int a[]={2,4,6,8},y=1,x,*p

*p=&a[1]

*for(x=0x<3x++) y+=*(p+x)

*printf("%d\n",y)

*}

17

18

19

20

~C

~~~6

下述函数定义形式正确的是()

int f(int xint y)

int f(int x, y)

int f(int x,int y)

int f(x,y:y)

~C

~~~6

关于函数参数，说法正确的是()

实参与其对应的形参各自占用独立的内存单元

实参与其对应的形参共同占用一个内存单元

只有当实参和形参同名时才占用同一个内存单元

形参是虚拟的，不占用内存单元

~A

~~~6

用数组名作为函数的实参时，传递给形参的是()

数组的首地址

数组的第一个元素

数组中的全部元素

数组的元素个数

~A

~~~6

复合语句中定义的变量的作用范围是()

整个源文件

整个函数

整个程序

所定义的复合语句

~D

~~~6

一个函数的返回值由()确定

return语句中的表达式

调用函数的类型

系统默认的类型

被调用函数的类型

~D

~~~6

以下说法正确的是()

C语言程序总是从第一个定义的函数开始执行

在C语言程序设计中，要调用的函数必须在main函数中定义

C语言程序总是从main函数开始执行

C语言程序中的main函数必须放在程序的开始部分

~C

~~~6

以下函数的类型是()

*fff(float x)

*{

*printf("",x*x)

*}

与参数x的类型相同

void类型

int类型

无法确定

~C

~~~6

以下程序的输出结果是()

*fun(int a,int b)

*{int c

*c=a+b

*retutn c

*}

*main()

*{int x=6,y=7,z=8,r

*r=func((x--,y++,x+y),z--)

*printf("%d\n",r)

*}

11

20

21

31

~C

~~~10

当说明一个结构体变量时，系统分配给它的内存是()

各成员所需内存总量的总和

结构中第一个成员所需内存量

成员中占内存量最大者所需的容量

结构中最后一个成员所需内存量

~A

~~~10

设有以下说明语句：

*struct stu

*{int a

* float b

*}stutype

*则下面叙述不正确的是()

strut是结构体类型的关键字

strut stu是用户定义的结构体类型

stutype是用户定义的结构体类型名

a和b都是结构体成员名

~C

~~~10

C语言结构体类型变量在执行期间()

所有成员一直驻留在内存中

只有一个成员驻留在内存中

部分成员驻留在内存中

没有成员驻留在内存中

~A

~~~11

若想对文本文件只进行读 *** 作，打开此文件的方式为()

"r"

"W"

"a"

"r+"

~A

~~~11

如果要打开C盘file文件夹下的abc.dat文件，fopen函数中第一个参数应为()

c:file\abc.dat

c:\file\abc.dat

"c:\file\abc.dat"

"c:\\file\\abc.dat"

~D

~~~11

用fopen函数打开文件， *** 作完毕后用()函数关闭它

fopen

open

fclose

close

~C

~~~11

以下可作为函数fopen中第一个参数的正确格式是()

c:user\test.txt

c:\user\test.txt

"c:\user\test.txt"

"c:\\user\\test.txt"

~D

~~~11

若执行fopen函数时发生错误，则函数的返回值是()

地址值

0

1

EOF

~B

~~~11

若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应是()

"ab++"

"wb+"

"rb+"

"ab"

~B

若以"a+"方式打开一个已存在的文件，则以下叙述正确的是()

文件打开时，原有文件内容不被删除，位置指针移到文件末尾，可作添加和读 *** 作

文件打开时，原有文件内容不被删除，位置指针移到文件开头，可作重写和读 *** 作

文件打开时，原有文件内容不被删除，只可作写 *** 作

以上各种说法皆不正确

~A

###

~~~9

下列程序的功能时：给r输入数据后计算半径为r的圆面积s。程序在编译时出错。

main()

{ int rfloat s

scanf("%d",&r)

s=pi*r*r

printf("s=%f\n",s)

}

出错的原因是（）。

注释语句书写位置错误

存放圆半径的变量r不应该定义为整型

输出语句中格式描述符号非法

计算圆面积的赋值语句中使用了非法变量

~D

~~~9

以下叙述错误的是（）。

在程序中凡是以“#”开始的语句行都是预处理命令行

预处理命令行的最后不能以分号表示结束

#define MAX是合法的宏定义命令行

C程序对预处理命令行的处理是在程序执行的过程中进行的

~C

~~~9

下列叙述中正确的是（）。

预处理命令行必须位于源文件的开头

在源文件的一行上可以有多条预处理命令

宏名必须用大写字母表示

宏替换不占用程序的运行空间

~D

~~~9

若程序中有宏定义行：#define N 100，则下列叙述中正确的是（）。

宏定义中定义了标识符N的值为整数100

在编译程序对C源程序进行预处理时用100替换标识符N

对C源程序进行编译时用100替换标识符N

在运行时用100替换标识符N

~B

~~~9

程序

#include <stdio.h>

#define M 5

#define N M+M

main()

{ int k

k=N*N*5

printf("%d\n",k)

}

的输出结果是（）。

100

50

55

45

~C

~~~9

下列叙述中正确的是（）。

预处理命令行必须位于C源程序的起始位置

在C语言中，预处理命令行都以#开头

每个C程序必须在开头包含预处理命令行：#include<stdio.h>

C语言的预处理不能实现宏定义和条件编译的功能

~B

~~~9

C语言的编译系统对宏命令的处理是（）。

在系统对源程序进行编译前

和其他语句的编译同时进行

在程序连接时进行

在程序运行时进行

~A

~~~9

以下叙述中不正确的是（）。

预处理命令行都必须以“#”号开始，结尾不加分号

在程序中凡是以“#”开始的语句行都是预处理命令行

C程序在执行过程中对预处理命令进行处理

预处理命令可以放在程序的任何位置

~C

~~~9

下面叙述中正确的是（）。

C语言中预处理是指完成宏替换和文件包含指定的文件的调用

预处理命令只能位于C源程序文件的首部

预处理命令可以放在程序中的任何位置

预处理命令结尾需要加分号

~C

~~~9

以下有关宏替换的叙述不正确的是（）。

使用宏定义可以嵌套

宏定义仅仅是符号替换

双引号中出现的宏名不替换

宏名必须用大写字母表示

~D

---