C语言程序设计技术水平考试复习题纲.doc

C语言程序设计技术水平考试复习题纲

一、选择题
l C语言的编译系统对宏命令的处理是( )
A）在程序运行时进行的
B）在程序连接时进行的
C）和C程序中的其它语句同时进行编译的
D）在对源程序中其它语句正式编译之前进行的

l 下列表达式中值为false（假）的是（ ）
A）1<3 && 5<7 B）!(5<10)
C）11 && 0x01 D）!(4<7) || (2<8)

l 如果 x 是一个整型变量，那么以下答案（ ）是赋值 x = 1/3 的结果
A）0.33
B）0.30
C）0
D）未定义的无用数据

l 设int x, *p; 下列表达式中正确的是（ ）
A）5.0%2 B）x+1=5 C）&p D）&(x+1)

l 对以下说明，数值为9的表达式是 ( )
int a[10]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, *p=a;
A）*p+9 B）*(P+8) C）*p+=9 D）P+8

l 以下程序执行后的输出结果是（ ）
void main()
{
int k=2, i=2, m;
m = (k+=i*=k);
printf(%d,%d\n”, m, i);
}
A）8,6 B）8,3 C）6,4 D）7,4

l 以下程序当输入 3 时，输出的结果是（ ）
# include <stdio.h>
void main()
{
int x, y , z;
scanf("%d", &x);
if (x>5)
{
y = 100;
z = -5;
}
printf("%d %d %d",x, y, z);
}
A）3, 无用数据, –5 B）5, 无用数据, 3
C）3, 无用数据, 无用数据 D）无用数据, 无用数据, 无用数据

l 在下面的代码段中，语句 x = 1 会执行（ ）次
for(j =1; j <= n; j++)
for(k=1; k <=n; k++)
x = 1;
A）n B）n(n+1) C）n2 D）n+n

l 以下程序段所做工作是（ ）
do {
scanf("%d", &numb);
} while (numb < 1 || numb > 10);
A）读取 [0,11] 范围之内的一个整数
B）读取 [-1,10] 范围之内的一个整数
C）读取 [1,10] 范围之内的一个整数
D）以上三项皆错

l 在以下四个运算符中，优先级最低的是( )
A）* B）+ C）/ D）=

l 如果n=2，以下程序输出结果是（ ）
switch (n)
{
case(1): printf("You have chosen to add data\n");
break;
case(2): printf("You have chosen to delete data\n");
case(3): printf("You have chosen to view data\n");
break;
case(4): printf("You have chosen to print data\n");
break;
default: printf("Invalid input\n");
break;
}
A）You have chosen to add data
B）You have chosen to delete data
C）You have chosen to delete data
Invalid input
D）You have chosen to delete data
You have chosen to view data
l 假设char str[10]=”China\0”; 执行strlen(str)后的结果是（ ）
A）5 B）6 C）7 D）9

l 运行以下程序的输出结果是（ ）
void main()
{
int n[5]={0}, i, k=2;
for(i=0; i<k; i++)
n[i] = n[i] + 1;
printf(“%d\n”, n[k]);
}
A）不确定 B）2 C）1 D）0

l 对于定义为 float p[3][3]; 的数组，以下用法错误的是（ ）
A）p[0][0] B）p[1][3] C）p[1][1] D）p[1][2]

l 以下程序的输出结果是（ ）
int a, b;
void fun()
{ a=100; b=200 ;}
void main()
{
int a=5, b=7;
fun();
printf(“%d%d\n”, a, b);
}
A）100200 B）57 C）200100 D）75

l （ ）可以是结构体的一部分
A）字符串常量 B）整数变量 C）整数常量 D）字符常量
l 函数原型声明应该放置在（ ）
A）在 main() 函数之中
B）作为 main() 函数中的第一个语句
C）恰好在函数本身的定义之前
D）在其他所有函数之前（包括 main() 函数）

l 在调用一个函数时，主调函数将通过（ ）的变量列表传递给被调函数
A）形式参数 B）实际参数 C）寄存器变量 D）局部变量

l 全局变量的作用域限于 （ ）
A）整个程序包括的所有文件
B）从定义该变量的语句所在的函数
C）本程序文件
D）从定义该变量的位置开始到本程序结束

l 当n=-4时，以下代码段将会发生什么情况（ ）
int factorial(int n)
{
if (n==0)
return 1;
else
return factorial(n-1) * n;
}
A）递归函数返回0
B）递归函数进入无限循环
C）递归函数返回 -4 的阶乘
D）以上三项皆错

l 递归调用中的函数状态将在（ ）中得到保持
A）堆栈 B）堆(Heap) C）树 D）以上皆错

l 以下程序的输出结果是 ( )
void fun(int x, int y, int z)
{
z = x*x+y*y;
}
void main()
{
int a=31;
fun(5, 2, a);
printf(“%d”,a);
}
A）0 B）29 C）31 D）无定值

l 对于声明 int a[100] 和 int j，表达式 *(a + j) 等价于引用（ ）
A）a[j-1] B）a[j+1] C）a D）a[j]

l 以下循环体的执行次数是( )
void main()
{ int i,j;
for(i=0,j=1; i<=j+1; i+=2, j--)
printf("%d \n",i);

A）2   B）3  C）0          D）1
l 有以下程序
#include <stdio.h>
void main( )
{
int i,n=0;
for(i=2;i<5;i++)
{
do
{
if(i%3) continue;
n++;
} while(!i);
n++;
}
printf("n=%d\n",n);
}
则程序执行后的输出结果是（ ）
A）n=4 B）n=2 C）n=3 D）n=5

l 以读写方式打开一个已有的文本文件file1, 下面fopen函数正确的调用方式是（ ）
A）FILE *fp; fp=fopen(“file1”,”r”);
B）FILE *fp; fp=fopen(“file1”,”r+”);
C）FILE *fp; fp=fopen(“file1”,”rb”);
D）FILE *fp; fp=fopen(“file1”,”rb+”);

l 当 int b=2；时，表达式 (b<<2) / (b>>1)的值是（ ）
A）0 B）2 C）4 D）8
l C语言规定：在一个源程序中，main()函数的位置( )。
A、 必须在最开始 B、必须在系统调用的库函数的后面
C、 可以任意 D、必须在最后

l 若x、i、j和k都是int型变量，那么执行表达式x=(i=4，j=16，k＝32)；后，x的值为( )。
A、 4 B、 16 C、 32 D、 52

l 在C语言程序中（ ）
A、函数的定义可以嵌套,但函数的调用不可以嵌套
B、函数的定义不可以嵌套,但函数的调用可以嵌套
C、函数的定义和函数的调用不可以嵌套
D、函数的定义和函数的调用均可以嵌套

l sizeof(double)的返回值类型是( )。
A、 双精度型 B、 单精度型
C、 整型 D、 不合法

l puts函数可以向终端输出一个（ ）
A、整型变量表达式值 B、实型变量值
C、字符或字符型变量值 D、字符串

l 已知i,j,k为int型变量，若从键盘输入：1,2,3<回车>，使i的值为1、j
的值为2、k的值为3，以下选项中正确的输入语句是（ ）。
A、scanf("%2d%2d%2d",&i,&j,&k);
B、scanf("%d %d %d",&i,&j,&k);
C、scanf("%d,%d,%d",&i,&j,&k);
D、scanf("i=%d,j=%d,k=%d",&i,&j,&k);

l 判断char型变量ch是否为小写字母的正确表达式是( )。
A、 ’a’<＝ch<＝’z’ B、 (ch>=’a’)&(ch<=’z’)
C、 (ch>=’a’)&&(ch<=’z’) D、 (ch>=’a’) AND (ch<=’z’)

l 请阅读以下程序：
void main( )
{ int a=1，b=2，c=3；
if(c=a+b)
printf(“***\n”);
else
printf(“$$$\n”);
}
A. 有语法错误，不能通过编译 B. 输出 ***
C. 输出 $$$ D. 可以通过编译，但不能通过连接

l 语句while (! E)；中的表达式 !E 等价于( )。
A、 E==0 B、 E!=1 C、 E!=0 D、 E==1

l 若i为整型变量，则以下循环执行次数是（ ）
for(i=2;i= =0;) printf(“%d”,i- -);
A、无限次 B、0次 C、1次 D、2次

l 以下程序的运行结果是（ ）
#include <stdio.h>
void main()
{ int k=5,a=3,b=2,c=1;
printf("%d\n",k<a?k:(c<b?c:a));}
A、5 B、3 C、2 D、1

l 若有说明：int a[3][4]; 则对a数组元素的非法引用是( )。
A、 a[0][2*1] B、 a[1][3] C、 a[4-2][0] D、 a[0][4]

l 对两个数组a和b进行如下初始化：
char a[]=”ABCDEF”；
char b[]＝{ ‘A’,’B’,’C’,’D’,’E’,’F’};
则以下叙述正确的是( )。
A、 a与b数组完全相同 B、 a和b中部存放字符串
C、 a与b长度相同 D、 a数组比b数组长度长

l 下面程序运行的结果是( )。
void main()
{ char ch[7]=”65ab21”;
int i, s=0;
for (i=0; ch[i]>=’0’&& ch[i]<=’9’; i+=2)
s=10*s+ch[i]-‘0’;
printf(“%d\n”, s);
}
A、 2ba56 B、 6521 C、 6 D、 62

l C语言程序编译时，程序中的注释部分将（ ）。
A、参加编译，并会出现在目标程序中
B、参加编译，但不会出现在目标程序中
C、不参加编译，也不会出现在目标程序中
D、不参加编译，但会出现在目标程序中

l 以下程序的输出结果是( )。
void main()
{
int a=0, i;
for (i=1; i<5; i++)
{
switch (i)
{
case 0:
case 3: a+=2;
case 1:
case 2: a+=3;
default: a+=5;
}
}
printf(“%d”, a);
}
A、 31 B、 13 C、 10 D、 20

l 以下正确的说法是( )。
在C语言中 A、 实参和与其对应的形参各占用独立的存储单元
B、 实参和与其对应的形参共占用一个存储单元
C、 只有当实参和与其对应的形参同名时才共占用存储单元
D、 形参是虚拟的，不占用存储单元

l 关于C语言数组的正确描述是（ ）
A、 数组的大小是固定的，数组中元素的类型可以不同
B、 数组的大小是可变的，数组中元素的类型必须相同
C、 数组的大小是固定的，数组中元素的类型必须相同
D、 数组的大小是可变的，数组中元素的类型可以不同

l 下列关于break语句的叙述中，不正确的是( )。
A、 break语句可用在循环体中，它将使流程跳出本层循环体
B、 break语句可用在switch语句中，它将使流程跳出当前switch语句
C、 break语句可用在if语句中，它将使流程跳出当前if语句
D、 break语句在一层循环体中可以出现多次

l 下列函数声明中，正确的是（ ）。
A、void myfun(int a, b); B、 void myfun(int a, int b);
C、 void myfun(int a; int b); D、 void myfun(int a int b);

l 若要交换int型变量x 和 y 的值，正确的语句是( )。
A、 x=y; B、 int temp=x; x=y; y=temp;
C、 y=x; D、 int temp=x; y=x; x=y;

l 已知函数原型为 void fun(int * )，则下列选项中，正确的函数调用是( )。
A、 double x=3.45; fun(x); B、 int a=15; fun(a*3.14);
C、 int b=100; fun(&b); D、 fun(256);

l 若有宏定义：#define MOD(x, y) x%y ，则执行以下语句后的输出结果为( )。
int z，a=15，b=l00;
z＝MOD(b，a)； b%a
printf(“%d\n”,z);
A、11 B、10 C、6 D、宏定义不合法

l 程序中通过调用库函数中字符串函数来实现字符串操作，需通过（ ）命令将string.h文件包含到该程序中。
A、#define B、#include C、#if D、#iend

l 变量指针的含义是指该变量的( )。
A、值 B、地址 C、名 D、一个标志

l 若已定义 int a=5；下面对(1)，(2)两个语句的正确解释是( )。
(1)int *p=&a; (2) *p=a;
A、 语句(1)和(2)中的*p含义相同，都表示绐指针变量p赋值
B、 (1)和(2)语句的执行结果，都是把变量a的地址值赋给指针变量p
C、 (1)在对p进行说明的同时进行初始化，使p指向a
(2)将变量a的值赋给指针变量p
D、 (1)在对p进行说明的同时进行初始化，使p指向a
(2)将变量a的值赋于*p

l 若有定义：int a[4][3]，则对a数组的第i行第j列(假设i，j已正确说明并赋值)元素值的正确引用为( )。
A、 *(*(a+i)+j) B、(a+i)[j] C、*(a+i+j) D、*(a+i)+j

l 若有以下说明和语句：
struct student
{
int age;
int num;
} std, *p;
p=&std;
则以下对结构体变量std中成员age的引用方式中，不正确的是( )。
A、std.age B、p->age C、(*p).age D、*p.age

l 函数调用语句：fseek(fp, -20L, 2); 的含义是( )。
A、 将文件位置指针移到距离文件头20个字节处
B、 将文件位置指针从当前位置向后移动20个字节
C、 将文件位置指针从文件末尾处向后退20个子节
D、 将文件位置指针移到离当前位置20个字节处

l 字符串”VB\tVC\tJAVA\n”的长度为( )。
A、14 B、8 C、11 D、12

l 若已知 int a=10, b=20; 则表达式 !a<b 的值是( )。
A、10 B、20 C、0 D、1

l 若有代数式,则错误的C语言表达式是（　　　　　）
A、a/b/c*e B、a*e/b*c
C、a*e/b/c D、a*e/c/b

l 在C语言中定义某内部变量时，如省略了存贮类型符，则系统将其默认为（ ）
A、寄存器型 B、自动型
C、静态型 D、非法

l 栈的插入与删除操作是在（ ）进行的。
A、栈顶 B、栈底 C、任意位置 D、指定位置

l 设int型变量n的值为2，执行语句：n+=n*n; 后,n的值为( 　　)。
A、 2 B、 4 C、6 D、 16

l 假设已定义x和y为double类型，则表达式x=1，y=x+5/2 的值是 ( )
A、1 B、3 C、3.0 D、3.5

l 当调用函数时，实参是一个数组名，则向被调用函数传送的是（　　 ）
A、 数组的长度 B、 数组的首地址
C、 数组每一个元素的地址 D、 数组每个元素中的值

l 以下数组定义中不正确的是( )
A、 int a[2][3];
B、 int b[][3]={0,1,2,3}; int a[]={1,2,3,4}
C、 int c[100][100]={0};
D、 int d[3][]={{1,2},{1,2,3},{1,2,3,4}};

l 下面有关for循环的正确描述是 （ ）
A、在for循环中，它只能用于循环次数已经确定的情况
B、在for循环中，要先执行循环体语句，后判断表达式决定下次循环
C、在for循环中，不能用break语句跳出循环体
D、for循环的循环体语句中，可以包含多条语句，但必须用花括号括起来

l 下列表达式中值为false（假）的是 （ ）。
A、1<3 && 5<7 B、!(5<10)
C、11 && 0x01 D、!(4<7) || (2<8)

l 以下函数调用语句中实参的个数 （ ） 。
excc((v1+v2),(v3+v4+v5),v6);
A、3 B、4 C、5 D、6

l 以下程序段( )。
x=-1;
do
{
x=x*x;
} while (x);
A、 是死循环 B、 循环执行一次 C、循环执行二次 D、有语法错误

l 已知字母a 的ASCII码为十进制97，且设ch为字符变量，则表达式ch=‘a’+’8’-’3’的值（ ）
　　A、103 B、C C、f D、F

l 下面程序的运行结果是( )
#include <stdio.h>
void main( )
{ int i, j，x＝0；
for (i=0; i<2; i++)
{ x++;
for (j=0; j<=3; j++)
{ if (j % 2) continue ;
x++;
}
x++;
}
printf(“x=%d \n”, x);
}
A、 x＝4 B、 x=8 C、 x=6 D、 x=12

l 能正确表示逻辑关系：“a≥10或a≤0”的C语言表达式是( )
A、 a>=10 or a<=0 B、 a>=0|a<=10
C、 a>=10 &&a<=0 D、 a>=10‖a<=0

l 定义如下变量和数组：
int i;
int x[3][3]={{9,8,7},{6,5,4},{3,2,1}}；
则下面语句的输出结果是（
for(i=0;i<3;i++)printf(“%d”，x[i][2-i])；
A、7 5 3 B、7 4 1 C、 9 5 1 D、9 6 3

l 在一个被调函数中，关于return语句使用的中，错误的是（ ）
A、 被调函数中可以没有return语句
B、 被调函数中可以使用多个return语句
C、 被调函数中，如果有返回值，就一定要有return语句
D、 被调函数中，一句return语句可以返回多个值给主调函数

l C语言printf()函数中的控制符”\n”的作用是（ ）
A、换行 B、回车 C、换页 D、退格

l C语言中运算对象必须是整型的运算符是( )
A、 %= B、 / C、 = D、〈=

l 有如下程序：
main( )
{ int x=1, a=0, b=0;
switch ( x )
{ case 0: b++; break;
case 1: a++;break;
case 2: a++; b++;
}
printf(“a=%d, b=%d\n”, a, b);
}
该程序的输出结果是( )
A、a=2, b=1 B、a=1, b=0
C、a=0, b=1 D、a=2, b=2

l 对长度为n的线性表进行顺序查找，平均的比较次数为（ ）
A、log2n B、n/2 C、（n+1）/2 D、n+1

l 判断字符串s1是否大于s2，应当使用( )。
A、 if (s1>s2) B. if (strcmp(s1,s2))
C. if (strcmp(s1,s2)>0) D. if (strcmp(s2,s1)>0)

l 若已定义x为int类型变量,下列语句中说明指针变量p的正确语句是（ ）
A、int p=&x; B、int *p=x;
C、int *p=&x; D、*p=*x;

l 下列关于 # include “test.h” 与 # include 〈test.h〉的叙述中，正确的是( )。
A、 # include “test.h” 仅仅搜索当前目录
B、 # include <test.h> 仅仅搜索源程序所在目录
C、 # include “test.h” 直接按系统设定的标准方式搜索目录
D、 # include “test.h” 先在源程序所在目录搜索，再按系统设定的标准方式搜索

l 设有以下说明语句
struct stu
{ int a;
float b;
}stutype;
则下面的叙述不正确的是（ ）
A、struct是结构体类型的关键字
B、stuct stu是用户定义的结构体类型
C、stutype是用户定义的结构体类型名
D、a和b都是结构体成员名

l 以下程序的输出结果是 ( )
void fun(int x, int y, int z)
{ z=x*x+y*y; }
main()
{ int a=31;
fun(5,2,a);
printf(“%d”,a);
}
A、0 B、29 C、31 D、无定值

1. 执行int a=3,*p=&a;后，*p的值为（ ）
A、 变量a的地址值 B、无意义
C、 变量p的地址值 D、 3

l 存储以下数据，占用存储字节最多的是 （ ）
A、0 B、‘0’ C、“0” D、0.0

l 能正确表示代数式的C语言表达式是( )。
A、 sqrt(a*a+b*b) B、 sqrt(a**2+b**2)
C、 pow(a*a+b*b,2) D、 pow(a**2+b**2, 0.5)

l 在C语言中，对动态分配的内存块进行释放功能的函数是( )。
A、 malloc( ) B、 free( )
C、 new_memory( ) D、 dele( )

l 有以下程序
#include <stdio.h>
void main( )
{
int i,n=0;
for(i=2;i<5;i++)
{
do
{
if(i%3) continue;
n++;
} while(!i);
n++;
}
printf("n=%d\n",n);
}
则程序执行后的输出结果是（ ）
A、n=5 B、n=2 C、n=3 D、 n=4

二、阅读与选择题
（）
C 语言中的合法标识符由 C）任意字母 、____ D）数字__、__ _ F）_下横线____组成，且必须以 C）任意字母_____、____ F）下横线______开头。

A）任意字符 B）大写字母 C）任意字母 D）数字
E）小写字母 F）下横线 G）反斜杠 H）关键字

（）
下面程序的功能是输出以下形式的金字塔图案是：
                        *
                       ***
                      *****
                     *******
void main( )
{
int i, j;
for(i=1;i<=4;i++)
{
for(j=1;j<= E 44 ;j++) printf( G 45 );
for(j=1;j<=__B_46__;j++) printf( F 47 );
printf(“\n”);
}
}

A）i   B）2*i-1   C）2*i+1   D）i+2
E）4-i F）”*” G）” ” H）i

 （）
C语言程序分为语句、复合语句、函数和文件四种域。为了编程中的方便，C语言允许程序员把某一变量定义在某一域中才可以操作，这称为变量的 D 。通常把 分为全局和局部两种：只能在 F 中起作用的变量，称为局部变量；可以在 I 中起作用的变量，称为全局变量。
假设在程序的开始处(即在main()之前)定义了一个整型变量count，则count属于 B ，函数myfun(double x)中的形式参数x属于 A 。

A、局部变量 B、全局变量 C、生存期 D、作用域
E、数据类型 F、函数或复合语句 G、类型转换 H、复合语句
I、一个文件或整个程序
（）
在C语言环境下编写与运行一段C程序的过程为：（1）分析程序要求，设计解题的____G_____和_____D____；（2）编写和_____K____源程序，产生的源程序文件的扩展名一般为____J_____；（3）然后对该源程序进行___F______，产生的目标文件的扩展名一般为_____H____；（4）如果没有错误，可以进行_____A____操作，产生可执行文件；（5）运行并得到结果。

A、连接 B、 .doc C、 .exe D、 算法
E、输出 F、 编译 G、 数据结构 H、 .obj
I、输入 J、 .c K、 调用 L、 说明

（）
C语言源程序的结构单位为____H ___，____ H___ 必须先____L ___后调用。每个C程序必须有一个___K ___。调用函数时可以通过__C_ ___向被调用函数传递数据，被调用函数可通过___F ___语句返回结果。C语言允许在函数内部____J ___另一个函数，不允许在函数内部___ D___另一个函数。函数直接或间接调用函数自己，称为___ G___。
A、子程序 B、递推调用 C、参数 D、定义 E、break
F、return G、递归调用 H、函数 I、调试 J、调用
K、main函数 L、声明

()
程序设计语言可划分为低级语言和高级语言两大类。与高级语言相比，用低级语言开发的程序，其 C___，但在 D ___的场合，还经常全部或部分地使用低级语言。在低级语言中，汇编语言与机器语言十分接近，它使用了___ A___来提高程序的可读性。C是一种 __F__，它特别适合编写 H ___的程序。
A、助记符　　　　 B．电子商务
C．运行效率高，开发效率低　 D．对时间和空间有严格要求
E、运行效率低，开发效率高 F、高级语言
G、第四代语言 H、系统软件
I、数值计算

三、阅读与填空题
（）C语言是一种强类型语言，对于变量要“先___ 声明___, 后使用”。
（）表达式：1>2 ? 3:4的值是___4 ____。
（）同一数组中，数组元素之间是通过 下标/索引 来加以区分的。
（）设n为int型变量，请写出描述”n是奇数”的表达式___n%2!=0_ ___。
（） 在C语言中，一个函数由两部分组成，它们分别是函数首部和__ _ _ 函数体/函数定义 组成。
（）定义int a[]={10,20,30,40,50,60},*p=a; 则表达式*(p+2)的值是_30 _
（ ）在循环体中可用_ _break ___语句实现跳出本循环体，提前结束循环。

实践题复习：
l 以下程序的功能是：
从键盘上输入12个整数，存放在数组a[3][4]中，现要求如下：
(1) 找出这些数中的最小值,并记录它的位置(若有多个最小值,只要求找出其中一个即可)；
(2) 输出最小值及其位置（列出它的行、列下标）。
请完成程序填空。
#include <stdio.h>
void main()
{
int (1) ; a[3][4]
int i,j;
int min, row,col;
printf("input 12 numbers:\n");

for(i=0; i<3 ; (2) ) i++
for (j=0; (3) ; j++) j<4
scanf("%d", (4) ); &a[i][j]

min= (5) ; a[0][0]
row=0;
col=0;
for(i=0; i