2021知到答案 程序设计基础（山东工商学院） 最新智慧树满分章节测试答案

第三章 单元测试

1、单选题：
char x=0xffff;
printf(“%dn”,x–);
上面程序段的运行结果是

选项：
A:fffe
B:-32768
C:-32767
D:-1
答案: 【-1】

2、单选题：
double d;
float f;
long l;
int i;
i=f=l=d=20/3;
printf(“%d,%1d,%.1f,%.1f,”,i,l,f,d);
上面程序段的运行结果是

选项：
A:6,6,6.0,6.7
B:6,6,6.0,6.0
C:6,6,6.7,6.0
D:6,6,6.7,6.7
答案: 【6,6,6.0,6.0】

3、单选题：
unsigned a=65535;
printf(“%d,%o,%x”,a,a,a);
TC中整型变量占2个字节，则上面程序段的运行结果是

选项：
A:65535,177777,ffff
B:65535,65535,65535
C:-1,65535,ffff
D:-1,177777,ffff
答案: 【-1,177777,ffff】

4、单选题：
关于putchar()的说法正确的是
选项：
A:putchar()不能对转义字符进行操作
B:putchar()函数括号中可以写字符变量或常量，也可以写整型变量或常量
C:其作用由用户向计算机输出一个字符
D:putchar()可用于输出字符串
答案: 【putchar()函数括号中可以写字符变量或常量，也可以写整型变量或常量】

5、单选题：
要从键盘给两个整型变量a、b输入数据，输入格式是1,2，能完成此任务的代码是
选项：
A:scanf(“%d,%d”,&a,&b);
B:scanf(“%d%d”,&a,&b);
C:scanf(“%d%d”,a,b);
D:getchar(a,b);
答案: 【scanf(“%d,%d”,&a,&b);】

6、单选题：
想通过代码“scanf(“%d%d,%d”,&a,&b,&c);”把1、2、3分别存入3个整型变量a、b、c，则正确的键盘输入应该是
选项：
A:

1  2,3

B:

123

C:

1,2,3

D:

1  2  3

答案: 【

1  2,3

】

7、单选题：
关于格式控制字符串%-m.ns,正确的说法是
选项：
A:

如果n>m，则截取n个字符输出，突破m的限制

B:

如果n<m，则字符串向右靠拢，左端补0

C:

如果n>m，则只截取m个字符，其余的舍弃

D:

m表示输出的字符串最少占m列，n为小数精度

答案: 【

如果n>m，则截取n个字符输出，突破m的限制

】

8、单选题：
以下不属于格式控制字符的是
选项：
A:%D
B:%f
C:%X
D:%E
答案: 【%D】

9、单选题：
a、b、c都是整型变量，用“scanf(“%d %2d %*2d %d”,&a,&b,&c);”给3个变量输入数据，设输入格式是12 34 56 78,则3个变量的值分别是
选项：
A:1,34,7
B:12,34,56
C:1,34,78
D:12,34,78
答案: 【12,34,78】

10、单选题：
char c1=’1′,c2=’2′;
c1=getchar();
c2=getchar();
上面的程序段运行时从键盘输入a并回车，则正确的叙述是

选项：
A:

c1被赋予字符a,c2无确定值

B:

程序将等待输入第二个字符

C:

c1被赋予字符a,c2被赋予换行符

D:

c1被赋予字符a,c2维持原值

答案: 【

c1被赋予字符a,c2被赋予换行符

】

11、单选题：
int i;
float f;
scanf(“i=%d,f=%f”,&a,&f);
上面程序段准备把10和5.12分别存给i和f，正确的输入是（）。

选项：
A:105.12
B:10<空格>5.12
C:i=10,f=5.12
D:i=10f=5.12
答案: 【i=10,f=5.12】

12、单选题：
int a;
char b;
float c;
scanf(“%d%c%f”,&a,&b,&c);
若上面程序段运行时键盘输入的字符序列为2223a123o.12,则a、b、c的值分别是

选项：
A:原值不变
B:2223,a,123
C:2223,a,原值
D:2223，a,123o.12
答案: 【2223,a,123】

第四章 单元测试

1、单选题：
int a=3,b=2,c=1,f;
f=a>b>c;
上面程序段执行后，f的值是

选项：
A:不确定
B:1
C:0
D:2
答案: 【0】

2、单选题：
#include <stdio.h> int main ( ){   int a=1,b=2,m=0,n=0,k;   k=(n=b>a)||(m=a<b);   printf (“%d,%d”,k,m);   return 0; }上面程序的运行结果是

选项：
A:

1,0

B:

0,1

C:

0,0

D:

1,1

答案: 【

1,0

】

3、单选题：
以下四个选项中，执行完程序段后y的值不为3的是
选项：
A:int x=5,y=2; if(x) y=3;
B:int x=5,y=2; if(2) y=3;
C:int x=0,y=0; if(x=y) y=3;
D:int x=0,y=2; if(x=y) y=3;
答案: 【int x=0,y=0; if(x=y) y=3;】

4、单选题：
int a=2,b=-1,c=2;
if(a<b)
if(b<0)
c=0;
else c++;
上面的程序段执行后，c的值是

选项：
A:

0

B:

1

C:

3

D:

2

答案: 【

2

】

5、单选题：
int x=10,y=20,z=30;
if(x>y)
z=x;x=y;y=z;
上面代码段执行后，x，y，z的值是

选项：
A:20,30,10
B:10,20,30
C:20,30,30
D:20,10,10
答案: 【20,30,30】

6、单选题：
逻辑运算符中，运算优先级按从高到低正确排序的是
选项：
A:! || &&
B:&& ! ||
C:! && ||
D:|| && !
答案: 【! && ||】

7、单选题：
以下是if语句的基本形式：

if(表达式)语句

其中“表达式”
选项：
A:必须是逻辑表达式
B:必须是关系表达式
C:可以是任意合法的表达式
D:必须是逻辑表达式或关系表达式
答案: 【可以是任意合法的表达式】

8、单选题：
若有表达式(！w)?(–x):(++y),则下列选项中与其等价的表达式是
选项：
A:(w!=1)?(–x):(++y)
B:(w==1)?(–x):(++y)
C:(w!=0)?(–x):(++y)
D:(w==0)?(–x):(++y)
答案: 【(w==0)?(–x):(++y)】

9、单选题：
int w=’b’,x=14,y=15;
w=((x||y)&&(w<‘a’));
执行上面程序段后，w的值为

选项：
A:1
B:0
C:-1
D:NULL
答案: 【0】

10、单选题：
if((x=y=2)>=x&&x=5)
y*=x;
上面程序段执行后，整型变量x、y的值分别是

选项：
A:5、2
B:存在语法错误
C:2、4
D:5、10
答案: 【存在语法错误】

11、单选题：
int x,y;
scanf(“%d%d”,&x,&y);
if(x>y)
x=y;y=x;
else
x++;y++;
printf(“%d,%d”,x,y);
关于上面程序段，下列说法正确的是

选项：
A:有语法错误
B:若输入“4 3”，输出“4,4”
C:若输入“3 4”，输出“4,5”
D:若输入“4 3”，输出“3,4”
答案: 【有语法错误】

12、单选题：
1.  #include输入一个整数
7.     if (m > 0)              //是否为正数
8.     {
9.            if (m % 2 == 0)     //是正数，且能被2整除，则是正偶数
10.          {
11.              printf(“%d is a positive evenn”, m);
12.          }
13.          else                    //不能被2整除，则是正奇数
14.          {
15.              printf(“%d is a positive oddn”, m);
16.          }
17.      }
18.
19.      _______________          //判断是否为负数
20.
21.      {
22.          _______________
23.
24.          {
25.              printf(“%d is a negative evenn”, m);   //是负偶数
26.          }
27.          else
28.          {
29.               printf(“%d is a negative oddn”, m);    //是负奇数
30.          }
31.      }
32.      else
33.      {
34.          printf(“%d is zero.It is an evenn”, m);
35.      }
36.     return 0;
37. }
上面程序代码的功能是判断输入整数的正负性和奇偶性，请将第19行和22行标号处缺少的代码填写完整

选项：
A:

第19行代码： if(m < 0)

第22行代码： if (m % 2 != 0)

B:

第19行代码： else if(m < 0)

第22行代码： if (m % 2 != 0)

C:

第19行代码： if(m < 0)  第22行代码： if (m % 2 == 0)

D:

第19行代码： else if(m < 0)

第22行代码： if (m % 2 == 0)

答案: 【

第19行代码： else if(m < 0)

第22行代码： if (m % 2 != 0)

】

13、单选题：
以下程序段中,与语句: k=a>b?(b>c?1:0):0;功能相同的是
选项：
A:if(a>b) k=1; else if(b>c) k=1; else k=0;
B:if(a<=b) k=0; else if(b<=c) k=1;
C:if((a>b)||(b>c)) k=1; else k=0;
D:if((a>b)&&(b>c)) k=1; else k=0;
答案: 【if((a>b)&&(b>c)) k=1; else k=0;】

14、单选题：
int x=1,a=0,b=0;
switch(x)
{
case 0:b++;
case 1:a++;
case 2:a++;b++;
}
上面程序段执行后，a，b的值分别是

选项：
A:2,1
B:1,0
C:1,1
D:2,2
答案: 【2,1】

15、单选题：
int x=1,y=2,z=3;
switch(x=1){
case 1:
switch(y==2){
case 1:printf(“*”);break;
case 2:printf(“%”);break;
}
case 0:
switch(z){
case 1:printf(“$”);break;
case 2:printf(“&”);break;
default:printf(“#”);
}
}
上面程序段的运行结果是

选项：
A:

*$

B:

%#

C:

*#

D:

$

答案: 【

*#

】

第五章 单元测试

1、单选题：
对于while语句,错误的说法是
选项：
A:

循环体有可能一次也不执行

B:

可以用条件控制循环体的执行不执行

C:

循环体可以是包含若干条语句的复合语句

D:

循环体至少要执行一次

答案: 【

循环体至少要执行一次

】

2、单选题：
对于整型变量x,与while(！x)等价的是
选项：
A:while(x==0)
B:while(x==1)
C:while(x！=1)
D:while(x！=0)
答案: 【while(x==0)】

3、单选题：
以下描述正确的是
选项：
A:do-while循环由do开始,用while结束,在while(表达式)后面必须写分号
B:在do-while循环体中,一定要有能使while后面表达式的值变成零(“假”)的操作
C:do-while循环中,根据情况可以省略while
D:由于do-while循环中循环体语句只能是一条可执行语句,所以循环体内不能使用复合语句
答案: 【do-while循环由do开始,用while结束,在while(表达式)后面必须写分号】

4、单选题：
#include
int main()
{
int x,i;
for(x=3;x<=100;x++){
if(x%2==0) _____;
for(i=2;i<=x-1;i++)
if(x%i==0) _____;
if(i==x) printf(“%d”,x);
}
return 0;
}
上面程序的功能是找出3～100间的素数,程序中所缺的两处应为
选项：
A:continue continue
B:break break
C:continue break
D:break continue
答案: 【continue break】

5、单选题：
设变量已正确定义,下面程序中能计算f=n!的是
选项：
A:

f=0; for(i=1; i<=n; i++) f*=i;

B:

f=1; for(i=n; i>1; i++) f*=i;

C:

f=1; for(i=n; i>=2; i–) f*=i;

D:

f=1; for(i=1; i<n; i++) f*=i;

答案: 【

f=1; for(i=n; i>=2; i–) f*=i;

】

6、单选题：
#include
int main()
{
int x,s=0;
for(x=1;x<=5;x++){
switch(x%3){
case 0:
default:s+=3;
case 1:s+=1;break;
case 2:s+=2;
}
}
printf(“%d”,s);
return 0;
}
上面程序的运行结果是
选项：
A:13
B:10
C:6
D:7
答案: 【10】

7、单选题：
#include
int main()
{
int i,j;
for(i=3;i>=1;i–)
{
for(j=1;j<=2;j++)
printf(“%d”,i+j);
printf(” “);
}
return 0;
}
上面程序的运行结果是
选项：
A:23 43 45
B:43 25 43
C:45 34 23
D:23 34 45
答案: 【45 34 23】

8、单选题：
#include <stdio.h>
int main()
{
int i=10,x=0;
for( ;i<10;i++)
x=x+i;
printf(“%d”,x);
return 0;
}上面程序的运行结果是
选项：
A:

10

B:

1

C:

无限

D:

0

答案: 【

0

】

9、单选题：
以下不是死循环的是
选项：
A:for(;;x+=k);
B:while(1){x++;}
C:for (;(c=getchar())!=’n’;) printf(“%c”,c);
D:for (k=10;;k–) sum=sum+k;
答案: 【for (;(c=getchar())!=’n’;) printf(“%c”,c);】

10、单选题：
以下正确的说法是
选项：
A:在循环体内使用break和continue的作用相同
B:continue 语句的作用是结束整个循环的执行
C:从多层循环嵌套内退出时,只能使用goto语句
D:只能在循环体内和switch语句内使用break语句
答案: 【只能在循环体内和switch语句内使用break语句】

11、单选题：
有关for语句正确的是
选项：
A:只用于循环次数已经确定的情况
B:for循环是先执行循环体语句,后判断表达式
C:for循环中,不能用break跳出循环体
D:for语句的循环体只能是一条语句
答案: 【for语句的循环体只能是一条语句】

12、单选题：
#include <stdio.h>
int main()
{
int i=1,n=1;
for( ;i<3;i++)
{
continue;
n=n+i;
}
printf(“%d”,n);
return 0;
}
上面程序运行后,变量n的值为
选项：
A:

2

B:

4

C:

1

D:

3

答案: 【

1

】

13、单选题：
#include <stdio.h>
int main()
{
int x,s;
for(x=0,s=0;x<=10;x++)
{
if(x%3==0)
continue;
else
{
if(x%4==0)
continue;
else s+=x;
if(s%5==0) break;

}
}
printf(“%d”,s);
return 0;
}
上面程序的运行结果是
选项：
A:

15

B:

5

C:

25

D:

35

答案: 【

15

】

14、单选题：
#include <stdio.h>
int main()
{
int x=012;
do
printf(“%d”,x–);
while(–x);
return 0;
}
上面程序的运行结果是
选项：
A:

8642

B:

108642

C:

86420

D:

10864

答案: 【

108642

】

15、单选题：
#include <stdio.h>
int main()
{
int s=0,i=5;
while(s+=i,i-=2)
printf(“%d”,s);
return 0;
}
上面程序的运行后,循环的执行次数是
选项：
A:

15

B:

9

C:

5

D:

死循环

答案: 【

死循环

】

第六章 单元测试

1、单选题：
fun(float x)
{
float y;
long z;
y=x*x;
z=(long)y;
return(z);
}
上面fun函数的类型是
选项：
A:long
B:int
C:void
D:float
答案: 【int】

2、单选题：
以下正确的函数声明形式是
选项：
A:double fun(x,y);
B:double fun(int x, int y);
C:double fun(int x; int y);
D:double fun(int x, y);
答案: 【double fun(int x, int y);】

3、单选题：
有以下函数定义:void fun(int n,double x) {…} ,若以下选项中的变量都已经正确定义且赋值,则对函数fun的正确调用语句是
选项：
A:k=fun(10,12.5);
B:void fun(n,x);
C:fun(int y,double m);
D:fun(10,12.5);
答案: 【fun(10,12.5);】

4、单选题：
#include <stdio.h>
int a, b;
void swap( )
{
int t;
t=a; a=b; b=t;
}
int main()
{
scanf(“%d,%d”, &a, &b);
swap( );
printf (“a=%d,b=%dn”,a,b);
return 0;
}
假设用户输入5,3,上面程序的运行结果是
选项：
A:

5,3

B:

3,5

C:

a=5,b=3

D:

a=3,b=5

答案: 【

a=3,b=5

】

5、单选题：
#include <stdio.h>
void fun (int a,int b,int c)
{
a=456;
b=567;
c=678;
}
int main()
{
int x=10, y=20,z=30;
fun (x,y,z);
printf(“%d,%d,%dn”,x,y,z);
return 0;
}
上面程序的运行结果是
选项：
A:

678567456

B:

10,20,30

C:

30,20,10

D:

456567678

答案: 【

10,20,30

】

6、单选题：
#include <stdio.h>
void f(int x)
{ }
int main()
{
int a=1;
f(a);
return 0;
}
关于上面的程序,下面说法正确的是
选项：
A:

x是形参,a是实参

B:

x是实参,a是形参

C:

x是形参,a是形参

D:

x是实参,a是实参

答案: 【

x是形参,a是实参

】

7、单选题：
以下不正确的说法是
选项：
A:

实参应与其对应的形参类型一致或者兼容

B:

实参个数与形参个数必须相等

C:

实参可以是常量、变量或表达式

D:

形参可以是常量、变量或表达式

答案: 【

形参可以是常量、变量或表达式

】

8、单选题：
#include stdio.h>
long fib(int g)
{
switch(g)
{
case 0:return 0;
case 1:
case 2:return 1;
}
return ________________;
}
int main()
{
long k;
k=fib(7);
printf(“k=%ldn”,k);
}
上面的程序用递归定义的方法实现求菲波拉契数列1、1、2、3、5、8……, 第7项的值为fib(7),请将程序补充完整.
选项：
A:

fib(g)+fib(g)

B:

fib(7)

C:

fib(g-1)+fib(g-2)

D:

fib(g)+fib(g-1)

答案: 【

fib(g-1)+fib(g-2)

】

9、单选题：
以下对函数的描述中正确的是
选项：
A:函数既可以嵌套定义又可以嵌套调用
B:自定义函数不可以去调用主函数
C:调用函数时,只能把实参值传给形参,形参值不能传给实参
D:函数必须有返回值,否则不能使用函数
答案: 【调用函数时,只能把实参值传给形参,形参值不能传给实参】

10、单选题：
若主函数调用了一个函数, 但被调函数中没有return语句, 关于被调函数，下面说法中正确的说法是
选项：
A:

没有返回值

B:

返回若干个系统默认值

C:

返回一个用户所希望的函数值

D:

返回一个不确定的值

答案: 【

返回一个不确定的值

】

11、单选题：
#include <stdio.h>
int fun(int n)
{
if(n==1)
return 1;
else
return(n+fun(n-1));
}
int main(){
int x;
scanf(“%d”,&x);
x=fun(x);
printf(“%d”,x);
return 0;
}
若输入10,上面的程序运行结果是
选项：
A:

45

B:

55

C:

54

D:

65

答案: 【

55

】

12、单选题：
函数调用时,若实参是变量,则实参和它对应的形参之间的传递方式是
选项：
A:双向传递
B:由实参传给形参，再由形参传回给实参
C:由用户指定的传递方式
D:单向传递
答案: 【单向传递】

13、单选题：
C语言允许函数值类型缺省定义,此时该函数值隐含的类型是
选项：
A:float型
B:double 型
C:long型
D:int型
答案: 【int型】

14、单选题：
关于C语言函数的描述中,正确的是
选项：
A:函数的定义和函数的调用都不可以嵌套
B:函数的定义和函数的调用都可以嵌套
C:函数的定义可以嵌套,但函数的调用不可以嵌套
D:函数的定义不可以嵌套,但函数的调用可以嵌套
答案: 【函数的定义不可以嵌套,但函数的调用可以嵌套】

第七章 单元测试

1、单选题：
若在一个函数的复合语句中定义了一个变量，则该变量
选项：
A:在本源文件范围内有效
B:定义非法
C:只在该复合语句中有效
D:在该函数中有效
答案: 【只在该复合语句中有效】

2、单选题：
某源文件中定义了一个全局变量，其作用范围是
选项：
A:从定义处到本源文件结束
B:整个源文件的范围
C:不知道有无声明，所以不确定
D:所有源文件
答案: 【不知道有无声明，所以不确定】

3、单选题：
在函数体中定义的局部变量，其作用范围是
选项：
A:定义它的源文件内
B:定义它的函数内
C:定义它的大括号内
D:所有源文件
答案: 【定义它的大括号内】

4、单选题：
函数形参的声明不在任何大括号内，关于形参，下列说法正确的是
选项：
A:形参只是一个符号，不表示变量
B:形参是静态局部变量
C:形参是全局变量
D:形参是动态局部变量
答案: 【形参是动态局部变量】

5、单选题：
函数中未指定存储类型的局部变量，其存储类型是
选项：
A:auto
B:extern
C:static
D:register
答案: 【auto】

6、单选题：
关于静态局部变量，正确的说法是
选项：
A:

其他几种说法都不对

B:

执行到它的作用域时分配空间，离开它的作用域时释放空间

C:

程序装载时分配空间，程序结束时才释放空间

D:

从分配空间到程序结束，它一直存在，期间在任何地方都可以使用它

答案: 【

程序装载时分配空间，程序结束时才释放空间

】

7、单选题：
定义了一个变量但未赋初值，关于它的初值，下面说法正确的是
选项：
A:若是static型的全局变量，为0；若是extern型的全局变量，则不确定
B:若是全局变量，则为0；若是局部变量，则不确定
C:若是静态局部变量，则为0；若是自动变量或寄存器变量，则不确定
D:若是动态存储，则为0；若是静态存储，则不确定
答案: 【若是静态局部变量，则为0；若是自动变量或寄存器变量，则不确定】

8、单选题：
关于全局变量的生存期，下面说法正确的是
选项：
A:取决于它定义的位置
B:从源文件开始执行到源文件执行结束
C:取决于它所在的函数
D:从程序装载到程序运行结束

答案: 【从程序装载到程序运行结束
】

9、单选题：
若全局变量定义时未规定属性，则它的属性是
选项：
A:extern
B:register
C:auto
D:static
答案: 【extern】

10、单选题：
#include <stdio.h>
int max(int a,int b)
{
int c;
c=a>b?a:b;
printf(“%d”,c);
return c;
}
int main()
{
int a=4;
max(a,b);
printf(“%d”,max(a,b));
return 0;
}
上面程序的运行结果是

选项：
A:

444

B:

34

C:

4

D:

24

答案: 【

444

】

11、单选题：
int fac (int n)
{
static int f=1;
f*=n;
return f;
}
int main()
{
int i,n;
for(i=1;i<=5;i++)
n=fac(i);
printf(“%d”,n);
return 0;
}
上面程序的运行结果是

选项：
A:24
B:100
C:5
D:120
答案: 【120】

12、单选题：
根据变量的作用域将变量分为
选项：
A:自动变量和寄存器变量
B:自动变量和临时变量
C:全局变量和局部变量
D:静态变量和动态变量
答案: 【全局变量和局部变量】

13、单选题：
全局变量和局部静态变量分配空间的时机是

选项：
A:主函数执行时
B:装载exe文件时
C:执行到作用域的时候
D:主函数结束时
答案: 【装载exe文件时】

14、单选题：
下列变量在程序运行过程中不占内存空间的是
选项：
A:静态局部变量
B:寄存器变量
C:自动局部变量
D:全局变量
答案: 【寄存器变量】

15、单选题：
下面哪种类别的变量允许在其它源文件中使用？
选项：
A:auto
B:register
C:extern
D:static
答案: 【extern】

第八章 单元测试

1、单选题：
下面说法错误的是
选项：
A:宏展开不会出现编译错误
B:宏展开不会进行数据类型的判别
C:宏展开能发现宏定义中的错误
D:宏展开只是简单地文字替换
答案: 【宏展开能发现宏定义中的错误】

2、单选题：
设有宏定义
#define PI 3.14159
在宏展开时，3.14159会被认为是
选项：
A:7个文字符号
B:单精度实数
C:双精度实数
D:字符串
答案: 【7个文字符号】

3、单选题：
文件包含时，可以用也可以用””将被包含文件括起来，下面说法正确的是
选项：
A:能用的一般也可以用””
B:能用的不能用””，反之亦然
C:两者作用相同
D:能用””的一般也可以用
答案: 【能用的一般也可以用””】

4、单选题：
文件包含命令中若用<>包括被包含的文件，表示
选项：
A:既到系统设定的目录中查找，又到本源文件所在目录查找
B:到系统设定的包含目录中查找它
C:其他几种说法都不对
D:要到本源文件所在的目录中查找它
答案: 【到系统设定的包含目录中查找它】

5、单选题：
若有宏定义
#define N 2+1
则printf(“%d”,N*(N+1))的输出结果是
选项：
A:12
B:8
C:6
D:5
答案: 【6】

6、单选题：
有一种方法可以避免一个文件的内容被包含两次或以上，该方法除了文件包含命令外，还需要使用
选项：
A:条件编译
B:宏定义和分支结构
C:宏定义
D:宏定义和条件编译
答案: 【宏定义和条件编译】

7、单选题：
下面关于条件编译的说法，正确的是
选项：
A:条件编译就是在正式编译时，根据条件选择一部分代码留下参与编译，另一部分舍弃
B:若一个程序既能写成条件编译，又能写成分支结构，则用条件编译写成的源程序比用分支结构写成的源程序将来生成的可执行文件更短
C:条件编译两个分支中若都有代码，则这两部分代码都要参加编译
D:条件编译就是在程序执行时，根据条件选择一部分代码执行
答案: 【若一个程序既能写成条件编译，又能写成分支结构，则用条件编译写成的源程序比用分支结构写成的源程序将来生成的可执行文件更短】

8、单选题：
若有定义
#define M(n) a=n*2
int a;
则printf(‘%d’,M(5+1)*3)的输出结果是
选项：
A:36
B:其他答案都不对
C:11
D:21
答案: 【11】

第九章 单元测试

1、单选题：
下面四段程序中，能正确输出变量a的值的是
选项：
A:int a=1, *p=&a; printf(“%d”,*p);
B:int a=1, *p; *p=&a; printf(“%d”,*p);
C:int a=1,*p;
*p=a;
printf(“%d”,*p);
D:int a=1,*p=a; printf(“%d”,*p);
答案: 【int a=1, *p=&a; printf(“%d”,*p);】

2、单选题：
要定义两个指针变量，下面代码正确的是
选项：
A:int *(p1，p2);
B:int *p1, int *p2;
C:int *p1,*p2;
D:int* p1,p2;
答案: 【int *p1,*p2;】

3、单选题：
若有定义：
int *p;
则以下说法正确的是
选项：
A:变量名为p
B:变量类型为int
C:变量名为*p
D:变量基类型为int*
答案: 【变量名为p】

4、单选题：
若有定义
int x,*p;
则能使p指向x的表达式是
选项：
A:p=&x
B:p=*x
C:p=x
D:*p=x
答案: 【p=&x】

5、单选题：
若有定义：
int *p, a=1, b;
则以下正确的程序段是
选项：
A:p=&b;
scanf(“%d”，p)；
B:scanf(“%d”, &b）;
*p=b;
C:p=&b;
scanf（”%d”，&p);
D:p=&b;
scanf(“%d”，*p);
答案: 【p=&b;
scanf(“%d”，p)；】

6、单选题：
若有定义：
int a=511, *b=&a;
则printf(“%dn”, *b)的输出结果为
选项：
A:511
B:a的地址
C:b的地址
D:不确定值
答案: 【511】

第十章 单元测试

1、单选题：
以下对一维数组a的定义中正确的是
选项：
A:int a[5];
B:char a(10);
C:int a[0..100];
D:int k=10;int a[k];
答案: 【int a[5];】

2、单选题：
以下对一维数组的定义中不正确的是
选项：
A:double x[5]={2.0,4.0,6.0,8.0,10.0};
B:char ch2[ ]={‘x10’, ‘xa’, ‘x8’};
C:int y[5]={0,1,3,5,7,9};
D:char ch1[ ]={‘1’, ‘2’, ‘3’, ‘4’, ‘5’};
答案: 【int y[5]={0,1,3,5,7,9};】

3、单选题：
以下对二维数组的定义中正确的是
选项：
A:int a[][]＝{{1,2,3},{4,5,6}}
B:int a[][3]= {1，2，3，4，5，6};
C:int a[][3];
D:int a[4][]={1，2，3，4，5，6};
答案: 【int a[][3]= {1，2，3，4，5，6};】

4、单选题：
假定一个int型变量占用两个字节，若有定义：int x[10]={0,2,4}; 则数组x在内存中所占字节数是
选项：
A:6
B:20
C:3
D:10
答案: 【20】

5、单选题：
#include <stdio.h>
int main()
{
int a[4][4]= {{1,3,5},{2,4,6},{3,5,7}};
printf(“%d%d%d%dn”,a[0][3],a[1][2],a[2][1],a[3][0]);   return 0;
}
上面程序的运行结果是
选项：
A:

5430

B:

输出值不定

C:

0650

D:

1470

答案: 【

0650

】

6、单选题：
int main()
{
int m[][3]= {1,4,7,2,5,8,3,6,9};
int i,j,k=2;
for(i=0; i<3; i++) {
printf(“%d “,m[k][i]);
}
return 0;
}
上面程序的运行结果是
选项：
A:

3 6 9

B:

2 5 8

C:

4 5 6

D:

7 8 9

答案: 【

3 6 9

】

7、单选题：
#include
int main()
{
int b[3][3]= {0,1,2,0,1,2,0,1,2},i,j,t=0;
for(i=0; i<3; i++)
for(j=i; j<=i; j++)
t=t+b[i][b[j][j]];
printf(“%dn”,t);
return 0;
}
上面程序的输出结果是
选项：
A:1
B:9
C:4
D:3
答案: 【3】

8、单选题：
若有定义：int a[2][4];，则引用下标变量正确的是
选项：
A:a[2][2]
B:a[0][4]
C:a[2][2+1]
D:a[0][3]
答案: 【a[0][3]】

9、单选题：
若有定义：int aa[8];，则不能代表数组元素aa[1]地址的是
选项：
A:&aa[0]++
B:&aa[0]+1
C:&aa[1]
D:aa+1
答案: 【&aa[0]++】

10、单选题：
若二维数组y有m列，则排在y[i][j]前的元素个数为
选项：
A:j*m+i
B:i*m+j+1
C:i*m+j
D:i*m+j-1
答案: 【i*m+j】

11、单选题：
若定义一个名为s且初值为”123″的字符数组，则下列定义错误的是
选项：
A:char s[]={“123n”};
B:char s[]={’1’，’2’，’3’，’ ‘}
C:char s[]={“123”};
D:char s[4]={‘1’，’2’，’3’}
答案: 【char s[]={“123n”};】

12、单选题：
下列描述中不正确的是
选项：
A:可以对整型数组进行整体输入、输出
B:不能在赋值语句中通过赋值运算符”=”对字符型数组进行整体赋值
C:可以对字符串进行整体输入、输出
D:字符型数组中可以存放字符串
答案: 【可以对整型数组进行整体输入、输出】

13、单选题：
printf(“%dn”, strlen(“school”)); 以上printf语句的输出结果是
选项：
A:7
B:存在语法错误
C:6
D:不定值
答案: 【6】

14、单选题：
若有语句：char s1[10], s2[10]=”books”;，则能将字符串books存入数组s1的语句是
选项：
A:s1=”books”
B:s1=s2
C:strcpy(s2, s1)
D:strcpy(s1, s2);
答案: 【strcpy(s1, s2);】

15、单选题：
若有定义int a[3][4];,则能输入其第3行第2列元素的正确语句为
选项：
A:scanf(“%d”,a[3,2])
B:scanf(“%d”,*(a+2)+1)
C:scanf(“%d”,*(*(a+2)+1))
D:scanf(“%d”,*(a[2]+1))
答案: 【scanf(“%d”,*(a+2)+1)】

16、单选题：
设有定义：char s[12]=”string”;则printf(“%d”,strlen(s));的输出结果是
选项：
A:6
B:11
C:12
D:7
答案: 【6】

17、单选题：
语句printf(“%d”,strlen(“absno121”));的输出结果是
选项：
A:11
B:8
C:10
D:9
答案: 【9】

18、单选题：
语句strcat(strcpy(str1,str2),str3);的功能是
选项：
A:将字符串str2复制到字符串str1后再将字符串str3连接到字符串str1之后
B:将字符串str1复制到字符串str2中后再连接到字符串str3之后
C:将字符串str2连接到字符串str1后再将字符串str1复制到字符串str3中。
D:将字符串str1连接到字符串str2中后再复制到字符串str3之后
答案: 【将字符串str2复制到字符串str1后再将字符串str3连接到字符串str1之后】

19、单选题：
若有如下定义：char x[]=”abcdefg”; char y[]={‘a’, ‘b’, ‘c’, ‘d’, ‘e’,’f’, ‘g’};，则正确的叙述为:
选项：
A:数组y的长度大于数组x的长度
B:数组x的长度大于数组y的长度
C:数组x和数组y等价
D:数组x和数组y的长度相同
答案: 【数组x的长度大于数组y的长度】

第十一章 单元测试

1、单选题：
若有语句int *point,a=4;和point=&a;下面均代表地址的一组选项是
选项：
A:*&point,*point,&a
B:a,point,*&a
C:&*a,&a,*point
D:&a,&*point ,point
答案: 【&a,&*point ,point】

2、单选题：
有以下程序段
int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b;
b=p[5];
执行后b中的值是
选项：
A:5
B:9
C:6
D:8
答案: 【9】

3、单选题：
int a[7],*p=a;若有以上定义，则p+5表示
选项：
A:元素a[5]的值
B:元素a[6]的地址
C:元素a[6]的值
D:元素a[5]的地址
答案: 【元素a[5]的地址】

4、单选题：
设已有定义: int a[10]={15,12,7,31,47,20,16,28,13,19}，*p; 则下列语句中正确的是
选项：
A:for(p=a,a=a+10;p<a;p++);
B:for(p=a;a<p+10; ++a);
C:for(p=a;p<(a+10);p++);
D:for(p=a;a<(p+10);a++);
答案: 【for(p=a;p<(a+10);p++);】

5、单选题：
#include
int main()
{
int x[] = {10, 20, 30};
int *px = x;
printf(“%d,”, ++*px); printf(“%d,”, *px);
px = x;
printf(“%d,”, (*px)++); printf(“%d,”, *px);
px = x;
printf(“%d,”, *px++); printf(“%d,”, *px);
px = x;
printf(“%d,”, *++px); printf(“%dn”, *px);
return 0;
}
上面程序运行后的输出结果是
选项：
A:20,10,11,20,11,12,20,20
B:11,11,11,12,12,13,20,20
C:11,11,11,12,12,20,20,20
D:20,10,11,10,11,10,11,10
答案: 【11,11,11,12,12,20,20,20】

6、单选题：
#include
int main()
{
int arr[]= {6,7,8,9,10};
int *ptr;
ptr=arr;
*(ptr+2)+=2;
printf (“%d,%dn”,*ptr,*(ptr+2));
return 0;
}
上面程序的运行结果为
选项：
A:7,9
B:6,8
C:8,10
D:6,10
答案: 【6,10】

7、单选题：
#include
#include
int main()
{
char *s1=”AbDeG”;
char *s2=”AbdEg”;
s1+=2;
s2+=2;
printf(“%dn”,strcmp(s1,s2));
return 0;
}

上面程序的运行结果是
选项：
A:不确定的值
B:正数
C:负数
D:零
答案: 【负数】

8、单选题：
有以下定义
char a[10],*b=a;
不能给数组a输入字符串的语句是
选项：
A:gets(&a[0])
B:gets(a)
C:gets(b)
D:gets(a[0])
答案: 【gets(a[0])】

9、单选题：
char *s=”abcde”;
s+=2;printf(“%d”,s);
上面程序段的运行结果是
选项：
A:cde
B:无确定的输出结果
C:字符‘c’的地址
D:字符‘c’
答案: 【字符‘c’的地址 】

10、单选题：
#include
int main()
{
char a[]=”programming”,b[]=”language”;
char *p1,*p2;
int i;
p1=a;
p2=b;
for(i=0; i<7; i++)
if(*(p1+i)==*(p2+i))
printf(“%c”,*(p1+i));
return 0;
}

上面程序输出结果是
选项：
A:ga
B:or
C:gm
D:rg
答案: 【ga】

11、单选题：
若有说明语句
char a[]=”It is mine”;
char *p=”It is mine”;
则以下不正确的叙述是
选项：
A:p变量中存放的地址值可以改变
B:p指向另外的字符串时，字符串的长度不受限制
C:a中只能存放10个字符
D:a+1表示的是字符t的地址
答案: 【a中只能存放10个字符】

第十二章 单元测试

1、单选题：
int f(int b[][4])
{
int i,j,s=0;
for(j=0; j<4; j++)
{
i=j;
if(i>2) i=3-j;
s+=b[i][j];
}
return s;
}
int main( )
{
int a[4][4]= {{1,2,3,4},{0,2,4,5},{3,6,9,12},{3,2,1,0}};
printf(“%dn”,f(a) );
return 0;
}
执行后的输出结果是
选项：
A:11
B:16
C:12
D:18
答案: 【16】

2、单选题：
若有以下函数首部
int fun(double x[10], int *n)
则下面针对此函数的函数声明语句中正确的是
选项：
A:int fun(double *, int *);
B:int fun(double *x, int n);
C:int fun(double x, int *n);
D:int fun(double , int )
答案: 【int fun(double *, int *);】

3、单选题：
void sum(int *a)
{
a[0]=a[1];
}
int main( )
{
int aa[10]= {1,2,3,4,5,6,7,8,9,10},i;
for(i=2; i>=0; i–) sum(&aa[i]);
printf(“%dn”,aa[0]);
return 0;
}

上面程序的运行结果是
选项：
A:4
B:2
C:1
D:3
答案: 【4】

4、单选题：
int main()
{
char a;
char *str=&a;
strcpy(str,”hello”);
printf(str);
return 0;
}
上面程序的运行结果是
选项：
A:发生异常
B:h
C:Null
D:hell
答案: 【发生异常】

5、单选题：
void print(char *s)
{
printf(“%s”,s);
}
int main()
{
char *p,*q;
char str[]=”Hello,Worldn”;
q = p = str;
p++;
print(q);
print(p);
return 0;
}
上面程序的运行结果是
选项：
A:Hello，World Hello，World
B:Hello，World ello，World
C:ello，World ell，World
D:H
e
答案: 【Hello，World ello，World】

6、单选题：
下面选项属于函数指针的是：
选项：
A:两者都是
B:(int*)p(int,int) ;
C:int *p(int,int) ;
D:两者都不是
答案: 【两者都不是】

7、单选题：
若有函数max(a,b)，并且已使函数指针变量p指向函数max，当调用该函数时，正确的调用方法是
选项：
A:*p(a,b);
B:(*p)max(a,b);
C:*pmax(a,b);
D:(*p)(a,b);
答案: 【(*p)(a,b);】

8、单选题：
对于语句int *pa[5]；下列描述中正确的是
选项：
A: pa [5]表示某个元素的第5个元素的值
B:pa是一个指向数组的指针，所指向的数组是5个int型元素
C:pa是一个指向某数组中第5个元素的指针，该元素是int型变量
D:pa是一个具有5个元素的指针数组，每个元素是一个int型指针
答案: 【pa是一个具有5个元素的指针数组，每个元素是一个int型指针】

9、单选题：
若有以下说明和语句，int c[4][5],(*p)[5];p=c;能正确引用下标变量的是
选项：
A:*(p+1)+3
B:*(p+3)
C: p+1
D:*(p[0]+2))
答案: 【*(p[0]+2))】

10、单选题：
若有定义：int a[2][3]; 则对a数组的第i行j列元素地址的正确引用为
选项：
A:*(a[i]+j)
B:(a+i)
C:*(a+j)
D:a[i]+j
答案: 【a[i]+j】

11、单选题：
设已有定义: char *st=”how are you”; 下列程序段中正确的是
选项：
A:char a[11]; strcpy(a, st);
B:char a[11], *p; strcpy(p=a+1,&st[4]);
C:char a[], *p; strcpy(p=&a[1],st+2);
D:char a[11]; strcpy(++a, st)
答案: 【char a[11], *p; strcpy(p=a+1,&st[4]);】

12、单选题：
设变量p1和p2指向同一个字符串的首字母，c为字符变量，则以下不能正确执行的赋值语句是
选项：
A:c=*p1*(*p2);
B:p2=c;
C:p1=p2;
D:c=*p1+*p2;
答案: 【p2=c;】

13、单选题：
以下正确的程序段是
选项：
A:char str[20],*p=str; scanf(“%s”,p[2]);
B:char str[20]; scanf(“%s”,&str[2]);
C:char *p;scanf(“%s”,p);
D:char str[20],*p=str; scanf(“%s”,*p);
答案: 【char str[20]; scanf(“%s”,&str[2]);】

14、单选题：
int **pp;int *p,a=1;p=&a;能够将pp指向变量p的代码是
选项：
A:pp=p;
B:pp=&p;
C:*pp=p;
D:pp=*p;
答案: 【pp=&p;】

15、单选题：
已定义以下函数
int fun (int *p)
{
return *p;
}
该函数的返回值是
选项：
A:形参p中存放的值
B:形参p所指存储单元中的值
C:不确定的值
D:形参p的地址值
答案: 【形参p所指存储单元中的值  】

第十三章 单元测试

1、单选题：
下列对结构类型变量不正确的定义是
选项：
A:struct{
int num;
int age;
}teacher
B:struct teacher{
int num,age;
}a;
C:struct teacher{
int num;
int age;
}teacher1;
D:struct{
int num;
int age; }teacher1,teacher2;
答案: 【struct{
int num;
int age;
}teacher】

2、单选题：
设有以下定义语句：struct student{ int num; char name[10]; float score;}wang,zhang;，则变量wang所占的内存字节数是（ ）（注：在VC环境下要考虑内存对齐规则）
选项：
A:20
B:18
C:24
D:10
答案: 【20】

3、单选题：
假设有如下的定义：
struct{
int n;
char c;
float f;
}rec;
则以下各个输入语句中，正确的是
选项：
A:scanf(“%s”,&rec.c);
B:scanf(“%d”,rec);
C:scanf(“%c”,&rec.c);
D:scanf(“%f”,&rec);
答案: 【scanf(“%c”,&rec.c);】

4、单选题：
#include
struct abc{
int a,b,c;
};
int main()
{ struct abc s[2]={{1,2,3},{4,5,6}};
int t;
t=s[0].a+s[1].b;
printf(“%dn”,t);
return 0;
}
上面程序的输出结果是
选项：
A:8
B:6
C:7
D:5
答案: 【6】

5、单选题：
有以下说明和定义语句
struct student{
int age;
char num[8];
};
struct student stu[3]={{20,”200401″},{21,”200402″},{19,”200403″}};
struct student *p=stu;
以下选项中引用结构体变量成员错误的是
选项：
A:(p++)->num
B:stu[2]->age
C:(*p).num
D:p->num
答案: 【stu[2]->age】

6、单选题：
struct person {
char name[9];
int age;
};
struct person class[10]={“John”,17, “Paul”,19,”Mary”,18, “Adam”,16};
根据上面的定义，能打印出字母M的语句是
选项：
A:printf(“%cn”,class[3].name);
B:printf(“%cn”,class[3].name[1]);
C:printf(“%cn”,class[2].name[0]);
D:printf(“%cn”,class[2].name[1]);
答案: 【printf(“%cn”,class[2].name[0]);】

7、单选题：
若有以下程序段：
struct st{
int n;
int *m;
};
int a=2,b=3,c=5;
struct st s[3]=({101,&a},{102,&b},{103,&c});
int main(){
struct st *p;
p=s;
…
}
则以下表达式中值为5的是
选项：
A:*((p+2)->n)
B:*((p+2).m)
C:*((p+2)->m)
D:((p+2)->m)
答案: 【*((p+2)->m)】

8、单选题：
union{
short m;
char a[8];
}a,*p=&a;
a.m=100;
a.a[0]=’A’;
p->a[1]=1;
printf(“%d,%d”,sizeof(a),a.m);
上面程序的运行结果是
选项：
A:10, 100
B:8, 321
C:8, 100
D:8, 65
答案: 【8, 321】

9、单选题：
以下对共用体类型数据的描述中，错误的是
选项：
A:同一个共用体变量中，各成员的首地址是不相同的
B:在定义共用体变量的同时允许对它的第一个成员进行初始化
C:共用体类型的定义可以出现在结构类型定义中
D:共用体变量所占的内存大小，等于占用内存最多的成员所占的内存大小
答案: 【同一个共用体变量中，各成员的首地址是不相同的】

10、单选题：
int main()
{
struct cmplx { int x; int y; }
cnum[2]={1,3,2,7};
printf(“%dn”,cnum[0].y /cnum[0].x * cnum[1].x);
return 0;
}
上面程序的输出是
选项：
A:1
B:0
C:3
D:6
答案: 【6】

11、单选题：
#include
union utype{
int i;
float f;
}u[2];
int main(){
printf(“%dn”,sizeof(u)) ;
return 0;
}
在VC环境下上面程序的运行结果是
选项：
A:4
B:8
C:16
D:6
答案: 【8】

12、单选题：
union U{
short a;
char b[4];
}u;
u.b[0]=2;
u.b[1]=1;
u.b[2]=3;
printf(‘%hd’,u.a);
VC中，上面程序的执行结果是
选项：
A:130
B:513
C:其余三个答案都不对
D:258
答案: 【258】

13、单选题：
以下叙述中错误的是
选项：
A:用typedef可以给各种已有类型起别名，但不能给变量起别名
B:可以用typedef将已存在的类型名用一个新的名字来代表
C:可以通过typedef增加新的类型
D:用typedef定义新的类型名后，原有类型名仍有效
答案: 【可以通过typedef增加新的类型】

14、单选题：
设有以下语句
typedef struct S{
int g;
char h;
}T;
则下面叙述中正确的是
选项：
A:可用S定义结构体变量
B:T是struct S类型的变量
C:可以用T定义结构体变量
D:S是struct类型的变量
答案: 【可以用T定义结构体变量】

15、单选题：
设有以下定义语句
struct student{
int num;
char name[8];
float score;
}a[2];
则数组a所占内存的字节数是（注：在VC环境下）
选项：
A:16
B:40
C:20
D:32
答案: 【32】

第十四章 单元测试

1、单选题：
表达式7&&8和7&8的值分别是
选项：
A:0 1
B:1 1
C:0 0
D:1 0
答案: 【1 0】

2、单选题：
表达式7||8和7|8的值分别是
选项：
A:1 15
B:1 1
C:0 15
D:0 1
答案: 【1 15】

3、单选题：
表达式7^16的值是
选项：
A:21
B:1
C:23
D:0
答案: 【23】

4、单选题：
int main()
{
char x=040;
printf(“%dn”,x=(x<<1));
return 0;
}
以上程序的输出结果是
选项：
A:120
B:64
C:160
D:100
答案: 【64】

5、单选题：
若有定义：
int a=20,b=28,C;
则执行语句C=(a&b)>>2;后C的值为
选项：
A:80
B:112
C:7
D:5
答案: 【5】

6、单选题：
char a=3,b=6,c;
c=a^b<<2;
以上程序执行后c的二进制值是
选项：
A:00010100
B:00011000
C:00011100
D:00011011
答案: 【00011011】

7、单选题：
若有代码：
int a=11,b=2,c;
c=(a>>2)|(b<<1);
则代码执行后c的值为
选项：
A:

11

B:

10

C:

其余答案都不对

D:

6

答案: 【

6

】

8、单选题：
若有定义：
int x=3, y=4;
则表达式x^~y的值为
选项：
A:-7
B:4
C:-4
D:-8
答案: 【-8】

9、单选题：
若有定义：
int x=3, y=4;
则表达式!x|y的值为
选项：
A:1
B:0
C:3
D:4
答案: 【4】

第十五章 单元测试

1、单选题：
下列四种打开文件的方式中，能删除原文件（已有文件）内容的是
选项：
A:a
B:w
C:r+
D:a+
答案: 【w】

2、单选题：
缓冲文件系统中，使用下面哪类文件或设备不需要程序员打开和关闭？
选项：
A:键盘和显示器
B:U盘上的文件
C:C盘根目录中的文件
D:光盘上的文件
答案: 【键盘和显示器】

3、单选题：
下面说法正确的是
选项：
A:

fclose()函数不需要参数

B:

fclose()与fopen()的不同点是：fclose()函数的执行不会失败

C:

其他几种说法都不对

D:

当只打开一个文件时，fclose()不需要参数

答案: 【

其他几种说法都不对

】

4、单选题：
标准函数fgets(s, n, f )的功能是
选项：
A:从文件中读取长度为n的字符串存入指针s所指的内存
B:从文件中读取长度不超过n-1个字符组成字符串存入指针s所指的内存
C:从文件中读取几个字符存入指针s所指的内在
D:从文件中读取长度为n-1的字符串存入指针s所指的内存
答案: 【从文件中读取长度不超过n-1个字符组成字符串存入指针s所指的内存】

5、单选题：
假设所有用到的函数都能正确执行，则下面说法正确的是
选项：
A:

其他几种说法都不对

B:

fread(&n,4,1,fp)和fread(&n,1,4,fp)完全等价

C:

使用fread(&n,4,1,fp)读一个整数或使用fread(&n,1,4,fp)读一个整数，读取后n中的值相同

D:

fread(&n,4,1,fp)和fread(&n,1,4,fp)两种用法的返回值相同

答案: 【

使用fread(&n,4,1,fp)读一个整数或使用fread(&n,1,4,fp)读一个整数，读取后n中的值相同

】

6、单选题：
windows中，用”w”方式打开文件，把短整型变量n=10的值以及字符变量c=’n’的值用fwrite（）分两次写入文件，则文件的内容（二进制数）是
选项：
A:00001101 00001010 00000000 00001101 00001010
B:00001010 00000000 00001101 00001010
C:00000000 00001010 00001101 00001010
D:00110001 00110000 00001101 00001010
答案: 【00001101 00001010 00000000 00001101 00001010】

7、单选题：
文件的二进制内容是：00001101 00001010 00110010 00100000，windows中，用”r”方式打开文件，用fscanf(fp,”%c%hd”,&c,&n)函数读取一个字符和一个短整数，则字符和短整数分别是
选项：
A:‘r’和10
B:‘n’和2
C:‘n’和50
D:‘r’和2
答案: 【‘n’和2】

8、单选题：
曾经，用fwrite函数（该函数用二进制方式写数据）向文件中写了一个整数，今欲将其读取出来，关于用什么方式打开文件，下面说法正确的是
选项：
A:不知道当初写数据时是用什么方式打开的文件，所以不能确定
B:必须用二进制方式打开
C:必须用文本方式打开
D:用文本方式或二进制方式均可
答案: 【不知道当初写数据时是用什么方式打开的文件，所以不能确定】

9、单选题：
文本文件中只存有一个字符‘A’，要将它读出来，下面说法正确的是
选项：
A:必须用二进制方式打开并用fread读取
B:必须用文本方式打开并用fgetc读取
C:可以用二进制方式打开然后用fread读取
D:必须用文本方式打开并用fread读取
答案: 【可以用二进制方式打开然后用fread读取】

10、单选题：
文件的二进制内容是：00110001 00100000，用fscanf(fp,”%d”,&x)或fread(&x,2,1,fp)读取一个短整数，则用此两种函数读出来的结果分别是
选项：
A:1 8241
B:10 8241
C:1 12576
D:10 12576
答案: 【1 8241】