齐大C语言单选题

单项选择

序号

题干

A 过程

B 函数

C 子程序 #md，&12x，month，D 标识符 D56，r_1_2，name，_st_1 答案 B D

1 C语言源程序的基本单位是（）。 2

下列字符序列中，可用作C标识符的一组字符序列是（）。

S.b，sum，average，class，day，_above lotus_1，2day 3 以下标识符中，不能作为合法的C用户定义标识符的是（）。

4 以下数据中，不正确的数值或字符常量是（）。

5

以下数值中，不正确的八进制数或十六进制数是（）。

6 以下的选择中，正确的赋值语句是（）。 7

以下运算符中，优先级最高的运算符是（）。

8 在C语言中，能代表逻辑值“真”的是（）。 9 下列变量说明语句中，正确的是（）。 10

下列字符序列中，不可用作C语言标识符的是（）。

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

12 以下标识符中，不能作为合法的C用户自定义标识符的是（）。

13 以下标识符中，不能作为合法的C用户自定义标识符的是（）。

14 以下标识符中，不能作为合法的C用户自定义标识符的是（）。

15 以下数据中，不正确的数值或字符常量是（）。

16 以下数据中，不正确的数值或字符常量是（）。

17 以下运算符中，优先级最高的运算符是（）。

18 以下运算符中，优先级最高的运算符是（）。

19

以下运算符中，优先级最高的运算符是（）。

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

a3_b3 0 0x16

a=1,b=2 ?:

True char:a b c; b70

在C程序中所用的变

量必须先定义后使用

for answer putchar 8.9e1.2 c *= || =

一个好的程序应该有详尽的注释

void 5L 16 j++ ++

等于0的数 char a;b;c; #ab

程序中，APH和aph

是两个不同的变量 _print to _double 10 66 >= % !=

在C程序中，赋值运算符的优先级最

student_n! _123 W13 -16 a=b=5; && “真” int x;z; symbol 若a和b类型相

同，在执行了赋

值语句a=b；后b中的值将放入

a中，b中的值不变

WORD signed _123 0xff00 0xaa (类型) ! *(乘号) 在C程序中，j++;是一条赋

a1 9861 0xaaaa y==(x) , 非0的数 int x,z; a_1 当输入数值数据时，对于整型变量只能输入整型值；对于实型变量只能输入实型值 siz _if INT 82.5 50 + == () C程序中的#include和

B C C C B D D B

D A C A A A C C D B 21 设C语言中，int类型数据占2个字节，则long类型数据占（）。

22

设C语言中，int类型数据占2个字节，则short类型数据占（）。

23 C语言中，double类型数据占（）。 24 C语言中，char类型数据占（）。 25

设C语言中，int类型数据占2个字节，则unsigned类型数据占（）。 下列程序的输出结果是（）。 main()

26 {char c1=97,c2=98;

printf(\ }

执行下列语句后变量x和y的值是（）。27

y=10;x=y++;

28 下列数据中，为字符串常量的是（）。 29

先用语句定义字符型变量c，然后要将字符a赋给c，则下列语句中正确的是（）。下列语句的结果是（）。 main()

{ int j; 30 j=3;

printf(\

printf(\ } 31

设a=12，且a定义为整型变量。执行语句a+=a-=a*=a;后a的值为（）。 已知year为整型变量，不能使表达式32

（year%4==0&&year0!=0）

||year@0==0的值为真的数据是（）。

单项选择

1个字节 1个字节 1个字节 1个字节 1个字节

97 98 x=10,y=10 A c='a';

3,3 12 1990 低

2个字节 2个字节 2个字节 2个字节 2个字节

97 b x=11,y=11 \c=\

3,4 144 1992 值语句

4个字节 4个字节 4个字节 4个字节 4个字节

a 98 x=10,y=11 How do you do. c=\

4,3 0 1996 #define均不是C语句

8个字节 8个字节 8个字节 8个字节 8个字节

a b x=11,y=10 $abc C='97'

4,4 132 2000 C B D A B

B

C B A

D

C

A

单项选择

33

下列运算符中，不属于关系运算符的是（）。

假设所有变量均为整型，表达34

式:a=2,b=5,a>b?a++:b++,a+b的值

是（）。

35 以下不符合C语言语法的赋值语句是（）。 a=1,b=2 36 以下不符合C语言语法的赋值语句是（）。 j++;

++j; j=j=5;

a=5;b=5; k=2*4,k*4;

y=(a=3,6*5);

y=float(j);

A D

7

8

9

2

B

<

>

>=

!

D

执行下列程序后，其输出结果是（）。 main()

{int a=9; 37

a+=a-=a+a;

printf(\ }

下列语句的输出结果是（）。 38

printf(\下列程序的输出结果是（）。 main()

39 {int a=7,b=5;

printf(\ }

下列程序的输出结果是（）。 main()

40 {int a=011;

printf(\ }

若k,g均为int型变量，则下列语句的输41 出为（）。

18

有语法错误不能通过编译

0

12

15 6f

9

2

5

11

16 70

-18

1

1

10

15 71

-9

0

不确定值

9

16 6f

C

C

A

C

D

单项选择

k=017; g=111; printf(\printf(\

以下程序段的执行结果是（）。 42

输出格式描述符的输出为21.38e+01

输出为2.2e+02

输出为C

double x;x=218.82631; printf(\

若k为int型变量，则以下程序段的执行43

结果是（）。

k=-8567; printf(\若ch为char型变量，k为int型变量（已知字符a的ASCII十进制代码为97）， 44

则以下程序段的执行结果是（）。

ch='a'; k=12;

printf(\printf(\45 若有以下定义：char s='\\092'; 则该语句（）。

46

若a是float型变量，b是unsigned int型变量，以下输入语句中合法的是（）。 已知字母a的ASCII十进制代码为97，则执行下列语句后的输出结果为（）。

47 char a='a'; a--;

printf(\');

下列程序的输出结果为（）。 main()

{int m=7,n=4;

48 float a=38.4,b=6.4,x;

x=m/2+n*a/b+1/2;

printf(\ } 49

若给定条件表达式(M)?(a++):(a--)，则其中表达式M（）。

域宽不够,不能输出

格式描述符不合法,输出无定值

因变量类型与格式描述符的类型不匹配，输出无定值

使s的值包含1个字符

scanf(\

a,&b);

b,c

27.000000

和(M==0)等价

输出为|D|

输出项与格式描述符个数不符，输出为零值或不定值

定义不合法，s的值不确定

scanf(\&b);

a--运算不合法,故有语法错

27.500000

和(M==1)等价

输出为|0-8567|

61,141,k=%d

使s的值包含4个字符 scanf(\,&a,&b);

98,c

28.000000

和(M!=0)等价

-2.14e2

输出为|-8567|

61,141,k=

使s的值包含3个字符 scanf(\\

格式描述和输出项不匹配,输出无定值

28.500000

和(M!=1)等价

B

C

B C

C

A

C

单项选择

以下程序的输出结果是（）。 main()

{int i,j,k,a=3,b=2;

50 i=(--a==b++)?--a:++b;

i=2,j=1,k=3

i=1,j=1,k=2

i=4,j=2,k=4

i=1,j=1,k=3

D

j=a++;k=b;

printf(\ } 51 a,b为整型变量，二者均不为0，以下关系表达式中恒成立的是（）。

52

为了提高程序的运行速度，在函数中对于整型或指针可以使用（）型的变量。 以下程序的输出结果为（）。 main()

53 {int i=8,j=10;

printf(\ }

54

C 语言中以下几种运算符的优先次序（）的排列是正确的。

55

设a为整型变量，初值为12，执行完语句a+=a-=a*a后，a的值是（）。 经下列语句定义后，sizeof(x)，sizeof(y)，sizeof(a)，sizeof(b)在

微机上的值分别为（）。

56 char x=65;

float y=7.3;

int a=100;

a*b/a*b==1 auto

11,10

由高到低

为:!,&&,||,算术运算符,赋值运算符

552

2,2,2,4 a/b*b/a==1 register

9,10

由高到低为:!,算术运算符,关系运算符,&&,||,赋值运算符 144

1,2,2,4 a/b*b+a%b==a static

010,9

由高到低为:算术运算符,关系运算符,赋值运算符,!,&&,|| 264

1,4,2,8 a/b*b==a extern

10,9

由高到低为:算术运算符,关系运算符,!,&&,||,赋值运算符 -264

2,4,2,8 C B

B

B

D C

单项选择

double b=4.5;

用下列语句定义a，b，c，然后执行b=a、c='b'+b，则b，c的值是（）。 57

long a=0xffffff;

int b; char c;

执行下列语句后，a和b的值分别为（）。

int a,b; 58

a=1+'a';

b=2+7%4-'A'; 59

C语言中要求对变量作强制定义的主要理由是（）。

以下程序的输出结果是（）。 main()

{float x=3.6;

60 int i;

i=(int)x;

printf(\ }

经过以下语句定义后，表达式61

z+=x>y?++x:++y的值为（）。

int x=1,y=2,z=3;

以下程序的运行结果是（）。 main() 62

{

int i=1,sum=0;

0ffffff 和0x61

-63,-64

便于移植

x=3.600000,i=4

2

i=10,sum=9

-1和98

98,-60

便于写文件

x=3,i=3

3

i=9,sum=9

-1和97

1,-60

便于编辑预处理程序的处理

x=3.600000,i=3

6

i=2,sum=1

指向同一地址

79,78

便于确定类型和分配空间

x=3 i=3.600000

5

运行出现错误

C

B

D

C

C

D

while(i<10) sum=sum+1;i++;

printf(\ }

以下程序的运行结果是（）。 main()

{ int n;

for(n=1;n<=10;n++)

63 {

if(n%3==0) continue;

printf(\

} }

在C语言中，if语句后的一对原括号中，64

用以决定分支的流程的表

达式（）。

在以下给出的表达式中，与 65

do--while(E)语句中的（E）不等价的

表达式是（）。

假定所有变量均已正确定义，下列程序段运行后x的值是（）。 k1=1; k2=2; 66

k3=3; x=15;

if(!k1) x--;

else if(k2) x=4;

单项选择

12457810

只能用逻辑表达式(!E==0)

14

369

只能用关系表达式(E>0||E<0)

4

12

只能用逻辑表

达式或关系表

达式

(E==0)

15

1234567890

可用任意表达式

(E!=0)

3

A

D

C

B

else x=3;

执行下列语句后的输出为（）。

int j=-1; 67

if(j<=1) printf(\

else printf(\在C语言中，为了结束由while语句构成69

的循环，while后一对圆括号

中表达式的值应该为（）。 下列程序的输出为（）。 main()

{ int y=10; 70

while(y--);

printf(\ } 71

C语言的if语句嵌套时，if与else的配对关系是（）。

设j和k都是int类型，则for循环语句 72

for(j=0,k=-1;k=1;j++,k++) printf(\（）。

设j和k都是int类型，则for循环语句 73

for(j=0,k=0;j<=9&&k!=876;j++) scanf(\（）。

74 下列数组说明中，正确的是（）。

75 下列数组操作说明中，正确的是（）。

单项选择

****

0

y=0

每个else总是与它上面的最近的未被配对的if配对

循环结束的条件不合法

最多执行10次

int array[][4];

static char str[]=\

%%%%

1

while构成无限循环

每个else总是与最外层的if配对

是无限循环

最多执行9次

int array[][];

static char str[]; str=\

%%%%c

True

y=1

每个else与if的配对是任意的

循环体一次也不执行

是无限循环

int

array[][][5]; static char str1[5],str2[]={\str1=str2;

有错,执行不正确

非0

y=-1

每个else总是与它上面的if配对

循环体只执行一次

循环体一次也不执行

int array[3][]; static char str1[],str2[];str2={\hina\strcpy(str1

A

A

D

A

B

A

A

A

单项选择

,str2);

int num['10']; static int a[][3]={{1},{4}}; static char int n=5; int a[n][n+2]; static int a[][]={{1,2,3},{4,5,6}};

static char D

76 下列定义数组的语句中正确的是（）。 char str[10]; static int

char str[]; static int a[2][3]={{1},{4,5}}; static int A

77 下列定义数组的语句中不正确的是（）。 a[2][3]={1,2,3,4,

5,6}; static char 78 下列语句中，不正确的是（）。

若输入ab，程序运行结果为（）。 main()

{ static char a[2]; 79

scanf(\

printf(\ }

80 下列说法不正确的是（）。

81 关于return语句，下列正确的说法是（）。

82 在C语言的函数中，下列正确的说法是（）。 83 在C语言程序中（）。

84 C语言执行程序的开始执行点是（）。

85 C语言程序中，若对函数类型未加显式说明，则函数的隐含说明类型为（）。

86 C语言程序中，当调用函数时（）。

a[2]={1,2};

a,b 主函数main中定义

的变量在整个文件或程序中有效

在主函数和其他函数中均可出现

必须有形参

函数的定义可以嵌

套,但函数的调用不可以嵌套

程序中第一条可以执行语言 void

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

a[2]={'1','2'};

a, 不同函数中,可以使用相同名字的变量

必须在每个函数中出现

形参必须是变量名函数的定义不可以嵌套,但函数的调用可以嵌套 程序中第一个函数double

实参和形参可以共用存储单元

a[2]={'1','2','3'};

b, 形式参数是局部变量

可以在同一个函数中出现多次

可以有也可以没有形参 函数的定义和函数调用均可以嵌套 程序中的main函数 int 可以由用户指定是否共用存

a[2]={'1'};

程序出错 在一个函数内部,可以在

复合语句中定义变量,这些变量只在复合语句中有效

只能在除主函数之外的函数中出现一次 数组名不能作形参 函数的定义和函数调用不可以嵌套 包含文件中的第一个函数 char 计算机系统自动确定是

C C

A

C C B C C A

单项选择

储单元

数组名作为实参数传递给函数时，数组名被处理为（）。

该数组的首地址

否共用存储单元

87

该数组的长度

该数组的元素个数

该数组中各元素的值 预处理就是

预处理是指完成宏

88 以下描述中，正确的是（）。

替换和文件包含中C源程序中凡是

预处理指令只能位

行首以#标识的于C源文件的开始 控制行都是预

完成C编译程序对C源程序第一遍扫描,C C

89 以下对C语言函数的描述中，正确的是（）。 以下函数调用语句中实参的个数是（）。 90

exce((v1,v2),(v3,v4,v5),v6);

以下函数调用语句中实参的个数是（）。 91

func((e1,e2),(e3,e4,e5));

92 C语言中函数调用的方式有（）。

执行下面程序后，输出结果是（）。 main()

{ a=45,b=27,c=0;

c=max(a,b); 93

printf(\ }

int max(x,y)

int x,y;

{ int z;

指定的文件的调用

C程序必须由一个或

一个以上的函数组

成

3

2

函数调用作为语句一种

45

C函数既可以嵌套定义又可以递归调用

4

3

函数调用作为函数表达式一种

27

处理指令

函数必须有返回值,否则不能使用函数

5

5

函数调用作为语句或函数表达式两种

18

为编译词法和语法分析作准备 C程序中有调

用关系的所有函数必须放在同一个程序文件中

6

语法错误

函数调用作为语句、函数表达式或函数参数三种

72

A A

A

D

A

j=3;

printf(\

printf(\ }

已知year为整型变量，不能使表达式149

(year%4==0&&year0!=0)||

year@0==0的值为“真”的数据是（）。150

下列运算符中，不属于关系运算符的是（）。

151 以下不符合C语言语法的赋值语句是（）。152 以下不符合C语言语法的赋值语句是（）。执行下列程序后，其输出结果是（） main()

{int a=9; 153

a+=a-=a+a;

printf(\ }

下列语句的输出结果是（）。 154

printf(\下列程序的输出结果是（）。 155

单项选择

1990

<

a=1,b=2 j++;

18

有语法错误不能通过编译 0

1992

1996

> >= ++j; a=b=5; j=j=5;

k=2*4,k*4;

9 -18 2 1 5 1 2000

!

y=(a=3,6*5);

y=float(j);

-9 0 不确定值 A

D A D

C

C

A

main()

{int a=7,b=5;

printf(\ }

若int类型数据占两个字节，则下列语句的输出为（）。 156

int k=-1; printf(\若k,g均为int型变量，则下列语句的输出为（）。 157

k=017; g=111; printf(\printf(\

以下程序段的执行结果是（）。 158

double x;x=218.82631; printf(\

若k为int型变量，则以下程序段的执行结果是（）。 159

k=-8567; printf(\若ch为char型变量,k为int型变量(已知字符a的ASCII十进制代码为97)， 160

则以下程序段的执行结果是（）。

ch='a'; k=12;

printf(\printf(\161

若有以下定义:char s='\\092'; 则该语句（）。

162 若a是float型变量，b是unsigned型变

单项选择

-1,-1

15 6f

输出格式描述符的域宽不够,不能输出

格式描述符不合法,输出无定值

因变量类型与格式描述符的类型不匹配,输出无定值

使s的值包含1个字符

scanf(\

-1,32767

16 70

输出为21.38e+01

输出为|D|

输出项与格式描述符个数不符,输出为零值或不定值

定义不合法，s的值不确定

scanf(\

-1,32768

15 71

输出为2.2e+02

输出为|0-8567|

61,141,k=%d

使s的值包含4个字符 scanf(\

-1,65535

16 6f

输出为-2.14e2

输出为|-8567|

61,141,k=

使s的值包含3个字符 scanf(\

D

D

C

B

C

B C

量，以下输入语句中合法的是（）。 已知字母a的ASCII十进制代码为97，则执行下列语句后的输出结果为（）。

163 char a='a'; a--;

printf(\');

下列程序的输出结果为（）。 main()

{int m=7,n=4;

164 float a=38.4,b=6.4,x;

x=m/2+n*a/b+1/2;

printf(\ } 165

若给定条件表达式(M)?(a++):(a--),则其中表达式M（）。

以下程序的输出结果是（）。 main()

166 {int i,j,k,a=3,b=2;

i=(--a==b++)?--a:++b;

j=a++;k=b;

单项选择

a,&b);

b,c

27.000000

和(M==0)等价

i=2,j=1,k=3

&b);

a--运算不合法,故有语法错

27.500000

和(M==1)等价

i=1,j=1,k=2

,&a,&b);

98,c

28.000000

和(M!=0)等价

i=4,j=2,k=4

\

格式描述和输出项不匹配,输出无定值

28.500000

和(M!=1)等价

i=1,j=1,k=3

C

A

C

D

printf(\ } 167 a，b为整型变量，二者均不为0，以下关系表达式中恒成立的是（）。

168

为了提高程序的运行速度，在函数中对于整型或指针可以使用（）型的变量。 以下程序的输出结果为（）。 main()

169 {int i=010,j=10;

printf(\ }

170

C 语言中以下几种运算符的优先次序（）的排列是正确的。

171

设a为整型变量，初值为12，执行完语句a+=a-=a*a后，a的值是（）。 经下列语句定义后,sizeof(x)，sizeof(y)，sizeof(a)，sizeof(b)在

微机上的值分别为（）。

172 char x=65;

float y=7.3;

int a=100;

单项选择

a*b/a*b==1 auto

11,10

由高到低

为:!,&&,||,算术运算符,赋值运算符

552

2,2,2,4 a/b*b/a==1 register

9,10

由高到低为:!,算术运算符,关系运算符,&&,||,赋值运算符 144

1,2,2,4 a/b*b+a%b==a static

010,9

由高到低为:算术运算符,关系运算符,赋值运算符,!,&&,|| 264

1,4,2,8 a/b*b==a extern

10,9

由高到低为:算术运算符,关系运算符,!,&&,||,赋值运算符 -264

2,4,2,8 C B

B

B

D C

double b=4.5;

用下列语句定义a，b，c，然后执行b=a?c='b'+b,则b,c的值是（）。 173

long a=0xffffff;

int b; char c;

执行下列语句后，a和b的值分别为（）。

int a,b; 174

a=1+'a';

b=2+7%-4-'A'; 175

C语言中要求对变量作强制定义的主要理由是（）。

以下程序的输出结果是（）。 main()

{float x=3.6;

176 int i;

i=(int)x;

printf(\ }

177 经过以下语句定义后，表达式

单项选择

0ffffff 和0x61

-63,-64

便于移植

x=3.600000,i=4

2

-1和98

98,-60

便于写文件

x=3,i=3

3

-1和97

1,-60

便于编辑预处理程序的处理

x=3.600000,i=3

6

指向同一地址

79,78

便于确定类型和分配空间

x=3 i=3.600000

5

C

B

D

C

C

z+=x>y?++x:++y的值为（）。

int x=1,y=2,z=3;

以下程序的运行结果是（）。 main() {

178 int i=1,sum=0;

while(i<10) sum=sum+1;i++;

printf(\ }

以下程序的运行结果是（）。 main()

{ int n;

for(n=1;n<=10;n++) 179

{

if(n%3==0) continue;

printf(\

单项选择

i=10,sum=9

12457810

i=9,sum=9

369

i=2,sum=1

12

运行出现错误

1234567890

D

A

单项选择

} }

180

在C语言中，if语句后的一对原括号中，只能用逻辑表

只能用逻辑表达式

只能用关系表达式 达式或关系表

可用任意表D

用以决定分支的流程的表达式（）。 在以下给出的表达式中，与

181

do--while(E)语句中的(E)不等价的

表达式是（）。

假定所有变量均已正确定义，下列程序段运行后x的值是（）。 k1=1; k2=2; k3=3;

182

x=15;

if(!k1) x--;

else if(k2) x=4;

else x=3;

执行下列语句后的输出为（）。

int j=-1; 183

if(j<=1) printf(\

(!E==0) (E>0||E<0) 14 4 **** %%%% 达式

达式

(E==0) (E!=0) 15 3 %%%%c

有错,执行不正确

C

B

A

else printf(\

184

###################################

######################## 在C语言中，为了结束由while语句构成185 的循环，while后一对圆括号

中表达式的值应该为（）。 下列程序的输出为（）。 main()

{ int y=10; 186

while(y--) ;

printf(\ }

187

C语言的if语句嵌套时，if与else的配对关系是（）。

设j和k都是int类型，则for循环语句（）。

188

for(j=0,k=-1;k=1;j++,k++) printf(\

设j和k都是int类型，则for循环语句（）。 189

for(j=0,k=0;j<=9&&k!=876;j++) scanf(\

190 下列数组说明中，正确的是（）。

191 下列数组说明中，正确的是（）。

单项选择

a=1,b=0 0 y=0

每个else总是与它上面的最近的if配对

循环结束的条件不合法

最多执行10次 int array[][4]; static char str[]=\

a=2,b=1 1 while构成无限循环

每个else总是与最外层的if配对

是无限循环

最多执行9次 int array[][];

static char str[]; str=\

a=1,b=1 True y=1 每个else与if的配对是任意的

循环体一次也不执行

是无限循环

int array[][][5]; static char str1[5],str2[]={\str1=str2;

a=2,b=2 非0 y=-1 每个else总是与它上面的if配对

循环体只执行一次

循环体一次也不执行

int array[3][]; static char str1[],str2[];str2={\hina\strcpy(str1

B

A

D

A

B

A

A

A

单项选择

,str2);

#define size 10

192 下列定义数组的语句中正确的是（）。

char

str1[size],str2[size+2]; static int

193 下列定义数组的语句中不正确的是（）。 a[2][3]={1,2,3,4,

static int a[2][3]={{1},{4,static int a[][3]={{1},{static int a[][]={{1,2D

char str[];

int num['10'];

int n=5; int a[n][n+2];

A

194 下列语句中，不正确的是（）。

若输入ab，程序运行结果为（）。 main()

{ static char a[2]; 195

scanf(\

printf(\ }

196 下列说法不正确的是（）。

197 关于return语句，下列正确的说法是（）。

198 在C语言的函数中，下列正确的说法是（）。 199 在C语言程序中（）。

5,6}; static char a[2]={1,2};

a,b 主函数main中定义

的变量在整个文件或程序中有效

在主函数和其他函数中均可出现

必须有形参

函数的定义可以嵌

套,但函数的调用不可以嵌套

5}}; static int a[2]={'1','2'};

a, 不同函数中,可以使用相同名字的变量

必须在每个函数中出现

形参必须是变量名函数的定义不可以嵌套,但函数的调用可以嵌套

4}}; static char a[2]={'1','2','3'};

b, 形式参数是局部变量

可以在同一个函数中出现多次

可以有也可以没有形参 函数的定义和函数调用均可以嵌套

,3},{4,5,6}};

static char a[2]={'1'};

程序出错 在一个函数内部,可以在

复合语句中定义变量,这些变量只在复合语句中有效

只能在除主函数之外的函数中出现一次 数组名不能作形参 函数的定义和函数调用不可以嵌套

C C

A

C C B 单项选择

程序中第一条可以程序中的main包含文件中的第一个函C

200 C语言执行程序的结束执行点是（）。

程序中第一个函数

201 C语言程序中，若对函数类型未加显式说明，则函数的隐含说明类型为（）。

202 C语言程序中，当调用函数时（）。

203

数组名作为实参数传递给函数时，数组名被处理为（）。

204 以下描述中，正确的是（）。

205 以下对C语言函数的描述中，正确的是（）。以下函数调用语句中实参的个数是（）。206

exce((v1,v2),(v3,v4,v5),v6); 以下函数调用语句中实参的个数是（）。207

func((e1,e2),(e3,e4,e5));

208 C语言中函数调用的方式有（）。

执行下面程序后，输出结果是（）。 main() 209

{ a=45,b=27,c=0;

执行语言 void

实参和虚参各占一个独立的存储单元

该数组的长度 预处理是指完成宏

替换和文件包含中指定的文件的调用

C程序必须由一个或

一个以上的函数组

成

3

2

函数调用作为语句一种

45

double

实参和虚参共用存储单元

该数组的元素个数

预处理指令只能位

于C源文件的开始 C函数既可以嵌套定义又可以递归调用

4

3

函数调用作为函数表达式一种

27

函数 int 可以由用户指定是否共用存储单元 该数组的首地址

C源程序中凡是

行首以#标识的控制行都是预

处理指令

函数必须有返回值,否则不能使用函数

5

5

函数调用作为语句或函数表达式两种

18

数 char 计算机系统自动确定是否共用存储单元 该数组中各元素的值 预处理就是

完成C编译程序对C源程序第一遍扫描,为编译词法和语法分析作准备 C程序中有调

用关系的所有函数必须放在同一个程序文件中

6

语法错误

函数调用作为语句?函数表达式或函数参数三种

72

C C C C A A

A

D

A

c=max(a,b);

printf(\ }

int max(x,y)

int x,y;

{ int z;

if(x>y) z=x;

else z=y;

return(z); }

以下程序的输出结果为（）。 main()

{int a=1,b=2,c=3,d=4,e=5; 210

printf(\+e))); }

单项选择

15

13

9

函数调用出错

B

int func(int x,int y) {

return(x+y); }

211 下列定义不正确的是（）。

下列程序运行结果为（）。

#define P 3

#define S(a) P*a*a main() 212

{int ar;

ar=S(3+5);

printf(\ }

已知p,p1为指针变量，a为数组名，j为213

整型变量，下列赋值语句中不

正确的是（）。 214

经过下列的语句 int j,a[10],*p;定义后，下列语句中合法的是（）。

215 两个指针变量可以（）。

216 若已定义x为int类型变量，下列语句中

单项选择

#define PI 3.141592

192

p=&j,p=p1;

p=p+2; 相加 int p=&x;

#define S345

29

p=a;

p=a[5]; 相乘 int *p=x;

int max(x,y); int x,y; { } 27

p=&a[j];

p=a[2]+2; 不能指向同一地址 int *p=&x;

static char c;

25

p=10;

p=&(j+2); 指向同一地址 *p=*x;

C

B

D

A D C

说明指针变量p的正确语句是（）。

217 关于指针概念说法不正确的是（）。

218

设有说明int (*ptr)[M];其中标识符ptr是（）。

219 下面选择中正确的赋值语句是（设char a[5],*p=a;）（）。

220

具有相同类型的指针变量p与数组a，不能进行的操作是（）。

若有下列定义，则对a数组元素地址的正确引用是（）。 221

int a[5],*p=a;

若有下列定义和语句，则对a数组元素的非法引用是（）。 222

int a[2][3], (*pt)[3]; pt=a; 若有下列定义，则对a数组元素地址的正确引用是（）。 223

int a[5],*p=a; 以下程序段 char

*alp[]={\224 puts(alp[1]);

的输出结果是（）。

设有以下语句，若0

char

str[4][2]={\,*strp[4];

单项选择

一个指针变量只能指向同一类型变量

M个指向整型变量的指针

p=\p=a;

&a[5]

pt[0][0]

*(p+5)

A

strp

一个变量的地址称为该变量的指针

指向M个整型变量的函数指针

a=\*p=a[0];

p+2

*(pt+1)[2]

*p+2

B

str[k]

只有同一类型

变量的地址才能放到指向该类型变量的指针变量之中 一个指向具有M

个整型元素的一维数组的指针

*p=\p=&a[0];

a++

*(pt[1]+2)

*(a+2)

D

strp[k]

指针变量可以由整数赋,不能用浮点赋

具有M个指针元素的一维指针数组,每个元素都只能指向整型量

*a=\p=&a;

&a

*(a[0]+2

*&a[5]

DEF

*strp

D

C A D B

B

C

D

A

int j;

for (j=0;j<4;j++)

strp[j]=str[j];

执行下列语句后的结果为（）。

int x=3,y; 226

int *px=&x;

y=(*px)++; 227

若有定义:char *p1,*p2,*p3,*p4,ch;则不能正确赋值的程序语句为（）。 228

当定义一个结构体变量时，系统分配给它的内存是（）。

设有如下定义: struct sk {int a; float b;} data,*p; 229

若要使p指向data中的a域，正确的赋值语句是（）。

230 以下对枚举类型名的定义中正确的是（）。

在下列程序段中，枚举变量c1,c2的值依次是（）。

enum color

231 {red,yellow,blue=4,green,white}

c1,c2;

c1=yellow;c2=white;

单项选择

x=3,y=3

p1=&ch;

scanf(\各成员所需内存量的总和

p=(struct sk*)&data.a;

enum

a={sum,mon,tue};

1,6

x=4,y=3

p2=(char *)malloc(1);scanf(\结构中第一个成员所需内存量

p=(struct sk*) data.a;

enum a

{sum=9,mon=-1,tue};

2,5

x=3,y=4

*p3=getchar();

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

p=&data.a;

enum a={\\

1,4

x=4,y=4

p4=&ch;*p4=getchar(); 成员中占内存量最大者所需的容量

*p=data.a;

enum a {\\

2,6

B

C

A A

B

A

单项选择

printf(\232

变量p为指针变量，若p=&a，下列说法不&*p==&a

*&a==a

(*p)++==a++

*(p++)==a++

D

正确的是（）。

以下程序的输出结果是（）。 main()

{ char s[]=\ 233

p=s;

printf(\

printf(\

printf(\ }

执行下列语句后的结果为（）。

int x=3,y; 234

int *px=&x;

y=*px++; 235

下列各m的值中，能使

m%3==2&&m%5==3&&m%7==2为真的是（）。 若有以下程序段:int a=3,b=4; 236

a=a^b;b=b^a;a=a^b;则执行以

上语句后，a和b的值分别是（）。 237 在位运算中，操作数每右移一位,其结果相当于（）。

238

fgets(str,n,fp)函数从文件中读入一个字符串，以下正确的叙述是（）。

123

x=3,y=4

8

a=3,b=4

操作数乘以2 字符串读入后不会自动加入'\\0'

321

x=3,y=3

23

a=4,b=3

操作数除以2 fp是file类型的指针

213

x=4,y=4

17

a=4,b=4

操作数乘以16 fgets函数将从文件中最多读

312

x=3,y不知

6

a=3,b=3

操作数除以16

fgets函数将从文件中最

A

B

B

B

B C

单项选择

入n-1个字符

索引文件和文本文件两种 记录组成

ASCII文件和二进制文件两种 由数据行组成 多读入n个字符

239 C语言中的文件类型只有（）。 240 C语言中，文件由（）。

文本文件一种 由数据块组成 二进制文件一种 由字符(字节)序列组成 B D

241 C语言中的文件的存储方式有（）。

242 下列标识符中，不合法的C语言用户自定义标识符是（）。

243 以下字符中不是转义字符的是（）。

下列程序段的输出结果为（）。

244 float k=0.8567;

printf(\下列程序段的输出结果为（）。 245

float x=213.82631;

printf(\246 C语言的注释定界符是（）。

247 切换编辑窗和信息窗的命令键是（）。

248 下列字符序列中，是C语言保留字的是（）。 249

double x;scanf(\不可以赋值给x变量的常量是（）。

250 C语言能正确处理的指数是（）。 251 下列运算符中是C语言关系运算符的是（）。

252

以下常量中，能够代表逻辑“真”值的常量是（）。

下列程序段的输出结果为（）。

253 int x=3,y=2;

printf(\254

下列程序段的输出结果为（）。

只能顺序存取

print \\a'

0085.6%% 213.82 { } F2

sizeof 123 8.5e4288 ~ \\0'

1 7 只能随机存取(或可以顺序存取,直接存取) 也可随机存取 enum _a \\n'

\\c'

0085.7% 0085.6% 213.83 213 [ ] \\* *\\ F3 F6 in scan 100000 A'

e-32 123000000000 ! & 0

0'

7 3 9 63 只能从文件的开头进行存取 sin1 \\\\'

.857 3.8 /* */ F9 sq \4.5e-5.6 != NULL

5 49 C B C B

C

D C A D C D C

C

C

int a=7,b=9,t;

t=a*=a>b?a:b;

printf(\255

下列表达式中，可作为C合法表达式的是（）。

256 以下语句中，不能实现回车换行的是（）。 执行以下程序段后，输出结果和a的值是（）。 257

int a=10;

printf(\258

以下语句中，循环次数不为10次的语句是（）。

以下程序段的输出结果为（）。

for(i=4;i>1;i--) 259

for(j=1;j

putchar('#');

260

以下程序段中，能够正确地执行循环的是（）。

单项选择

[3,2,1,0]

printf(\

10 和 10

for(i=1;i<10;i++); 无

for(i=1;i>10;i++)

(3,2,1,0)

putchar(\

10 和 11 i=1;do{i++;}while(i<=10);

###### static int a;

while(a)

3=2=1=0 fprintf(stdout,\

11 和 10 i=10;while(i>0){--i;}

# int s=6;

do s-=2;

while(s);

3/2/1/0 fwrite(\,1,1,stdout);

11 和 11 i=1;m:if(i<=10){i++;goto m;}

### int s=6;

m:if(s<100) exit(0);

B

B B

A

B

C

int a=1,b=2,c=3; 261

if(a>c)b=a;a=c;c=b;则c的值为（）。 int a=1,b=2,c=3;

if(a>b)a=b; 262

if(a>c)a=c;

则a的值为（）。 int a=3,b=2,c=1;

if(a>b>c)a=b; 263

else a=c;

则a的值为（）。

264 求平方根函数的函数名为（）。 265 while(fabs(t)<1e-5)if(!s/10)break;循环结束的条件是（）。

266

int a[10];合法的数组元素的最小下标值为（）。

267

char a[10];不能将字符串\存储在数组中的是（）。

int i,j,a[2][3];按照数组a的元素在内268

存的排列次序，不能将数

1,2,3,4,5,6存入a数组的是（）。 269 static char str[10]=\数组元素

单项选择

1

1

3

cos

t>=1e-5&&t<=-1e-5&&s>-10&&s<10 10

strcpy(a,\

for(i=0;i<2;i++)for(j=0;j<3;j++)a[i][j]=i*3+j+1; 5

2

2

2

abs

fabs(t)<1e-5&&!s/10 9

a[0]=0;strcat(a,\

for(i=0;i<3;i++)for(j=0;j<2;j++)

a[j][i]=j*3+i+1; 6

3

3

1

pow

fabs(t)<1e-5 1

a=\

for(i=0;i<6;i++)a[i/3][i%3

]=i+1; 9

else s-=2; goto m:

不一定

不一定

0

sqrt s/10==0 0 int

i;for(i=0;i

<3;i++)a[i]=i+97;a[i]=0;

for(i=1;i<=6;i++)a[i][i]=i; 10

B

A

C

D A D

C D D 个数为（）。

若char a[10];已正确定义，以下语句中270

不能从键盘上给a数组的

所有元素输入值的语句是（）。 271

char a[]=\输出前5个字符的语句是（）。 int a[10]; 272

给数组a的所有元素分别赋值为1、2、3、??的语句是（）。 以下程序段的输出结果为（）。

char c[]=\ 273

int i=0;

do ;while(c[i++]!='\\0');printf(\,i-1); 274

char a1[]=\将a1串连接到a2串后面的语句是（）。 若有 char

275 s1[]=\

则下列语句中能够实现当字符串s1大于字符串s2时,输出s2的语句是（）。 276 函数的形式参数隐含的存储类型说明是（）。

277

与实际参数为实型数组名相对应的形式参数不可以定义为（）。

278 C语言中不可以嵌套的是（）。

279 用户定义的函数不可以调用的函数是（）。 280 全局变量的定义不可能在（）。 281 对于void类型函数，调用时不可作为（）。

单项选择

gets(a);

printf(\

for(i=1;i<11;i++)a[i]=i;

abc

strcat(a2,a1);

if(strcmp(s1,s1)>0)puts(s2);

extern float a[]; 函数调用

非整型返回值的 函数内部 自定义函数体中的语句

scanf(\

puts(a);

for(i=1;i<11;i++)a[i-1]=i;

ab

strcpy(a2,a1);

if(strcmp(s2,s1)>0)puts(s2);

static float *a; 函数定义 本文件外的 函数外面 循环体里的语句

for(i=0;i<10;i++)a[i]=getchar(); printf(\);

for(i=1;i<11;i++)a[i+1]=i;

2

strcat(a1,a2);

if(strcmp(s2,t)>0)puts(s2);

register float a; 循环语句 main函数 文件外面 if语句的成分语句

a=getchar();

a[5*2]=0;puts(a);

for(i=1;i<11;i++)a[0]=1;

3

strcpy(a1,a2);

if(strcmp(s1,t)>0)puts(s2);

auto float (*a)[3]; 选择语句 本函数下面定义的 最后一行 表达式

D

A

B

D

A

D

D C B C A D

单项选择

282

在C语言中，调用函数除函数名外，还必须有（）。

函数预说明 编译时进行的

实际参数 程序执行时进行的 struct ( ) 编译前预处理时进行的 enum 函数返回值 编辑时进行的 typedef C C B 283 C程序中的宏展开是在（）。

284 C语言中，定义结构体的保留字是（）。 union 285 结构体类型的定义允许嵌套是指（）。

对结构体类型的变量的成员的访问，无论286

数据类型如何都可使用

的运算符是（）。

287 相同结构体类型的变量之间，可以（）。 288 使用共用体变量，不可以（）。

enum a {sum=9,mon=-1,tue}; 289

定义了（）。

290 在定义构造数据类型时，不能（）。 291 位操作数据的单位是（）位。 292 C语言程序中必须有的函数是（）。

指针变量p进行自加运算(即 执行p++;)293

后，地址偏移值为2，则其

数据类型为（）。 294

若有int i=3,*p;p=&i;下列语句中输出结果为3的是（）。 若有int *p=(int

*)malloc(sizeof(int));则向内存申请295 到内存

空间存入整数123的语句为（）。 若有int

a[10]={0,1,2,3,4,5,6,7,8,9},*p=a;则296 输出结果不为5

的语句为（）。

297 char *s1=\则（）。

298 char h,*s=&h;可将字符H通过指针存入变量h中的语句是（）。

299 若有char a[80],*s=a;不正确的输入语句

成员是已经或正在定义的结构体型

.

相加 节省存储空间 枚举变量 说明变量 十六进制 #include \int printf(\scanf(\printf(\));

s2指向不确定的内存单元 *s=H;

scanf(\成员可以重名

-> 赋值 简化程序设计

3个标识符 说明存储类型 八进制

main

float printf(\

scanf(\

printf(\);

不能访问\

*s='H'; gets(s);

结构体型可以派生

* 比较大小 进行动态管理

枚举数据类型 初始化 二进制 printf

double printf(\p);

scanf(\);

printf(\(p+5));

puts(s1);与

puts(s2);结果相同

s=H;

fscanf(stdin,

定义多个结构体型

& 地址相同 同时访问所有成员

整数9和-1 末尾不写分号 十进制 scanf

char printf(\,p);

scanf(\**p);

printf(\,*p[5]);

s1不能再指向其它单元 s='H' fgets(s,80,

A

A

B D

C

D C B

A

C

A

D

C

B C

是（）。

300 int (*p)[6]; 它的含义为（）。

301 char *match(char c)是（）。 302

若有double *p,x[10];int i=5;使指针变量p指向元素x[5]的语句为（）。 不仅可将C源程序存在磁盘上，还可将数303

据按数据类型分别以什么的

形式存在磁盘上（）。 304 应用缓冲文件系统对文件进行读写操作，打开文件的函数名为（）。

305

应用缓冲文件系统对文件进行读写操作，关闭文件的函数名为（）。

文件中有一个位置指针，指向当前读写的306

位置，不可使p所指文件的

位置返回到文件的开头的是（）。 307

从键盘上输入某字符串时，不可使用的函数是（）。

选择结构中的条件与循环结构中循环成立的条件，

308 在写法上可以是任一表达式，但其值只能

被判断为“真”或“假”。

哪个数作为逻辑“假”值（）。 static struct {int a1;float a2;char a3;}a[10]={1,3.5,'A'}; 309

说明数组a是地址常量，它有10个结构体型的下标变量，采用静态存

储方式，其中被初始化的下标变量是（）。 310 打开文件时，方式“w”决定了对文件进行的操作是（）。

311

int a[10]={1,2,3,4,5,6,7,8};int *p;p=&a[5];p[-3]的值是（）。

312 一个算法应该具有“确定性”等5个特性，单项选择

具有6个元素的一维数组

函数定义的头部 p=&x[i];

内存 open fclose()

rewind(p);

getchar() -1 a[1] 只写盘 2

有零个或多个输入 定义了一个指向具有6个元素的一维数组的指针变量 函数预说明 p=x;

缓冲区 fopen close()

fseek(p,0,SEEK_SET);

gets() 1 a[-1] 只读盘 3

有零个或多个输出 \指向整型指针变量 函数调用 p=x[i];

文件 close fread()

fseek(p,0,0);

scanf() 非零的数 a[0] 可读可写盘 4

有穷性

stdin); 指向6个整数中的一个的地址 指针变量说明 p=&(x+i)

寄存器 fclose fwrite

fseek(p,-3L,SEEK_CUR);

fread() 0 a[10] 追加写盘 不一定 可行性

B

A A C

B A

D

A

D

C

A B B

单项选择

下面对另外4个特性的描述

中错误的是（）。 313

能将高级语言编写的源程序转换为目标程序的是（）。

链接程序

解释程序

编译程序 构成C程序的

C程序中注释部分可

花括号“{“和”}”基本单位是函编辑程序 分号是C语句C

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

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

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

317 在一个C程序中（）。

318 以下叙述中正确的是（）。 319 一个C程序的执行是从（）。

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

321 一个C语言程序是由（）。 322

C语言规定，在一个源程序中，main函数的位置（）。

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

324 以下叙述正确的是（）。

以出现在程序中任意合适的地方

C语言编译时不检查语法

构成C程序的基本单位是函数

main函数必须出现在所有函数之前 C语言的源程序不必

通过编译就可以直接运行

本程序的main函数

开始,到main函数结束

C语言比其他语言高级

一个主程序和若干子程序组成 必须在最开始

一个C源程序可由一个或多个函数组成 在C程序中，main函数必须位于程序的

只能作为函数体的定界符

C语言的子程序有过程和函数两种

可以在一个函数中定义另一个函数

main函数可以在任何地方出现 C语言中的每条可执行语句最终都将被转换成二进制的机器指令 本程序文件的第一个函数开始,到本程序文件的最后一个函数结束

C语言可以不用编译就能被计算机识别执行

函数组成 必须在系统调用的库函数的后面 一个C源程序必须

包含一个main函数 C程序的每行中只能写一条语句

数,所有函数名都可以由用户命名

C语言的函数可以嵌套定义 main()函数必须放在其它函数之前 main函数必须出现在所有函数之后 C源程序经编译形成的二进制代码可以直接运行 本程序的main函数开始,到本程序文件的最后一个函数结束

C语言以接近英

语国家的自然语言和数学语言作为语言的表达形式

若干过程组成 可以任意

C程序的基本组

成单位是函数

C语言本身没有输入输出语句

之间的分隔符,不是语句的一部分 C语言所有函数都是外部函数 所有被调用的函数一定要在调用之前进行定义 main函数必须出现在固定位置 C语言中的函数不可以单独进行编译 本程序文件的第一个函数开始,到本程序main函数结束 C语言出现的最晚,具有其他语言的一切优点 若干子程序组成 必须在最后 在C程序中，

注释说明只能位于一条语句的后面

在对一个C程序进行编译

A D A B B A C B C D C

325 表达式18/4*sqrt(4.0)/8值的数据类型为（）。

326 C语言中运算对象必须是整型的运算符是（）。

327

若变量已正确定义并赋值，下面符合C语言语法的表达式是（）。

若有条件表达式 (exp)?a++:b--，则以下328

表达式中能完全等价于

表达式(exp)的是（）。 329

设以下变量均为int类型，则值不等于7的表达式是（）。

330

在C语言中,int、char和short三种类型数据在内存中所占用的字节数（）。 设C语言中，一个int型数据在内存中占331

2个字节，则unsigned int

型数据的取值范围为（）。 332

在C语言中，char型数据在内存中的存储形式是（）。

设变量a是整型，f是实型，i是双精度333

型，则表达式10+'a'+i*f值的

数据类型为（）。 334 sizeof(float)是（）。

若有定义:int a=7;float x=2.5,y=4.7; 335

则表达式x+a%3*(int)(x+y)%2/4的值是（）。

已知大写字母A的ASCII码值是65，小写336

字母a的ASCII码是97，则用

八进制表示的字符常量'\\101'是（）。 设有说明:char w;int x;float y;double 337

z;则表达式w*x+z-y

值的数据类型为（）。

338 以下选项中合法的用户标识符是（）。 339 以下选项中合法的实型常数是（）。

单项选择

最前面

int %= a:=b+1

(exp==0)

(x=y=6,x+y,x+1)

由用用户自己定义0--255

补码

int

一个双精度型表达式

2.500000

字符A

float

long 5E2.0

float / a=b=c+2

(exp!=0)

(x=y=6,x+y,y+1)

均为2个字节

0--32767

反码

float

一个整型表达式

2.750000

字符a

char

_2Test E-3

double =

int 18.5%3

(exp==1)

(x=6,x+1,y=6,x+y) 是任意的

0--65535

原码

double

一种函数调用

3.500000

字符e

int

3Dmax .2E0

的过程中，可发现注释中的拼写错误

不确定 〈= a=a+7=c+b

(exp!=1)

(y=6,y+1,x=y,x+1) 由所用机器

的机器字长决定

0--2147483647

ASCII码

不确定

一个不合法的表达式

0.000000

非法的常量

double

A.dat 1.3E

C A B

B

C

D C

D

C

B

A

A

D

B C

单项选择

语句printf(\340

的输出结果是

(说明:'\\b'是退格符)（）。 341

若已定义x和y为double类型，则表达式x=1,y=x+3/2 的值是（）。

1

2

2.0 long 2.5 float 2_and=1-e-3A C

a\\bre\\'hi\\'y\\\\\\bou

a\\bre\\'hi\\'y\\bou re'hi'you

abre'hi'y\\bou

C

342 下列变量定义中合法的是（）。

short _a=1-.1e-1; double b=1+5e2.5;

343 若变量a和i已正确定义，且i已正确赋值，合法的语句是（）。

344 设有 int x=11; 则表达式 (x++ * 1/3) 的值是（）。

345

能正确表示逻辑关系:\≥10或a≤0\的C语言表达式是（）。

若以下变量均是整型，且num=sum=7;则计346

算表达式sum=num++,

sum++,++num后sum的值为（）。 347

设 int x=1, y=1; 表达式(!x||y--)的值是（）。

C语言中的标识符只能由字母，数字和下348

划线三种字符组成，

且第一个字符（）。 349 下面四个选项中，均是不合法的用户标识符的选项是（）。

350 下列四个选项中，均是C语言关键字的选项是（）。

351 下列四组选项中，均不是C语言关键字的选项是（）。

352

假设所有变量均为整型，则表达式(a=2,b=5,b++,a+b)的值是（）。

353 若有说明语句:char c='\\72';则变量c（）。 354 下面四个选项中，均是不合法的浮点数的选项是（）。

355

在C语言中，要求运算数必须是整型的运算符是（）。

356 以下符合C语言语法的赋值表达式是（）。 357 下面不正确的字符串常量是（）。

358 以下所列的C语言常量中，错误的是（）。 359

已定义ch为字符型变量，以下赋值语句中错误的是（）。

a==1 3

a>=10 or a<=0

7 0 必须为字母 A P_0 do auto enu include define1 IF2 type 7

包含1个字符 160. 0.12 e3 /

d=9+e+f=d+9 abc'

0xFF ch='\\';

++i; 4

a>=0|a<=10

8 1 必须为下划线

float la0 _A switch typedef continue getc char printf 8

包含2个字符 -e3 2e4.2 .e5 ++ d=9+e \1.2e0.5 ch=62+3;

do=0xfdaL; a=a++=5; 11

a>=10&&a<=0

9 2 必须为字母或下划线 b-a goto int sign union scanf include scanf case 6

包含3个字符

-.18 123e4 0.0 !=

d=9+e,e++,d+9 \2L ch=NULL;

; a=int(i); 12

a>=10‖a<=0

10 -1

可以是字母，

数字和下划线中任一字符

_123 temp int if struct type while for sin 2

说明不合法，c的值不确定-e3 .234 1e3 %

d=9+e++=d+7 \\\72' ch='\\xaa';

B A D B

B

C

C B A B A B D B A B A

单项选择

若a为int类型，且其值为3，则执行完360

表达式a+=a-=a*a后，a的

值是（）。

361 下列选项中，合法的C语言关键字是（）。 VAR

362 设有说明语句:char a='\\72';则变量a（）。 包含1个字符 cher 包含2个字符 integer 包含3个字符 default 说明不合法 D A -3

9

-12

6

C

363

以下选项中，与k=n++完全等价的表达式是（）。

以下for循环的执行次数是

364 for(x=0,y=0;(y=123)&&(x<4);x++);（）。 365 语句while(!E);中的表达式!E等价于（）。 366 下面有关 for 循环的正确描述是（）。

若i为整型变量，则以下循环执行次数是（）。 367

for(i=2;i==0;) printf(\

368

C语言中 while 和 do-while 循环的主要区别是（）。

369 以下不是无限循环的语句为（）。 370 执行语句 for(i=1;i<4;i++); 后变量 i 的值是（）。

371

C语言中用于结构化程序设计的三种基本结构是（）。

372

对 for(表达式1; ;表达式3) 可理解为（）。

373 下列运算符中优先级最高的是（）。

printf函数中用到格式符%5s，其中数字374

5表示输出的字符串占用

5列，如果字符串长度大于5，则输出（）。

375 putchar函数可以向终端输出一个（）。 376 以下描述中正确的是（）。

k=n,n=n+1

是无限循环 E==0

for 循环只能用于

循环次数已经确定的情况

无限次

do-while 的循环体至少无条件执行一次

for(y=0,x=1;x>++y;x=i++) i=x; 3

顺序结构、选择结构、循环结构 for(表达式1;0;表达式3) <

从左起输出该字符串,右补空格

整型变量表达式值 由于 do-while 循环中循环体语句只

n=n+1,k=n

循环次数不定 E!=1

for 循环是先执行循环循环体语句,后判断表达式

0次

while的循环控制条件比 do-while的循环控制条件更严格

for(;;x++=i); 4

if、switch、break for(表达式1;1;表达式3) +

按原字符长从左向右全部输出

实型变量值 do-while 循环由do开始,用while

k=++n

4次 E!=0 在 for 循环中,不能用 break 语句跳出循环体

1次

do-while 允许从外部转到循环体内 while(1){x++;} 5

for、while、do-while for(表达式1;表达式1;表达式3) &&

右对齐输出该

字串,左补空格 字符串 在 do-while 循环体中,一定

k+=n+1

3次 E==1 for 循环的

循环体语句中,可以包含多条语句,但必须用花括号括起来

2次

do-while 的循环体不能是复合语句 for(i=10;;i--) sum+=i; 不定 if、for、continue for(表达式1;表达式3;表达式3) != 输出错误信

息

字符或字符型变量值 do-while 循环中,根据情

A

C A

D B A

A B A B B B

D C

377

以下关于运算符优先顺序的描述中正确的是（）。

378

已知x=43，ch='A'，y=0;则表达式(x>=y&&ch<'B'&&!y)的值是（）。 若希望当A的值为奇数时，表达式的值为“真”，A的值为偶数时，表达 379

式的值为“假”，则以下不能满足要求的表达式是（）。 380

判断char型变量cl是否为小写字母的正确表达式是（）。

381 以下不正确的if语句形式是（）。

为了避免在嵌套的条件语句 if-else 中382

产生二义性，C语言规定:

else子句总是与（）配对。

383 逻辑运算符两侧运算对象的数据类型（）。 384

结构化程序设计所规定的三种基本控制结构是（）。

385 以下叙述正确的是（）。

对以下说明语句 int 386

a[10]={6,7,8,9,10}; 的正确理解是（）。

387 以下不正确的定义语句是（）。

单项选择

能是一条可执行语句,所以循环体内不能使用复合语句

关系运算符<算术运算符<赋值运算符<逻辑运算符 0

A%2==1

a'<=cl<='z'

if(x>y&&x!=y);

缩排位置相同的if

只能是0或1 输入、处理、输出

do-while语句构成

的循环不能用其它语句构成的循环来代替.

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

double

x[5]={2.0,4.0,6.0

结束,在 while(表达式)后面不能写分号

逻辑运算符<关系运算符<算术运算符<赋值运算符 语法错

!(A%2==0)

(cl>=a)&&(cl<=z)

if(x==y) x+=y;

其之前最近的if

只能是0或非0正数

树形、网形、环形

do-while语句构成的循环只能用break语句退出.

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

int

y[5]={0,1,3,5,7,

要有能使 while 后面表达式的值变为零(\假\的操作

赋值运算符<逻辑运算符<关系运算符<算术运算符 1

!(A%2)

('a'>=cl)||('z'<=cl) if(x!=y) scanf(\

) else scanf(\);

其之后最近的if

只能是整型或字符型数据 顺序、选择、循环

用do-while语

句构成的循环,在while后的表达式为非零时结束循环.

将5个初值依次赋给a[6]至a[10] char c1[]={'1','2'

况可以省略 while

算术运算符<关系运算符<赋值运算符<逻辑运算符 \假\

A%2

(cl>='a')&&(cl<='z')

if(x

同一行上的if

可以是任何类型的数据 主程序、子程序、函数 用do-while语句构成的循环,在while后的表达式为零时结束循环 因为数组长

度与初值的个数不相同,所以此语句不正确

char c2[]={'\\x10

C

C C

D

C

B

D C

D B B 388 若有说明:int a[][3]={1,2,3,4,5,6,7};则a数组第一维的大小是（）。 389

若二维数组a有m列,则在a[i][j]前的元素个数为（）。

390

若有说明:int a[3][4];则数组a中各元素（）。

设有数组定义: char array [ ]=\391

则数组 array所占的

空间为（）。 392

以下能正确定义数组并正确赋初值的语句是（）。

393 以下对二维数组a的正确说明是（）。 394 若有说明:int a[10];则对a数组元素的正确引用是（）。

395

在C语言中，一维数组的定义方式为:类型说明符 数组名[？]，？是指（）。 396

以下能对一维数组a进行正确初始化的语句是（）。

397 以下对一维整型数组a的正确说明是（）。 398 若有说明 int a[3][4];则对a数组元素的正确引用是（）。

399

若有说明 int a[3][4];则a数组元素的非法引用是（）。

400

以下能对二维数组a进行正确初始化的语句是（）。

401

以下不能对二维数组a进行正确初始化的语句是（）。

402

若有说明: int a[3][4]={0};则下面正确的叙述是（）。

单项选择

,8.0,10.0};

2 j*m+i

可在程序的运行阶段得到初值0

4个字节

int N=5,b[N][N];

int a[3][] a[10] [常量表达式] int

a[10]=(0,0,0,0,0)

int a(10);

a[2][4] a[0][2*1] int

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

int a[2][3]={0};

只有元素a[0][0]可得到初值0

9};

3 i*m+j

可在程序的编译阶段得到初值0

5个字节

int

a[1][2]={{1},{3}};

float a(3,4) a[3,5] [整型表达式]

int a[10]={};

int n=10,a[n];

a[1,3] a[1][3] int

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

a[][3]={{1,2},{0}};

此说明语句不正确 ,'3','4','5'};

4 i*m+j-1

不能得到确定的初值

6个字节

int

c[2][]={{1,2},{3,4}}; double a[1][4] a(5) [整型常量]或[整型表达式] int a[]={0}; int n;

scanf(\); int a[n];

a[1+1][0] a[4-2][0] int

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

a[2][3]={{1,2},{3,4},{5,6}};

数组a中各元

素都可得到初

值,但其值不一

','\\xa','\\x8'}; 无确定值 i*m+j+1 可在程序的

编译或运行阶段得到初值0

7个字节

int d[3][2]={{1,2},{34}}; float a(3)(4) a[10-10] [整型常量] int

a[10]={10*1};

#define SIZE 10 (换行) int a[SIZE]; a(2)(1) a[0][4] int a[][3]={{1,0,1}{},{1,1}}; int a[][3]={1,2,3,4,5,6}; 数组a中每个元素均可得到初值0

B B

D C

D

C D D C D C D B C D 单项选择

定为0 因为二维数组a中第二维大小

403

若有说明: int a[][4]={0,0};则下面不正确的叙述是（）。

数组a的每个元素都可得到初值0

二维数组a的第一维大小为1

的值除经初值个数的商为1,故数组a的行数为1

404 以下定义语句中，错误的是（）。 int a[]={1,2}; char *a[3]; char 有元素a[0][0]和a[0][1]可得到初值0,其余元素均得不到初值0 int D D

s[10]=\n=5,a[n];

405

在C语言中，引用数组元素时，其数组下标的数据类型允许是（）。

406

以下程序段中，不能正确赋字符串（编译时系统会提示错误）的是（）。

407 以下不能正确定义二维数组的选项是（）。 假定int类型变量占用两个字节，其有定408

义:int x[10]={0,2,4};，

则数组x在内存中所占字节数是（）。

409 以下数组定义中不正确的是（）。

410

以下不能正确进行字符串赋初值的语句是（）。

411

若使用一维数组名作函数实参，则以下正确的说法是（）。

412 凡是函数中未指定存储类别的局部变量，其隐含的存储类别为（）。

413 在C语言中，函数的隐含存储类别是（）。 414 以下正确的描述是：在C语言程序中（）。 415

C语言中，函数值类型的定义可以缺省，此时函数值的隐含类型是（）。

416 以下不正确的说法是：C语言规定（）。 整型常量

char

s[10]=\int

a[2][2]={{1},{2}}

;

3

int a[2][3];

char

str[5]=\

必须在主调函数中说明此数组的大小

自动(auto)

auto

函数的定义可以嵌

套,但函数的调用不

可以嵌套

void

实参可以是常量,变

整型表达式 char

t[]=\=t; int

a[][2]={1,2,3,4};

6 int

b[][3]={0,1,2,3};

char

str[]=\

实参数组类型与形参数组类型可以不匹配 静态(static) static

函数的定义不可以嵌套,但函数的调用可以嵌套 int

形参可以是常量,

整型常量或整型表达式 char s[10];s=\efg\int

a[2][2]={{1},2,3};

10 int

c[100][100]={0};

char

*str=\在被调用函数中,不需要考虑形参数组的大小

外部(extern) extern 函数的定义和函数的调用均不可以嵌套 float 实参可以为任

任何类型的表达式 char s[10];strcpy(s,\g\int a[2][]={{1,2},{3,4}};

20 int d[3][]={{1,2},{1,2,3},{1,2,3,4}}; char str[5]={'g','o','o','d'};

实参数组名与形参数组名必须一致 寄存器(register) 无存储类别 函数的定义和函数的调用均可以嵌套 double 形参应与其

C C D D

D

A

A

A C B B B 单项选择

量或表达式

变量或表达式

何类型 double 对应的实参类型一致

417 以下正确的函数定义形式是（）。

double fun(int double fun(int double

A

fun(int x,int fun(int

418 以下正确的说法是：在C语言中（）。

若调用一个函数，且此函数中没有return419

语句，则正确的说法是：

该函数（）。

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

421 以下正确的说法是（）。

422

若用数组名作为函数的实参，传递给形参的是（）。

423 以下正确的说法是（）。

424

C语言规定:简单变量做实参时，它和对应形参之间的数据传递方式是（）。 425 C语言允许函数类型缺省定义，此时函数值隐含的类型是（）。

426 C语言规定，函数返回值的类型是由（）。

x,int y) 实参和与其对应的

形参各占用独立的存储单元

没有返回值

全局变量的作用域

一定比局部变量的作用域范围大

用户若需调用标准

库函数，调用前必须重新定义

数组的首地址

定义函数时,形参的

类型说明可以放在函数体内

地址传递

float

return语句中的表达式类型所决定

x;int y) 实参和与其对应的形参共占用一个存储单元

返回若干个系统默认值

静态(static)类别变量的生存期贯穿于整个程序的运行期间

用户可以重新定义标准库函数，若如此，该函数将失去原有含义

数组第一个元素的值

return后边的值不能为表达式

单向值传递

int

调用该函数时的主

调函数类型所决定 y); 只有当实参和与其对应的形参同名时才共占用存储单元 能返回一个用户所希望的值

函数的形参都属于全局变量

系统根本不允许用户重新定义标准库函数

数组中全部元素的值 如果函数值的

类型与返回值类型不一致，以函数值类型为准

由实参传给形

参，再由形参传回给实参

long 调用该函数时

系统临时决定

x,y); 形参是虚拟的,不占用存储单元

返回一个不确定的值

未在定义语

句中赋初值的auto变量和static变量的初值都是随机值 用户若需调用标准库函数，调用前不

必使用预编译命令将该函数所在文件包括到用户源文件中，系统自动去调

数组元素的个数 如果形参与实参类型不一致，以实参类型为准 由用户指定的传递方式 double 在定义该函数时所指定的函数类型

A

D

B

B A C B

B

D 单项选择

所决定

427 以下错误的描述是：函数调用可以（）。 出现在执行语句中 428 关于建立函数的目的，以下正确的说法是提高程序的执行效出现在一个表达式中

提高程序的可读性 做为一个函数的实参 减少程序的篇做为一个函数的形参 减少程序文D B （）。

429

以下只有在使用时才为该类型变量分配内存的存储类说明是（）。

430

若已定义的函数有返回值，则以下关于该函数调用的叙述中错误的是（）。 431

当调用函数时，实参是一个数组名，则向函数传送的是（）。

432 在C语言中，形参的缺省存储类是（）。 在调用函数时，如果实参是简单变量，它433

与对应形参之间的数据

传递方式是（）。

434 以下运算符中优先级最低的是（）。 435 sizeof(float)是（）。 436 在C语言中，要求运算数必须是整型或字符型的运算符是（）。

437 在C语言中，要求运算数必须是整型的运算符是（）。

438 在位运算中，操作数每左移一位，其结果相当于（）。

439

在位运算中，操作数每右移一位，其结果相当于（）。

440 表达式，0x13&0x17的值是（）。 441 若a=1,b=2则 a|b的值是（）。

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

443

设char型变量x中的值为10100111，则表达式(2+x)^(~3)的值是（）。 若要说明一个类型名STP，使得定义语句444

STP s等价于char *s，

以下选项中正确的是（）。

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

率

auto和 static 函数调用可以作为独立的语句存在 数组的长度

auto

地址传递

&&

一种函数调用 && ^

操作数乘以2 操作数乘以2 0x17 0

预处理命令行都必须以#号开始

10101001

typedef STP char *s;

在程序的一行上可

以出现多个有效的预处理命令行

auto和 register 函数调用可以作为一个函数的实参 数组的首地址 register

单向值传递

&

一个不合法的表达式 & %

操作数除以2 操作数除以2 0x13 1

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

typedef *char STP;

使用带参的宏时,参数的类型应与宏定义时的一致

幅

register和 static 函数调用可以出现在表达式中

数组每一个元素的地址 static 由实参传给形参，再由形参传回实参 ||

一个整型表达式 ! !

操作数除以4 操作数除以4 0xf8 2

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

typedef stp *char;

宏替换不占用运行时间,只占编译时间

件所占内存 extern和 register 函数调用可以作为一个函数的形参 数组每个元素中的值 extern 传递方式由用户指定 | 一个浮点表达式 || >

操作数乘以4 操作数乘以4 0xec 3 以下是正确的宏定义

#define IBM_PC 01010101

typedef char* STP; 在以下定义中 C R 是称为\宏名\的标识符

B

D B A B

C C B B

A B B D

C

D D

C

单项选择

#define C R 045

以下各选项企图说明一种新的类型名，其typedef int typedef v4: 446

中正确的是（）。

typedef v1 int;

447 以下叙述正确的是（）。

可以把define和if定义为用户标识符

448 以下叙述中不正确的是（）。 表达式a&=b等价于a=a&b

449

设 int b=2;表达式(b>>2)/(b>>1)的值是（）。

0 450 若x=2,y=3则x&y的结果是（）。

0

整型变量x和y的值相等、且为非0值,

451 则以下选项中，结果为零的

x || y 表达式是（）。

452 下面说明不正确的是（）。

char

a[10]=\

设p1和p2是指向同一个字符串的指针变453

量，c为字符变量，则以下

c=*p1+*p2; 不能正确执行的赋值语句是（）。 设 char *s=\则指针变量s454

指向的字符串所占的字节数

9 是（）。 455 对于基本类型相同的两个指针变量之间，不能进行的运算是（）。

< 456

若有以下的定义:int t[3][2];能正确表示t数组元素地址的表达式是（）。 &t[3][2]

457 变量的指针，其含义是指该变量的（）。 值 458 若有语句int *point,a=4;和 point=&a;下面均代表地址的一组选项是（）。 a,point,*&a 459 若有说明:int *p,m=5,n;以下正确的程序p=&n;scanf(\段是（）。

p);

460

若有说明:int *p1,*p2,m=5,n;以下均是正确赋值语句的选项是（）。

p1=&m;p2=&p1 char *a=\等

461 下面判断正确的是（）。

价于 char *a;*a=\

typedef v2=int; 可以把define定义

为用户标识符,但不能把if定义为用户标识符

表达式a|=b等价于a=a|b 2 2

x | y char

a[10],*p=a;p=\ina\

p2=c; 5 = t[3] 地址

&*a,&a,*point p=&n;scanf(\*p)

p1=&m;p2=&n;*p1=*p2; char

str[10]={\};等价于char str[10];str[]={\

v3;

可以把if定义为用户标识符,但不能把define定义为用户标识符 表达式a!=b等价于a=a!b 4 3

x & y char

*a;a=\

p1=p2; 6 + &t[1] 名

*&point,*point,&a

scanf(\);*p=n; p1=&m;p2=p1; char

*s=\等价于 char

*s;s=\int; define和if都不能定义为用户标识符 表达式a^=b等价于a=a^b 8 5

x ^ y char a[10],*p;p=a=\c=*p1*(*p2);

7 - t[2] 一个标志 &a,&*point,point p=&n;*p=m; p1=&m;*p2=*p1; char c[4]=\d[4]=\

等价于 char

C

B C A B D

D

B

C

C D B D D C

C

单项选择

china\

若定义:int a=511,*b=&a;, 则

printf(\的输出结果为（）。

c[4]=d[4]=\abc\

462

无确定值

a的地址

512

511 定义了一个

定义了一个基类型

若有定义:int *p[3];，则以下叙述中正为int的指针变量p，定义了一个指针数组p，该数组含有三定义了一个名为*p的整型数可指向一维数组的指针D

463

确的是（）。

464 下列选项中正确的语句组是（）。

465

若有说明:int n=2,*p=&n,*q=p;，则以下非法的赋值语句是（）。

466

在说明语句:int *f();中，标识符f代表的是（）。

若有定义:int aa[ 8];则以下表达式中不467

能代表数组元aa[1]的

地址的是（）。 468 若有说明:int i, j=2,*p=&i;,则能完成i=j赋值功能的语句是（）。

469

设有定义:int n=0,*p=&n,**q=&p;则以下选项中，正确的赋值语句是（）。

470 fscanf函数的正确调用形式是（）。

471 系统的标准输入文件是指（）。 472 函数 ftell(fp) 的作用是（）。

473 函数 rewind 的作用是（）。

474 fseek函数的正确调用形式是（）。

475 利用 fseek 函数可以实现的操作是（）。

该变量具有三个指针

char s[8]; s={\p=q;

一个用于指向整型数据的指针变量

&aa[0]+1

i=*p; p=1;

fscanf(fp,格式字符串,输出表列); 键盘

得到流式文件中的当前位置 使位置指针重新返回文件的开头

fseek(文件类型指针,起始点,位移量) 改变文件的位置指针

个元素,每个元素都是基类型为int的指针

char *s; s={\*p=*q;

一个用于指向一维数组的行指针

&aa[1]

*p=*&j; *q=2;

fscanf(格式字符串,输出表列,fp); 显示器

移到流式文件的位置指针

将位置指针指向文件中所要求的特定位置

fseek(fp,位移量,起始点)

文件的顺序读写

组，该数组含有三个int类型元素

char s[8]; s=\n=*q; 一个用于指向函数的指针变量

&aa[0]++

i=&j; q=p;

fscanf(格式字符串,文件指针,输出表列); 软盘 初始化流式文件的位置指针 使位置指针指向文件的末尾

fseek(位移量,起始点,fp) 文件的随机读写

变量p，所指一维数组应具有三个int类型元素

char *s; s=\; p=n; 一个返回值为指针型的函数名

aa+1

i=**p; *p=5; fscanf(文件指针,格式字符串,输入表列); 硬盘 以上答案均正确 使位置指针自动移至下一个字符位置 fseek(起始

点,位移量,文件类型指针)

以上答案均正确

B D D D C

B D

D A A A B A 476

函数调用语句：fseek(fp,-20L,2);的含义是（）。

477 若调用fputc函数输出字符成功，则其返回值是（）。

478

在执行 fopen 函数时，ferror 函数的初值是（）。

479 fwrite函数的一般调用形式是（）。

480

以下read函数的调用形式中，参数类型正确的是（）。 已知函数的调用形式：

fread(buffer,size,count,fp);其中481 buffer

代表的是（）。 482

当顺利执行了文件关闭操作时，fclose函数的返回值是（）。

483

若以\方式打开一个已存在的文件，则以下叙述正确的是（）。

若要用fopen函数打开一个新的二进制文484

件，该文件要既能读也能写，

则文件方式字符串应是（）。 485

若执行fopen函数时发生错误，则函数的返回值是（）。

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

487

以下可作为函数fopen中第一个参数的正确格式是（）。

fgetc函数的作用是从指定文件读入一个488

字符，该文件的打开方式

必须是（）。

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

单项选择

将文件位置指针移到距离文件头20个字节处 EOF TRUE

fwrite(buffer,count,size,fp);

read(int fd,char *buf,int count)

一个整数,代表要读入的数据项总数

-1

文件打开时,原有文

件内容不被删除,位置指针移到文件末尾,可作添加和读操作

\

地址值

C语言中的文本文件

以ASCⅡ码形式存储数据

c:user\\text.txt

只写

二进制文件打开后

将文件位置指针从当前位置向后移动20个字节 1 -1

fwrite(fp,size,count,buffer);

read(int *buf,int fd,int count)

一个文件指针,指向要读的文件

TRUE

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

\

0

C语言中对二进制文件的访问速度比文本文件快 c:\%user\\text.txt

追加

在程序结束时,应

将文件位置指针从文件末尾处倒退20个字节 0 1

fwrite(fp,count,size,buffer); read(int

fd,int count,char *buf)

一个指针,指向要读入数据的存放地址

0

文件打开时,原有文件内容被删除,只可作写操作

\

1

C语言中，随机读写方式不适用于文本文件 \.txt\

读或读写

在利用fread

将文件位置指针移到离当前位置20个字节处 输出的字符 0

fwrite(buffer,size,count,fp); read(int count,char *buf,int fd)

一个存储区,存放要读的数据项

1

以上各种说法皆不正确

\

EOF C语言中，顺序读写方式不适用于二进制文件 \text.txt\

答案B和C都正确

不可以用

C

D D D A C

C

A

B

B

D D C

D

490

下列关于C语言数据文件的叙述中正确的是（）。

若fp已正确定义并指向某个文件，当未491

遇到该文件结束标志时函数

feof(fp)的值为（）。

若要打开A盘上user子目录下名为492

abc.txt的文本文件进行读、写操作，

下面符合此要求的函数调用是（）。 493

在C程序中，可把整型数以二进制形式存放到文件中的函数是（）。

若fp是指向某文件的指针，且已读到此494

文件末尾,则库函数feof(fp)

的返回值是（）。 495

C语言结构体类型变量在程序执行期间（）。

496

当说明一个结构体变量时系统分配给它的内存是（）。

单项选择

可以先读文件的末尾,而顺序文件不可以

文件由ASCII码字符序列组成,C语言只能读写文本文件

0

fopen(\c.txt\

fprintf函数

EOF

所有成员一直驻留在内存中 各成员所需内存量的总和

当用fclose函数关闭已打开的文件

文件由二进制数据序列组成,C语言只

能读写二进制文件 1

fopen(\\\abc.txt\

fread函数

0

只有一个成员驻留在内存中 结构中第一个成员所需内存量

函数从二进制文件中读数据时,可以用数组名给数组中所有元素读入数据

文件由记录序

列组成,可按数据的存放形式分为二进制文

件和文本文件

-1

fopen(\r\\abc.txt\b\fwrite函数

非零值

部分成员驻留在内存中 成员中占内存量最大者所需的容量

FILE定义指向二进制文件的文件指针

文件由数据

流形式组成,可按数据的存放形式分为二进制文件和文本文件

一个非0值

fopen(%user\\\\abc.txt\fputc函数

NULL

没有成员驻留在内存中 结构中最后一个成员所需内存量

D

A

B

A C

A

A

本文来源：https://www.bwwdw.com/article/mpto.html