绪论 单元测试
1、单选题：
十进制的10对应的二进制表示是以下哪个选项？
选项：
A: 1000
B: 1010
C: 0010
D: 10
答案: 【 1010】
2、单选题：
二进制数1000对应的十进制数是多少？
选项：
A: 1
B: 10
C: 1000
D: 8
答案: 【 8】
3、单选题：
计算机中数据存储的最小单位是什么？
选项：
A: 字节
B: 位
C: 地址
答案: 【 位】
4、单选题：
计算机中数据存储的基本单位是什么？
选项：
A: 位
B: 字节
C: 地址
答案: 【 字节】
5、单选题：
计算机的存储空间中一个字节是由多少个连续的位组成？
选项：
A: 4
B: 8
C: 10
D: 1
答案: 【 8】
第一章 单元测试
1、单选题：
C语言主要是借助以下哪种手段来实现程序模块化（ ）
选项：
A:使用三种基本结构语句
B:定义函数
C:使用丰富的数据类型
D:定义常量和外部变量
答案: 【定义函数】
2、单选题：
以下叙述错误的是（ ）
选项：
A:在一个任务中，单独编写的每个模块均可以独立运行
B:采用模块化结构，可以提高程序编制的效率
C:程序“模块化“有利于任务的分解
D:允许对函数单独进行编译，是C语言实现“模块化“的基础
答案: 【在一个任务中，单独编写的每个模块均可以独立运行】
3、单选题：
以下叙述中错误的是( )
选项：
A:C程序在运行过程中所有计算都以二进制方式进行
B:计算机不能直接执行C语言程序
C:C程序在运行过程中所有计算都以十进制方式进行
D:所有C程序都需要编译链接无误后才能运行
答案: 【C程序在运行过程中所有计算都以十进制方式进行】
4、单选题：
流程图是描述算法的很好的工具，一般的流程图中由几种基本图形组成，其中条件判断的图形是（ ）
选项：
A:菱形
B:椭圆型
C:平行四边形
D:长方形
答案: 【菱形】
5、单选题：
以下叙述中正确的是（）。
选项：
A:计算机能直接运行未经编译的C语言程序
B:计算机能够直接处理不超过20行源码的简单C语言程序
C:复杂算法不能使用N－S流程图来描述
D:循环结构、选择结构、顺序结构是结构化程序的三种基本结构
答案: 【循环结构、选择结构、顺序结构是结构化程序的三种基本结构】
第二章 单元测试
1、单选题：
对于一个正常运行的C程序，以下叙述中正确的是（ ）
选项：
A:程序的执行总是从程序的第一个函数开始, 在main函数结束
B:程序的执行总是从main函数开始
C:程序的执行总是从main函数开始，在程序的最后一个函数中结束
D:程序的执行总是从程序的第一个函数开始，在程序的最后一个函数中结束
答案: 【程序的执行总是从main函数开始】
2、单选题：
以下叙述中正确的是（ ）
选项：
A:C语言程序将从源程序中第一个函数开始执行
B:C语言规定必须用main作为主函数名，程序将从此开始执行
C:可以在程序中由用户指定任意一个函数作为主函数，程序将从此开始执行
D:main的各种大小写拼写形式都可以作为主函数名，如：MAIN，Main等
答案: 【C语言规定必须用main作为主函数名，程序将从此开始执行】
3、单选题：
C语言源程序名的后缀是( )
选项：
A:obj
B:.cp
C:exe
D:.C
答案: 【.C】
4、单选题：
以下关于注释的叙述中错误的是（）。
选项：
A:注释的边界符号“/*”和“*/”必须成对出现且可以嵌套
B:C语言允许注释出现在程序中任意合适的地方
C:注释的边界符号“/”和“*”之间不允许加入空格
D:注释的内容仅用于阅读，对程序的运行不起作用
答案: 【注释的边界符号“/*”和“*/”必须成对出现且可以嵌套 】
5、单选题：
关于程序中的注释，以下叙述正确的是（）。
选项：
A:/* 和 */多行注释中间不可以嵌套另一个注释
B: 注释的内容必须放在一对/* 和 */之间
C:注释内容错误会导致编译出错
D:注释必须置于所说明的语句前或语句后
答案: 【/* 和 */多行注释中间不可以嵌套另一个注释
】
第三章 单元测试
1、单选题：
若有定义语句：char c=’A’; 则变量c在内存中占( )
选项：
A:4个字节
B:3个字节
C:1个字节
D:2个字节
答案: 【】
2、单选题：
以下选项中，合法的C语言实数是（ ）
选项：
A:E13
B:3.1e0.4
C: .2e0
D:7.12E
答案: 【
】
3、单选题：
以下选项中合法的标识符是（ ）
选项：
A:1_ _
B:_11
C:1_1
D:1－1
答案: 【】
4、单选题：
以下选项中叙述正确的是（ ）
选项：
A:C语言的标识符可分为关键字、预定义标识符和用户标识符三类
B:C语言的标识符可分为语句、变量和关键字三类
C:C语言的标识符可分为运算符、用户标识符和关键字三类
D:C语言的标识符可分为函数名、变量和预定义标识符三类
答案: 【】
5、单选题：
C语言程序中，运算对象必须是整型数的运算符是（ ）
选项：
A:*
B:&&
C:%
D: /
答案: 【】
6、单选题：
若有定义语句：int a=12;，则执行语句：a+= a-= a*a;后，a的值是（ ）
选项：
A:264
B:-264
C:144
D:552
答案: 【】
7、单选题：
有以下程序
#include <stdio.h>
int main()
{
int x=010, y=10;
printf(“%d,%d”, ++x, y–);
return0;}程序运行后的输出结果是（ ）
选项：
A:010,9
B:9,10
C:10,9
D:11,10
答案: 【
8、单选题：
有以下程序
#include <stdio.h>
main()
{
int a;
a = (int)(-1.53*3);
printf(“%d”, a);
}
程序的运行结果是( )
选项：
A:-3
B:结果不确定
C:-4
D:-5
答案: 【】
9、单选题：
若有定义：int a=3;double b=0.1263; char ch=’a’;，则以下选项中,叙述有错的是（ ）。
选项：
A:复合运算：a*=b+ch是将变量b、ch之和与a相乘，结果再给a赋值
B:逗号表达式的计算结果是最后一个逗号之后的表达式的运算结果
C:语句ch=(unsigned int) a+b;是对a与b之和进行强制类型转换，结果赋值给变量ch
D:运算符%只能对整数类型的变量进行运算
答案:】
10、单选题：
以下选项中，合法的数值型常量是（ ）
选项：
A:0xDH
B:“A”
C:092
D:3.1415
答案: 【】
第四章 单元测试
1、单选题：
若变量已正确定义并赋值，以下不能构成C语句的选项是( )
选项：
A:A?a:b;
B:B++;
C:a=a+b
D:A=a+b;
答案: 【】
2、单选题：
若想给已定义为int型的变量a,b,c,d赋值为1，以下选项中错误的语句是（ ）。
选项：
A:a=1, b=a, c=b, d=c;
B:d=1, c=d, b=c, a=b;
C:a=b, b=c, c=d, d=1;
D:a=b=c=d=1;
答案: 【】
3、单选题：
有以下程序
#include <stdio.h>
main()
{ int a=0,b=0;
/* 给a赋值 a=10;
b=20; 给b赋值 */
printf(“a+b=%d”,a+b); /* 输出计算结果 */
}
程序运行后的输出结果是( )
选项：
A:a+b=10
B:出错
C:a+b=0
D:a+b=30
答案: 【】
4、单选题：
有以下程序
#include <stdio.h>
main()
{
char c1=’A’, c2=’Y’;
printf( “%d, %d”, c1,c2 );
}
程序的输出结果是( )
选项：
A:输出格式不合法，输出出错信息
B:65,89
C:A,Y
D:65,90
答案: 【】
5、单选题：
设有定义：
int n = 1234;
double x = 3.1411;
则语句
printf(“%3d,%1.3f”, n, x);
的输出结果是( )
选项：
A:1234,3.142
B:1234,3.141
C:123,3.142
D:123,3.141
答案: 【】
6、单选题：
有如下程序
#include <stdio.h>
main()
{
int x = 0x13;
printf(“%d”, x+1);
}
程序运行后的输出结果是( )
选项：
A:12
B:14
C:20
D:13
答案: 【】
7、单选题：
若有定义
int a;
float b;
double c;
程序运行时输入：
3 4 5<回车>
能把值3输入给变量a、4输入给变量b、5输入给变量c的语句是( )
选项：
A:scanf(“%lf%lf%lf”, &a,&b,&c);
B:scanf(“%d%f%lf”, &a,&b,&c);
C:scanf(“%d%f%f”, &a,&b,&c);
D:scanf(“%d%lf%lf”, &a,&b,&c);
答案: 【
8、单选题：
以下叙述中正确的是( )
选项：
A:在printf函数中，各个输出项只能是变量
B:在使用scanf函数输入整数或实数时，输入数据之间只能用空格来分隔
C:使用printf函数无法输出百分号%
D:在scanf函数中的格式控制字符串是为了输入数据用的，不会输出到屏幕上
答案: 【】
9、单选题：
若有定义：char c;int d; ，程序运行时输入： 1,2 <回车>，能把值1输入给变量c、值2输入给变量d的输入语句是( )
选项：
A:scanf(“%d,%f”, &c,&d);
B:scanf(“%c,%d”, &c,&d);
C:scanf(“%d%d”, &c,&d);
D:scanf(“%c%d”, &c,&d);
答案: 【】
10、单选题：
以下能正确输出字符a 的语句是（ ）
选项：
A:printf(“%d”, ‘a’);
B:printf(“%c”, “a”);
C:printf(“%s”, “a”);
D:printf(“%s”, ‘a’);
答案: 【】
第五章 单元测试
1、单选题：
表示关系式x≤y≤z的C语言表达式的是（ ）
选项：
A:(x<=y)||(y<=z)
B:(x<=y<=z)
C:(x<=y)&&(y<=z)
D:(x<=y)!(y<=z)
答案: 【】
2、单选题：
已知a=5,b=6,c=7,d=8,m=2,n=2，执行(m=a>b)&&(n=c<d)后n的值为（ ）
选项：
A:-1
B:0
C:1
D:2
答案: 【】
3、单选题：
以下叙述中正确的是（ ）
选项：
A:逻辑“非“（即运算符!）的运算级别是最低的
B:由&&构成的逻辑表达式与由||构成的逻辑表达式都有“短路“现象
C:C语言的关系表达式：0<x<10完全等价于: (0<x) && (x<10)
D:逻辑“或“（即运算符||）的运算级别比算术运算要高
答案: 【】
4、单选题：
有以下程序
#include <stdio.h>
main()
{
int a=0,b=0,c=0,d=0;
(++a || ++b) ? ++c : ++d;
printf(“%d,%d,%d,%d”, a,b,c,d);
}
程序的运行结果是（ ）
选项：
A:1,0,1,0
B:1,1,1,0
C:1,0,0,1
D:1,1,0,1
答案: 【】
5、单选题：
以下程序段中，不能实现条件“如果a<b则x=10，否则x=-10″的是（ ）
选项：
A:if(a<b) x=10;
if(b<a) x=-10;
B:x=(a>=b)? -10:10;
C:x=-10;
if(a<b) x=10;
D:if(a<b) x=10;
else x=-10;
答案: 【】
6、单选题：
有以下程序段
scanf(“%d%d%d”,&a,&b,&c);
if(a>b) a=b;
if(a>c) a=c;
printf(“%d”,a);
该程序段的功能是（ ）
选项：
A:输出a、b、c中值相等的数值
B:输出a、b、c中的最大值
C:输出a、b、c中的最小值
D:输出a的原始值
答案: 【】
7、单选题：
有如下程序
#include <stdio.h>
main()
{
int a = 0, b = 1;
if (++a == b++)
printf(“T”);
else
printf(“F”);
printf(“a=%d,b=%d”, a, b);
printf(“”);
}
程序运行后的输出结果是（ ）
选项：
A:Fa=0,b=2
B:Ta=1,b=2
C:Ta=0,b=1
D:Fa=1,b=2
答案: 【】
8、单选题：
下列条件语句中，输出结果与其他语句不同的是( )
选项：
A: if ( a ) printf(“%d”, x); else printf(“%d”, y);
B:if ( a==0 ) printf(“%d”, y); else printf(“%d”, x);
C: if ( a!=0 ) printf(“%d”, x); else printf(“%d”, y);
D:if ( a==0 ) printf(“%d”, x); else printf(“%d”, y);
答案: 【】
9、单选题：
有以下程序
#include <stdio.h>
main()
{ int x=1, y=0,a=0,b=0;
switch( x )
{ case 1: switch ( y )
{ case 0: a++; break;
case 1: b++; break;
}
case 2: a++; b++; break;
}
printf(“a=%d,b=%d”,a,b );
}
程序运行后的输出结果是（ ）
选项：
A:a=2,b=2
B:a=2,b=1
C:a=1,b=1
D:a=1,b=0
答案: 【】
10、单选题：
若以下选项中的变量a, b, y均已正确定义并赋值，则语法正确的switch语句是（）
选项：
A:switch (a+9)
{ case a : y=a-b;
case b : y=a+b;}
B:switch( a+b )
{ case1 :
case3 : y=a+b; break;
case0 :
case4 : y=a-b;}
C:switch( a*a+b*b )
{ default : break;
case 3 : y=a+b; break;
case 2 : y=a-b; break;
}
D:switch a*b
{ case 10 : y=a+b;
default : y=a-b;
}
答案: 【
】
第六章 单元测试
1、单选题：
有以下程序
#include <stdio.h>
main()
{ int i, sum;
for( i=1; i<6; i++ )
sum+=i;
printf(“%d”, sum);
}
程序运行后的输出结果是（ ）
选项：
A:随机值
B:15
C:16
D:0
答案: 【】
2、单选题：
有以下程序
#include <stdio.h>
main( )
{ int a=-2, b=2;
for(; ++a && –b;)
printf(“%d,%d,”, a,b);
}
程序执行后的输出结果是（）。
选项：
A:-1,1,
B:0,1,
C:-1,1,0,0,
D:-1,1,0,1,
答案: 【】
3、单选题：
要求通过while循环不断读入字符，当读入字母N时结束循环。若变量已正确定义，以下正确的程序段是( )
选项：
A:while(ch=getchar() =’N’) printf(“%c “,ch);
B:while(ch=getchar()==’N’) printf(“%c “,ch);
C:while((ch=getchar())!=’N’) printf(“%c “,ch);
D:while((ch=getchar())==’N’) printf(“%c “,ch);
答案: 【】
4、单选题：
有以下程序
#include <stdio.h>
main()
{
int a = -2, b = 0;
while (a++ && ++b) ;
printf(“%d,%d”, a, b );
}
程序运行后输出结果是（ ）
选项：
A:0,2
B:1,2
C:0,3
D:1,3
答案: 【】
5、单选题：
以下叙述正确的是（ ）
选项：
A:while-do语句构成的循环，当while语句中的表达式值为非0时结束循环
B:do-while语句和while-do构成的循环功能相同
C:do-while语句构成的循环，当while语句中的表达式值为0时结束循环
D:do-while语句构成的循环，必须用break语句退出循环
答案: 【】
6、单选题：
有以下程序
#include <stdio.h>
main()
{ char c;
do {
c=getchar();
putchar(c);
}while(c != ‘#’);
printf(“”);
}
执行时如输入：abcdefg##<回车> , 则输出结果是（ ）
选项：
A:abcdefg#
B:abcdefg
C:abcdefg##
D:##
答案: 【】
7、单选题：
以下叙述中正确的是( )
选项：
A:continue语句的作用是：使程序的执行流程跳出包含它的所有循环
B:break语句只能用在循环体内和switch语句体内
C:break语句只能用于switch语句体中
D:在循环体内使用break语句和continue语句的作用相同
答案: 【】
8、单选题：
有以下程序
#include <stdio.h>
main()
{
int a=1, b=0;
for(;a<5; a++)
{ if (a%2==0) break;
b += a;
}
printf(“%d “, b);
}
程序的运行结果是（ ）
选项：
A:1
B:0
C:4
D:10
答案: 【】
9、单选题：
有如下程序
#include <stdio.h>
main( )
{
int i, data;
scanf(“%d”, &data);
for (i=0; i<5; i++)
{
if (i < data) continue;
printf(“%d-“, i);
}
}
程序运行时，从键盘输入：3<回车>后，程序输出结果为（ ）
选项：
A:1-2-3-
B:3-4-
C:0-1-2-3-
D:0-1-2-
答案: 【】
10、单选题：
若有以下程序
#include <stdio.h>
main()
{ int s=0, n;
for (n=0; n<4; n++)
{ switch(n)
{ default: s+=4;
case 1: s+=1; break;
case 2: s+=2; break;
case 3: s+=3;
}
}
printf(“%d”, s);
}
则程序的输出结果是（ ）
选项：
A:10
B:11
C:13
D:15
答案: 【】
第七章 单元测试
1、单选题：
有以下程序
#include <stdio.h>
main()
{ int i, t[][3]={9,8,7,6,5,4,3,2,1};
for(i=0;i<3;i++)
printf(“%d “,t[2-i][i]);
}
程序执行后的输出结果是（ ）。
选项：
A:7 5 3
B:7 5 1
C:3 6 9
D:3 5 7
答案: 【】
2、单选题：
以下错误的定义语句是（ ）。
选项：
A:int x[][3]={1,2,3,4};
B:int x[4][]= {{1,2,3},{1,2,3},{1,2,3},{1,2,3}};
C:int x[4][3]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};
D:int x[][3]={{0},{1},{1,2,3}};
答案: 【】
3、单选题：
以下叙述中正确的是（ ）。
选项：
A:函数调用strlen(s);会返回字符串s实际占用内存的大小（以字节为单位)
B:C语言本身没有提供对字符串进行整体操作的运算符
C:当拼接两个字符串时，结果字符串占用的内存空间是两个原串占用空间的和
D:两个字符串可以用关系运算符进行大小比较
答案: 【】
4、单选题：
以下叙述中正确的是（ ）。
选项：
A:字符串常量”str1″的类型是:字符串数据类型
B:字符数组的每个元素可存放一个字符，并且最后一个元素必须是字符
C:下面的语句用赋初值方式来定义字符串，其中’ ‘是必须的char str1[] = {‘s’, ‘t’, ‘r’, ‘1’, };
D:有定义语句： char str1[] = “str1”; ，数组str1将包含4个元素
答案: 【】
5、单选题：
以下叙述中正确的是（ ）。
选项：
A:语句 char a[2] = {“A”, “B”}; 是合法的，定义了一个包含两个字符的数组
B:语句int a[8] = {0}; 是合法的
C:语句 char a[3]; a = “AB”; 是合法的，因为数组有三个字符空间的容量，可以保存两个字符
D:语句 int a[] = {0};是不合法的，遗漏了数组的大小
答案: 【】
6、单选题：
以下叙述中正确的是（ ）。
选项：
A:对于一维字符数组，不能使用字符串常量来赋初值
B:对于字符串常量 “string!”，系统已自动在最后加入了’�’字符，表示串结尾
C:在语句char str[] = “string!”;中，数组str的大小等于字符串的长度
D:语句 char str[10] = “string!”; 和 char str[10] = {“string!”}; 并不等价
答案: 【】
7、单选题：
以下选项中，没有编译错误的是（ ）。
选项：
A:char str1[5] = “pass”, str2[6]; str2 = str1;
B:char str3[] = {‘d’, ‘e’, ‘b’, ‘u’, ‘g’, ”};
C:char name[10]; name = “china”;
D:char str4[]; str4 = “hello world”;
答案: 【】
8、单选题：
有以下程序
#include <stdio.h>
#include <string.h>
main()
{
char s[]=”Beijing”;
printf(“%d”, strlen(strcpy( s,”China”) ));
}
程序运行后的输出结果是（ ）。
选项：
A:12
B:7
C:5
D:14
答案: 【】
9、单选题：
有以下程序
#include <stdio.h>
main()
{
char b[4][10]; int i;
for (i=0; i<4; i++)
scanf(“%s”, b[i]);
printf(“%s%s%s%s”, b[0],b[1],b[2],b[3]);
}
执行时若输入: Fig flower is red. <回车>
则输出结果是（ ）。
选项：
A:Figfloweris red.
B:Figflower is red.
C:Fig flower is red.
D:Figflowerisred.
答案: 【】
10、单选题：
以下叙述中正确的是（ ）。
选项：
A:在逻辑上，可以把二维数组看成是一个具有行和列的表格或矩阵
B:语句 int a[4][3] = {1,2,4,5}; 是错误的初始化形式
C:语句 int a[4][3] = {{1,2}, {4,5}}; 是错误的初始化形式
D:语句 int a[][3] = {1,2,4,5}; 是错误的初始化形式
答案: 【】
第八章 单元测试
1、单选题：
以下关于函数的叙述中正确的是（ ）。
选项：
A:函数形参的类型与返回值的类型无关
B:函数必须要有返回值
C:函数调用必须传递实参
D:函数必须要有形参
答案: 【】
2、单选题：
关于C语言函数声明的位置，以下叙述正确的是（ ）。
选项：
A:函数声明可以出现在源程序的任意位置，在程序的所有位置对该函数的调用，编译时都不会出现错误信息
B:函数声明只是为了美观和编译时检查参数类型是否一致，可以写也可以不写
C:在函数声明之后对该函数进行调用，编译时不会出现错误信息
D:函数声明只能出现在源程序的开头位置，否则编译时会出现错误信息
答案: 【】
3、单选题：
有以下程序
#include <stdio.h>
int fun( int a, intB)
{ return a+b; }
main()
{ int x=6, y=7, z=8, r ;
r = fun ( fun(x,y), z– );
printf (” %d” , r );
}
程序运行后的输出结果是（ ）。
选项：
A:21
B:20
C:15
D:31
答案: 【】
4、单选题：
有以下程序
#include <stdio.h>
int a=1, b=2;
void fun1( int a, int b )
{
printf( “%d %d ” ,a, b ); }
void fun2()
{ a=3; b=4; }
main()
{
fun1(5,6); fun2( );
printf( “%d %d”,a, b );
}
程序运行后的输出结果是（ ）。
选项：
A:5 6 3 4
B:3 4 5 6
C:5 6 1 2
D:1 2 5 6
答案:
】
5、单选题：
以下叙述中错误的是（ ）。
选项：
A:在不同的函数中可以使用相同名字的变量
B:函数中的形参属于局部变量
C:在函数内部定义的变量只能在本函数范围内使用
D:在函数外部定义的变量在所有函数中都有效
答案: 【在函数外部定义的变量在所有函数中都有效】
6、单选题：
有以下程序
#include <stdio.h>
void fun( int a, int b, int c )
{ a=b; b=c; c=a; }
main()
{ int a=10 , b=20, c=30;
fun( a, b, c );
printf(“%d,%d,%d”,c,b,a); }
程序运行后的输出结果是（ ）。
选项：
A:20,30,10
B:10,20,30
C:30,20,10
D:0,0,0
答案: 【
】
7、单选题：
有如下程序
#include <stdio.h>
int sum(int data)
{
static int init = 0;
return init += data;
}
main()
{
int i;
for (i=1; i<=5; i++)
printf(“%d,”, sum(i));
printf(“”);
}
程序运行后的输出结果是（ ）。
选项：
A:1,2,3,4,5,
B:1,1,1,1,1,
C:1,3,6,10,15,
D:0,0,0,0,0,
答案: 【】
8、单选题：
若有以下程序
#include <stdio.h>
void f(int x)
{ if (x >= 10)
{ printf(“%d-“, x%10); f(x/10); }
else
printf(“%d”, x);
}
main()
{ int z = 123456;
f(z);
}
则程序的输出结果是（ ）。
选项：
A:1-2-3-4-5-6
B:1-2-3-4-5-6-
C:6-5-4-3-2-1
D:6-5-4-3-2-1-
答案: 【
】
9、单选题：
有如下程序
#include <stdio.h>
int sub(double a, double b)
{
return (int)(a – b);
}
main()
{
printf(“%d”, sub(3.8, 2.1));
}
程序运行后的输出结果是（ ）。
选项：
A:1.7
B:1
C:2
D:2.0
答案: 【
】
10、单选题：
有以下程序
#include <stdio.h>
#define N 4
void fun(int a[][N])
{ int b[N][N],i,j;
for(i=0; i<N; i++)
for(j=0; j<N; j++)
b[i][j] = a[N-1-j][i];
for(i=0; i<N; i++)
for(j=0; j<N; j++)
a[i][j] = b[i][j];
}
main()
{
int x[N][N]={ {1, 2, 3, 4},{5, 6, 7, 8},
{9,10,11,12},{13,14,15,16}
},i;
fun(x); fun(x);
for (i=0;i<N; i++)
printf(“%d,”, x[i][i]);
printf(“”);
}
程序的运行结果是（ ）。
选项：
A:4,7,10,13,
B: 13,10,7,4,
C:1,6,11,16,
D:16,11,6,1,
答案: 【
】
第九章 单元测试
1、单选题：
以下叙述中正确的是（ ）
选项：
A:#include命令行不能出现在程序文件的中间
B:虽然包含文件被修改了，包含该文件的源程序也可以不重新进行编译和连接
C:在包含文件中，不得再包含其他文件
D:在一个程序中，允许使用任意数量的#include命令行
答案: 【】
2、单选题：
以下叙述正确的是（ ）。
选项：
A:一个源文件中可以包含多个文件，每个文件的包含单独写一个#include行
B:一个#include行可以包含多个文件，且最后一个文件起作用
C:一个#include行可以包含多个文件，文件名用逗号分开
D:#include <stdio.h > 是C程序的一条语句
答案: 【】
3、单选题：
有以下程序
#include <stdio.h>
#define S(x) x*x
main()
{
int k=5, j=2;
printf(“%d,%d”, S(k+j+2),S(j+k+2));
}
程序的运行结果是（ ）
选项：
A:81,81
B:18,18
C:21,18
D:21,21
答案: 【 】
4、单选题：
有如下程序
#include <stdio.h>
#define D(x) 4*x+1
main()
{
int i = 2, j = 4;
printf(“%d”, D(i+j));
}
程序运行后的输出结果是（ ）
选项：
A:25
B:12
C:9
D:13
答案: 【】
5、单选题：
有以下宏定义及调用
#define HA 2
#define HB(a) (HA+1)*a
…
x=HA*(HA+HB(2));
则以下判断正确的是（ ）。
选项：
A:x的值是16
B:宏定义不允许嵌套
C:宏调用不允许嵌套
D:x的值是 6
答案: 【】
第十章 单元测试
1、单选题：
有如下程序段
int *p, a=1;
p=&a;
*p=10;
则变量a的值为________。
选项：
A:10
B:不能确定
C:1
D:11
答案: 【】
2、单选题：
变量的指针，其含义是指该变量的_________
选项：
A:名
B:一个标志
C:值
D:地址
答案: 【
】
3、单选题：
关于数组和指针，以下说法错误的是_______.
选项：
A:指针可以指向同类型的数组中的任意一个元素
B:可以让一个指针指向一个同类型的数组
C:数组名本身就是一个指针，指向数组内存的起始位置
D:既可以读入数据到数组中，也可以读入数据到未赋初值的指针中
答案: 【
】
4、单选题：
若有以下定义，则对a数组元素的正确引用是_________.
int a[5],*p=a;
选项：
A:*&a[5]
B:*(a+2)
C: a+2
D:*(p+5)
答案: 【
5、单选题：
有如下程序
#include <stdio.h>
int main()
{
int i, *ptr;
int array[3] = {8,2,4};
for (ptr=array, i=0; i<2; i++)
printf(“%d,”, *ptr++);
printf(“”);
return 0;
}
程序运行后的输出结果是_______.
选项：
A:8,2,
B:2,4,
C:8,8,
D:4,8,
答案: 【
】
6、单选题：
指向一个包含４个整型元素的一维数组的行指针变量的定义形式为_______.
选项：
A: int (*p)[]
B: int (*p)[4]
C:int *(p[])
D:int *p[4]
答案: 【
7、单选题：
若有定义：int a[2][3]; 则对a数组的第i行第j列元素值的正确引用是______.
选项：
A:*(a+i+j)
B:*(a+i)+j
C:*(*(a+i)+j)
D:(a+i)[j]
答案: 【】
8、单选题：
下面程序段的运行结果是_______.
char a[ ]= “language”, *p ;
p=a ;
while (*p!= ‘u’) { printf(“%c”,*p-32); p++ ; }
选项：
A:LANGUAGE
B:langUAGE
C:language
D:LANG
答案: 【
】
9、单选题：
设有定义：char *cc[2]={“1234“,“5678“};则正确的叙述是_______.
选项：
A:cc 元素的值分别为”1234″和”5678“
B:cc 数组的两个元素中各自存放了字符串”1234″和”5678″的首地址
C:cc数组的两个元素分别存放的是含有 4 个字符的一维字符数组的首地址
D:cc是指针变量，它指向含有两个数组元素的字符型一维数组
答案: 【
】
10、单选题：
已有函数 max(a,b)，为了让函数指针变量 p 指向函数 max，正确的赋值方法是_______.
选项：
A:p=max;
B:*p=max(a,b);
C:p=max(a,b);
D:*p=max;
答案: 【
】
第十一章 单元测试
1、单选题：
有以下程序
#include <stdio.h>
#include <string.h>
struct A
{ int a; char b[10]; double c;};
void f(struct A t);
main()
{ struct A a={1001,”ZhangDa”,1098.0};
f(a);
printf(“%d,%s,%6.1f”, a.a,a.b,a.c);
}
void f(struct A t)
{ t.a=1002; strcpy(t.b,”ChangRong”); t.c=1202.0;}
程序运行后的输出结果是（）
选项：
A:1002,ChangRong,1202.0
B:1001,ChangRong,1098.0
C:1002,ZhangDa,1202.0
D:1001,ZhangDa,1098.0
答案: 【】
2、单选题：
设有定义：
struct {char mark[12]; int num1; double num2;} t1,t2;
若变量均已正确赋初值，则以下语句中错误的是（）
选项：
A:t2.num1=t1.num1;
B:t1=t2;
C:t2.mark=t1.mark;
D:t2.num2=t1.num2;
答案: 【】
3、单选题：
以下叙述中正确的是（）
选项：
A:即使是同类型的结构体变量，也不能进行整体赋值
B:结构体中可以含有指向本结构体的指针成员
C:结构体变量的地址不能作为实参传给函数
D:结构体数组名不能作为实参传给函数
答案: 【】
4、单选题：
设有以下程序段
struct person
{
float weight;
char sex;
char name[10];
} rec, *ptr;
ptr = &rec;
从键盘读入字符串给结构体变量rec的name成员，错误的输入语句是（）
选项：
A:scanf(“%s”, rec.name);
B:scanf(“%s”, ptr->name);
C:scanf(“%s”, rec->name);
D:scanf(“%s”, (*ptr).name);
答案: 【】
5、单选题：
以下叙述中错误的是（）
选项：
A:可以用typedef说明的新类型名来定义变量
B:typedef的作用是用一个新的标识符来代表已存在的类型名
C:typedef说明的新类型名必须使用大写字母，否则会出编译错误
D:用typedef可以说明一种新的类型名
答案: 【】
6、单选题：
有如下程序
#include <stdio.h>
struct person
{
char name[10];
int age;
}
main()
{
struct person room[4] = {{“Zhang”, 19}, {“Li”, 20}, {“Wang”, 17}, {“Zhao”, 18}};
printf(“%s:%d”, (room+2)->name, room->age);
}
程序运行后的输出结果是（）
选项：
A:Li:19
B:Wang:19
C:Wang:17
D:Li:20
答案: 【】
7、单选题：
有以下程序
#include <stdio.h>
typedef struct stu {
char name[10];
char gender;
int score;
} STU;
void f(STU *a, STU *b)
{
*b = *a;
printf(“%s,%c,%d,”, b->name, b->gender, b->score);
}
main()
{
STU a={“Zhao”, ‘m’, 290}, b={“Qian”, ‘f’, 350};
f(&a,&b);
printf(“%s,%c,%d”, b.name, b.gender, b.score);
}
程序的运行结果是（）
选项：
A:Zhao,m,290,Qian,f,350
B:Zhao,m,290,Zhao,m,290
C:Qian,f,350,Qian,f,350
D:Qian,f,350,Zhao,m,290
答案: 【】
第十二章 单元测试
1、单选题：
若有以下程序
#include <stdio.h>
main()
{ int c;
c= 10^5;
printf(“%d”, c);
}
则程序的输出结果是（ ）。
选项：
A:15
B:5
C:10000
D:105
答案: 【
】
2、单选题：
下面选项中关于位运算的叙述正确的是（ ）。
选项：
A:左移运算的结果总是原操作数据2倍
B:位运算符都需要两个操作数
C:右移运算时，高位总是补0
D:位运算的对象只能是整型或字符型数据
答案: 【】
3、单选题：
下面关于位运算符的叙述，正确的是（ ）。
选项：
A: ||表示“按位或“的运算
B:#表示“按位异或“的运算
C:&表示“按位与“的运算
D:~表示“按位异或“的运算
答案: 【
】
4、单选题：
有以下程序
#include <stdio.h>
main()
{
int a=3 ,b=3;
printf(“%d “,a&b);
}
程序运行后的输出结果是（ ）。
选项：
A:6
B:1
C:3
D:0
答案: 【
】
5、单选题：
有以下程序
#include <stdio.h>
main()
{
int c,d;
c = 10 | 5; d = 10 + 5;
printf(“%d,%d”, c, d);
}
程序的运行结果是（ ）。
选项：
A:15,15
B:105,15
C:5,15
D:10,15
答案:
第十三章 单元测试
1、单选题：
以下关于fclose(fp)函数的叙述正确的是（ ）。
选项：
A:只有对文件进行输入操作之后，才需要调用fclose(fp)函数关闭文件
B:只有对文件进行输出操作之后，才能调用fclose(fp)函数关闭文件
C:当程序中对文件的所有写操作完成之后，不一定要调用fclose(fp)函数关闭文件
D:当程序中对文件的所有写操作完成之后，必须调用fclose(fp)函数关闭文件
答案: 【】
2、单选题：
以下叙述正确的是（ ）。
选项：
A:fopen函数的返回值必须赋给一个任意类型的指针变量
B:fopen函数的调用形式为：fopen(文件名)
C:fopen函数的返回值为NULL时，则成功打开指定的文件
D:在C语言中调用fopen函数就可把程序中要读、写的文件与磁盘上实际的数据文件联系起来
答案: 【】
3、单选题：
若有以下程序
#include <stdio.h>
int main()
{ FILE *fp;
int i, a[6]={1,2,3,4,5,6},k;
fp = fopen(“data.dat”, “w+”);
for (i=0; i<6; i++)
{ fseek(fp, 0L, 0);
fprintf(fp, “%d”, a[i]);
}
rewind(fp);
fscanf(fp, “%d”, &k);
fclose(fp);
printf(“%d”, k); return 0;
}
则程序的输出结果是（ ）。
选项：
A:123456
B:1
C:6
D:21
答案: 【
】
4、单选题：
下面选项中关于“文件指针“概念的叙述正确的是（ ）。
选项：
A:文件指针是程序中用FILE定义的指针变量
B:文件指针指向文件在计算机中的存储位置
C:把文件指针传给fscanf函数，就可以向文本文件中写入任意的字符
D:文件指针就是文件位置指针，表示当前读写数据的位置
答案: 【】
5、单选题：
下面关于“EOF”的叙述，正确的是（ ）。
选项：
A:EOF是在库函数文件中定义的符号常量
B:EOF的值等于0
C:对于文本文件，fgetc函数读入最后一个字符时，返回值是EOF
D:文本文件和二进制文件都可以用EOF作为文件结束标志
答案: 【】
6、单选题：
标准库函数fgets( s,n,f )的功能是（ ）。
选项：
A:从文件f中读取n个字符串存入指针s所指的内存
B:从文件f中读取长度为n的字符串存入指针s所指的内存
C:从文件f中读取长度不超过n-1的字符串存入指针s所指的内存
D:从文件f中读取n-1个字符串存入指针s所指的内存
答案: 【】
7、单选题：
有如下程序
#include <stdio.h>
int main()
{
int i;
FILE* fp;
for (i=0; i<5; i++)
{
fp = fopen(“output.txt”, “w”);
fputc(‘A’ + i, fp);
fclose(fp);
}
return 0;
}
程序运行后，在当前目录下会生成一个output.txt文件，其内容是（ ）。
选项：
A:A
B:ABCDE
C:EOF
D:E
答案: 【】
8、单选题：
l 有下列程序
#include <stdio.h >
int main( )
{ FILE *fp;
int i, a[6]={ 1,2,3,4,5,6};
fp = fopen(“d.dat”, “w+b”);
for(i=0;i<6;i++)
fwrite(&a[i], sizeof(int), 1, fp);
rewind(fp);
fread(&a[3], sizeof(int), 3, fp);
fclose(fp);
for (i=0;i<6; i++)
printf(“%d,”, a[i]);
return 0;
}
程序执行后的输出结果是（ ）。
选项：
A:1,2,3,1,2,3,
B:4,5,6,1,2,3,
C: 4,5,6,4,5,6,
D: 1,2,3,4,5,6,
答案: 【】
9、单选题：
以下程序依次把从终端输入的字符存放到f文件中，用#作为结束输入的标志, 则在横线处应填入的选项是 （ ）。
#include <stdio.h>
int main()
{ FILE *fp; char ch;
fp=fopen( “fname”, “w” );
while(( ch=getchar()) !=’#’) fputc( __________ );
fclose(fp);
return 0;}
选项：
A:fp, ch
B:ch, fp
C:ch, “fname”
D:ch
答案: 【】
10、单选题：
以下不能对文件进行输出的库函数是（ ）。
选项：
A:fpout
B:fwrite
C:fputc
D:fprintf
答案: 【】
请先 ！