语言的编译系统对宏命令是

A. 以下叙述正确的是（C）

1.呵呵。#define和printf都属于预处理命令。预处理命令都不是C语句。而预处理

命令式有ANSI C统一规定的，它不是C语句本身的组成部分。

2.正是由于预处理命令不是C语句的本身组成部分，所以，不能直接对它们进行

编译（因为编译程序不能识别它们），必须在对程序进行通常的编译之前，先对

程序中的这些特殊的命令进行预处理。而宏命令正是预处理命令的一部分。

详细请见C语言的预处理部分。

B. C语言的编译系统对宏命令的处理是

前言：宏实质就是编译器在对代码进行编译之前进行的一个“查找替换”工作，就跟你在处理文档时用wps/word/记事本等进行“查找替换”操作一样。
c语言的编译系统对宏命令的处理是（）
a。在程序运行时进行的
b。在对源程序中其他成分正式编译之前进行的
c。在程序连续时进行的
d。和c程序中的其他语句同时进行编译
答：选b。在对源程序中其他成分正式编译之前进行的
2,
#define
n
2
/*
在预编译时将用下面代码中n替换成2
*/
#define
m
n+1
/*
在预编译时将m替换成n+1（即2+1，n会再被替换成2）*/
#define
num
2*m+1
/*
如上：在预编译时num替换成2*m+1，即2*n+1+1，即2*2+1+1*/
main()
{int
i;
for(i=1;i<=num;i++)printf("%d\n",i);
/*
*
如上所述，上句展开为：for(i=1;i<=2*2+1+1;i++)printf("%d\n",i);
*
所以：循环将执行6次
*/
}
/*
切记注意：每一个宏百进行替换时只是替换“正文”中的内容，而不包括预编译语句的内容，
否则就会像不少人理解的那样，错误地认为第2个题中的循环将执行7次
*/

C. c语言问题

ADBCADCBAC

D. C语言编译系统对宏替换的处理是在什么时候进行的

是正式工作开始之前的准备工作，所以宏替换是在对程序编译之前进行的。

宏替换是C/C++的预处理中的一部分，对于宏定义中的形参，在替换列表中，如果不是作为#或##的操作数，那么将对应实参完全展开(相当于对实参进行求值)，然后将替换列表中的形参替换掉，如果是#或##的操作数。

(4)语言的编译系统对宏命令是扩展阅读：

宏的用途在于自动化频繁使用的序列或者是获得一种更强大的抽象能力。

计算机语言如C语言或汇编语言有简单的宏系统，由编译器或汇编器的预处理器实现。C语言的宏预处理器的工作只是简单的文本搜索和替换，使用附加的文本处理语言如M4，C程序员可以获得更精巧的宏。

宏的行为如同是函数对自身程序文本的变形，并且可以应用全部语言来表达这种变形。一个C宏可以定义一段语法的替换，然而一个Lisp的宏却可以控制一节代码的计算。

E. c语言中的“宏”是指什么

是一种批量处理的称谓。计算机科学里的宏是一种抽象（Abstraction），它根据一系列预定义的规则替换一定的文本模式。

“宏”这个词的使用暗示着将小命令或动作转化为一系列指令。
计算机语言如C语言或 汇编语言有简单的宏系统，由编译器或汇编器的预处理器实现。C语言的宏预处理器的工作只是简单的文本搜索和替换，使用附加的文本处理语言如M4，C程序员可以获得更精巧的宏。

在Objective-C语言源程序中，允许用一个标识符来表示一个字符串，称为宏，被定义为宏的标识符称为宏名。在编译预处理时，对程序中所有出现的宏名，都用宏定义中的字符串去替换，这称为宏替换或宏展开。

宏定义是由源程序中的宏定义命令完成的，宏替换是由预处理程序自动完成的。在Objective-C语言中，宏分为有参数和无参数两种。

(5)语言的编译系统对宏命令是扩展阅读

A类宏是用G65 Hxx P#xx Q#xx R#xx或G65
Hxx P#xx Qxx
Rxx格式输入的，xx的意思就是数值，是以um级的量输入的，比如你输入100那就是0.1MM #xx就是变量号，变量号就是把数值代入到一个固定的地址中，固定的地址就是变量。

一般OTD系有#0~#100~#149~#500~#531.关闭电源时变量#100~#149被初始化成“空”，而变量#500~#531保持数据。我们如果说#100=30那么现在#100地址内的数据就是30了。

B类宏能完成某一功能的一系列指令像子程序那样存入存储器，用户可以设定M、S、T、G代码调用它们，使用时只需给出这个指令代码就能执行其功能，也可以像调用子程序一样使用。

F. 宏命令的宏命令（计算机科学）

对于编译语言，宏展开在编译时发生，进行宏展开的工具常被称为宏展开器。宏这一术语也常常被用于许多类似的环境中，它们是源自宏展开的概念，这包括键盘宏和宏语言。绝大多数情况下，“宏”这个词的使用暗示着将小命令或动作转化为一系列指令。
计算机语言如C语言或汇编语言有简单的宏系统，由编译器或汇编器的预处理器实现。C语言的宏预处理器的工作只是简单的文本搜索和替换，使用附加的文本处理语言如M4，C程序员可以获得更精巧的宏。 应用程序也可以使用一种和宏类似机理的系统来允许用户将一系列（一般是最常使用到的操作）自定义为一个步骤。也就是用户执行一系列操作，并且让应用程序来“记住”这些操作以及顺序。更高级的用户可以通过内建的宏编程来来直接使用那些应用程序的功能。
当使用一种不熟悉的宏语言来编程时，比较有效的方法就是记录一连串用户希望得到的操作，然后通过阅读应用程序记录下来的宏文件来理解宏命令的结构组成。

G. C语言帮忙对一下答案

这是老师给的一分以前卷子的参考题目和答案，明天就要补考了，题目很简单的应该，但我基本不懂，可我发现好象答案不对的，谁能帮我对一下谢谢了。答案附在后面

A卷
一、单项选择题（每小题2分，共40分）。
1． 一个C语言程序至少包含一个（ ）函数
A. printf B. scanf C. main D.自定义
2.以下叙述正确的是（ ）
A． 在C程序中，main( )函数必须位于程序的最前面
B． C程序的每行中只能写一个语句
C． C语言本身没有输入输出语句
D． 在对C语言进行编译的过程中，可以发现注释中的错误
3.下列C语句不正确的有（ ）
A．x=y=14; B.int x,y,z;
C.x=4,y=13; D.z=x+y;
4. 在int(*prt)[3];语句中，关于标识符prt正确的选项是（ ）
A.定义不合法
B.一个指向整型变量的指针
C.一个指针，它指向一个具有3个元素的一维数组
D.一个指针数组名，每个元素是一个指向整型变量的指针
5. 与十六进制数200等值的十进制数为 ( )
A . 256 B. 512 C .1024 D. 2048

6.以下叙述中正确的是（ ）
A. C语言的源程序不必通过编译就可以直接运行
B. C语言中的每条可执行语句最终都将被转换成二进制的机器指令
C. C源程序经编译形成的二进制代码可以直接运行
D. C语言中的函数不可以单独进行编译

7. putchar函数可以向终端输出一个( )。
A． 整型变量表达式值 B .实型变量值
C. 字符串 D. 字符或字符变量值
8.已知float a=10.6,a/=2的结果是( )
A.5.3 B.5.300000 C.5.0 D.5
9. 在下列符号中，哪个是合法的变量名？（ ）
A、 #jhgf B、 _gh3 C、 -76t D、 3ab
10. 有如下输入语句scanf(“a=%d,b=%d,b=%d”,&a,&b,&c);为使变量a的值为1,b 的值为3,c的值为2,从键盘输入数据的正确形式应是( ).
A.132<CR> B.1,3,2<CR> C.a=1,b=3,c=2<CR> D.a=1 b=3 c=2<CR>

11.已知字母A的ASCII码是65,以下程序的执行结果是( )
# include <stdio.h>
main ( )
{char c1=’A’,c2=’E’;
printf (“%d,%d”,c1,c2);}
A. A , E B. 65 , 65 C. 65 , 69 D. 65 ,70
12. 在C语言中switch语句可以和（ ）关键字配合使用来构成多分支选择语句。
A. case B.break C. goto D. else
13.如果a=4,b=4,则！（a>b）的值为（ ）
A． 真 B 假 C 不确定
14.能正确表示“m≥5或m≤3”的关系表达式是（ ）
A．m>=5 or m<=3” B m>=5|m<=3
C. m>=5||m<=3 D.m>=5 + m<=3
15.已知一个函数的定义为： void abc ( ) { … }
则函数中 void 的含义是( )
A、 执行该函数后函数没有返回值 B、 执行该函数后不返回
C、 该函数可以返回任意类型的数据 D、 以上都不对
16.C语言的编译系统对宏命令的处理是( )
A.、在程序运行时进行
B、在程序连接时进行
C、和C程序中的其他语句同时进行编译的
D、在对源程序中其他成分正式编译之前进行
17.判断字符串s1是否大于字符串s2,应当使用（ ）
A．if (s1>s2) B. if （strcmp (s1,s2) ）
C. if (strcmp(s2,s1)>0) D.if (strcmp(s1,s2)>0)
18.设有数组定义：char array[ ]=”China”;则数组array所占的空间为（ ）个字节。
A． 4 B. 5 C. 6 D. 7
19. 若有定义：int x=7, p=&x; 则执行*p=*p+1; x=x+2; 以后x的值是： ( )
A. 7 B. 8 C. 9 D. 10
20. 以下在任何情况下计算平方数时都不会引起二义性的宏定义是（ ）
A. #define POWER(x) x*x
B. #define POWER(x) (x)*(x)
C.#define POWER(x) (x*x)
D.#define POWER(x) ((x)*(x))
二、填空题(每空2分，计20分)
1一个C源程序至少应包括一个_______。
2.程序三种最基本的结构是___________、_______________、_________________。
3.若a是int 型变量，且a的初值为6，则计算表达式a+=a*a; 后a的值为______。
4. 指针变量的含义是指向变量的_______
5.若有以下定义：float w[16]; 则w数组元素下标的取值范围是______到______。
6..设a=3, b=2, c=1, 则表达式a>b+c的值是_____________。
7..以下程序段的运行结果是______
char a[7]=”abcdef”;
printf(“%c”,a[5]);
三、读程序，写出运行结果（5*4分）
1．下面程序的运行结果是_______________________________________
# include <stdio.h>
main ( )
{ int a, b;
a = 10;
b = a*9;
printf(“b = %d\n”, b);
}
2． 以下程序段的运行结果是__________
# define ADD(x) x+x
main( )
{ int m=1, n=2, k=3;
int sum=ADD(m+n)*k;
printf (“sum=%d”,sum);
}

3. 以下程序输入123456<CR>后的执行结果是______
# include <stdio.h>
main( )
{int a,b;
scanf (“%2d%3d”,&a,&b);
printf (“a=%d,b=%d\n”,a,b);
}
4.下面程序的运行结果是_______________________________________。
main ( )
{ int i;
for (i=1;i<=5;i++)
{ if (i%2)
printf (“*”);
printf (“#”);
}
printf (“#”);
}
5.以下程序的运行结果是_______
#include <stdio.h>
int a=10,b,*p;
main( )
{p=&a;
b=(*p)++;
printf(“%d,%d\n”,a,b);
}

答案
1.A 2．C 3．C 4．C 5．B 6．C 7．D 8．B
9．B 10．C 11．C 12．A 13．A 14．C 15．A 16．D
17．B 18．C 19．C 20．A

二、填空题(每空2分，计20分)
1、主函数 2、顺序，选择条件，循环结构 3、42 4、地址 5、0，15
6、0 7、f

三、读程序，写出运行结果（5*4分）
1、 b=90 2、sum=10 3、a=12,b=345 4、*##*##*## 5、11，10

B卷
一、单项选择题（每小题2分，共40分）。
1.一个 C语言程序是由( )
A.函数组成
B.若干个过程组成
C.若干子程序组成
D一个主程序和若干子程序组成
2.以下叙述不正确的有（ ）
A. C程序中，语句之间必须用分号（；）分隔
B. C程序中，多行语句可以写在一行中
C. C程序中，可以不必包含主函数
D. C程序中，可以由多个函数组成
3.下列C语句不正确的有（ ）
A．x=y=14; B.int x,y,z; C.x=4,y=13; D.z=x+y;
4.已知int a = 5, 则执行a = a/2; 后的a值是 ( )
A. 2.5 B. 2 C. 2.0 D. 3
5.判断整数a和b是否相等，应当使用 ( )
A．if (a==b) B. if (a=b) C. if (a, b) D. if (a!=b)
6.C语言的标识符的第一个字符必须为( )
A.字母 B.下划线 C. 字母或下划线 D. 字母或下划线或数字
7. 已知字母A的ASCII码值为66，执行下面的程序：
main( )
{ char c1=’A’;
printf(“%d %c\n”, c1, c1);
} 执行后输出结果是（ ）
A. 66 A B. A 66 C. 65 A D. A 65
8.在C语言中if语句可以和（ ）关键字配合使用来构成分支选择语句。
A. else B.break C. goto D. int
9. putchar函数可以输出一个( )。
A． 整型变量表达式值
B． 实型变量值
C． 字符串
D． 字符
10. C语言中while和do-while循环的主要区别是( )。
A． do-while的循环体至少无条件执行一次
B． while的循环控制条件比do-while的循环控制条件严格
C． do-while允许从外部转到循环体内
D. do-while的循环体不能是复合语句

11. 如果a=4,b=4,则（a<b）的值为（ ）
A． 真 B 假 C 不确定
12.下面对变量说明错误的是（ ）
A. char c1, int x; B. int a, b; float x, y;
C. int a; int b; D. char c1; int x;
13.若有a=1,b=2,c=3,d=4则条件表达式 a > b? c : d的值为 ( )
A. 2 B. 1 C. 4 D. 3
14. 设变量a是整型，f是实型，i是double型，则表达式10+’a’+i*f的值的数据类型为（ ）
A.整型 B. float C.double D.不确定
15.若有定义：int x, *pb; 则以下正确的赋值表达式是：
A）pb=&x; B)pb=x; C)*pb=&x; D)*pb=*x;
16.在C语言程序中，（ ）。
A． 函数的定义可以嵌套，但函数的调用不可以嵌套
B． 函数的定义不可以嵌套，但函数的调用可以嵌套
C． 函数的定义和函数均不可以嵌套
D. 函数的定义和函数均可以嵌套
17.以下程序段的运行结果是( )
char a[7]=”abcdef”;
printf(“%c”,a[5]);
A. d B. f C. e D.
18.凡是在函数中未指定存储类别的局部变量，其隐含的存储类别为（）
A．自动（auto） B.静态（static） C.外部（extern） D.寄存器（register）
19.在int(*prt)[3];语句中，关于标识符prt正确的选项是（）
A. 定义不合法
B. 一个指向整型变量的指针
C. 一个指针，它指向一个具有3个元素的一维数组
D. 一个指针数组名，每个元素是一个指向整型变量的指针
20.判断char型变量c1是否为小写字母的正确表达式是（ ）
A. (c1>=’a’)&&(c1<=‘z’ ) B. (c1>=a)&&(c1<=z )
C. (’a’<= c1 <=‘z’ ) D. ( a<= c1 <= z )
二、填空题(每空2分，计20分)
1.在C语言中，表示逻辑“假”值用______ 。
2.在C语言中（以微型机为例），一个char型数据在内存中所占的字节数是_____;一个float型数据在内存中所占的字节数是_____;一个double型数据在内存中所占的字节数是__________。
3．若a是int 型变量，且a的初值为3，则计算表达式a+=a*a; 后a的值为______。
4．C源程序的基本单位是_______
5若有以下定义：int score[6]; 则score数组元素下标的取值范围是______到______。
6. 字符‘0’的十进制ASCII码值是48，则字符‘9’的十进制ASCII码值是_______
7.有表达式 “20 < x <30”, 用C语言正确描述它应该是__________________________。

三、读程序，写出运行结果（5*4分）
1．执行下面的程序：
void main( )
{ int x=3, y＝1;
if ( x < y ) printf(“*****\n”);
else printf(“#####\n”);
}
其输出的结果是__________________________。

2.下面程序的运行结果是______________________________________(画□表示空格)。
假设输入1.23 50
# include <stdio.h>
main ( )
{ float x, y;
scanf(“%f%f”, &x, &y);
printf(“x=%7.2f, y=%7.2f\n”, x, y );
}

3.写出下面程序的输出结果_______________________________________________。
main ( )
{ int a=10, b=14, c=3;
if ( a < b ) a = b;
if ( a < c ) a = c;
printf(“a=%d, b=%d, c=%d\n”, a, b, c );
}

4.下面程序的输出结果是_____________
main()
{int number=0;
while (number++>=1)
printf (“*%d\n”,number);
printf(“**%d\n”,number);
}

5以下程序的运行结果是_______
void increment( )
{int x=0;
x+=1;
printf(“%d”,x);
}
main( )
{increment( );
increment( );
increment( );
}

一、单项选择题（每小题2分，共40分）。
1．A 2．C 3．C 4．B 5．A 6．C 7．A 8．A
9．D 10．A 11．B 12．A 13．C 14．C 15．A 16．B
17．B 18．A 19．D 20．A
二、填空题(每空2分，计20分)
1、1 2、1,4,8 3、42 4、函数 5、0，5 6、57 7、x>20&&x<30
三、读程序，写出运行结果（5*4分）
1、##### 2、x= 1.25 y= 50.00 3、a=14,b=14,c=3
4、**1 5、111

H. 电气三班c语言选择题

下面说法不正确的是（）。
调用函数时，实参可以是表达式
调用函数时，实参和形参可以共用内存单元
调用函数时，将实参的值复制给形参，使实参变量和形参变量在数值上相等
调用函数时，实参与形参的类型必须一致
~B
~~~6
下面函数调用语句含有实参的个数为（）。
func((exp1,exp2),(exp3,exp4,exp5));
1
2
3
5
~B
~~~6
在C语言中，函数调用时（）。
实参和形参各占独立的存储单元
实参和形参共用存储单元
由系统自动确定实参和形参是否共用存储单元
由用户指定实参和形参是否共用存储单元
~A
~~~6
C语言规定，程序中各函数之间（）。
既允许直接递归调用也允许间接递归调用
既不允许直接递归调用也不允许间接递归调用
允许直接递归调用不允许间接递归调用
不允许直接递归调用允许间接递归调用
~A
~~~8
下列能正确定义一维数组的选项是（）。
int a[5]={0,1,2,3,4,5};
char a[]={0,1,2,3,4,5};
char a={'A','B','C'};
int a[5]="0123";
~B
~~~8
下列叙述中错误的是（）。
对于double类型数组，不可以直接用数组名对数组进行整体输入或输出
数组名代表的是数组所占存储区的首地址，其值不可改变
在程序执行中，数组元素的下标超出所定义的下标范围时，系统将给出“下标越界”的出错信息
可以通过赋初值的方式确定数组元素的个数
~C
~~~8
有下列程序：
#include <string.h>
main()
{ char p[]={'a','b','c'},q[10]={'a','b','c'};
printf("%d%d\n",strlen(p),strlen(q));
}
下列叙述中正确的是（）。
在给p和q数组赋初值时，系统会自动添加字符串结束符，故输出的长度都为3
由于p数组中没有字符串结束符，长度不能确定，但q数组中字符串长度为3
由于q数组中没有字符串结束符，长度不能确定，但p数组中字符串长度为3
由于p和q数组中都没有字符串结束符，故长度都不能确定
~A
~~~8
若要求从键盘读入含有空格字符的字符串，应使用函数（）。
getc()
gets()
getchar()
scanf()
~B
~~~8
当用户要求输入的字符串中含有空格时，应使用的输入函数是（）。
scanf()
getchar()
gets()
getc()
~C
~~~8
当有定义语句：char s[10];,若要从终端给s输入5个字符，错误的输入语句是（）。
gets(&s[0]);
scanf("%s",s+1);
gets(s);
scanf("%s",s[1]);
~D
~~~8
当以下叙述中错误的是（）。
gets函数用于从终端读入字符串
getchar函数用于从磁盘文件读入字符
fputs函数用于把字符串输出到文件
fwrite函数用于以二进制形式输出数据到文件
~B
下列关于字符串的叙述中正确的是（）。
C语言中有字符串类型的常量和变量
两个字符串中的字符个数相同时才能进行字符串大小的比较
可以用关系运算符对字符串的大小进行比较
空串一定比空格打头的字符串小
~D
~~~8
下面能正确进行字符串赋值的是（）。
char s[5]={"ABCDE"};
char s[5]={'A','B','C','D','E'};
char*s; s="ABCDE";
char*s;printf("%s",s);
~C
~~~8
字符串"\\\"ABCDEF\"\\"的长度是（）。
15
10
7
8
~B
~~~8
下面各语句行中，能正确进行赋值字符串操作的是（）。
char s[5]={'a','b','c','d','e'};
char *s;gets(s);
char *s;*s="ABCDEF";
char s[5];scanf("%s",&s);
~B
~~~8
设已执行预编译命令#include<string.h>,以下程序段的输出结果是（）。
char s[]="abcdefg";
printf("%d\n",strlen(s));
7
8
9
10
~A
~~~8
若已包括头文件<string.h>且已有定义char s1[18],s2={"ABCDE"}和int i，现要将字符串"ABCDE"赋给s1,下述语句错误的是（）。
strcpy(s1,s2);
strcpy(s1,"ABCDE");
s1="ABCDE";
for(i=0;i<6;i++)
s1[i]=s2[i];
~C

###
~~~7
*以下程序的输出结果是[<4>]。
*#include<stdio.h>
*main()
*{
* int a[5]={2,4,6,8,10},*p;
* p=a;p++;
* printf("%d",*p);
*}
~~~7
*以下程序的输出结果是[<3 5>]。
*#include<stdio.h>
*void swap(int *a,int *b)
*{
* int *t ;
* t=a;a=b;b=t;
*}
*main()
*{
* int i=3,j=5,*p=&i,*q=&j;
* swap(p,q);printf("%d %d",*p,*q);
*}
~~~7
*下面程序段的运行结果是[<68>]。
*char str[]="ABCD",*p=str;
*printf("%d\n",*(p+3));

###
~~~7
设已有定义：float x;，则下列对指针变量p进行定义且赋初值的语句中正确的是( )。
float *p=1024;
int *p=(float)x;
float p=&x;
float *p=&x;
~D
~~~7
设有定义语句int (*f)(int);，则以下叙述正确的是( )。
f是基类型为int的指针变量
f是指向函数的指针变量，该函数具有一个int类型的形态
f是指向int类型一维数组的指针变量
f是函数名，该函数的返回值是其类型为int类型的地址
~B
~~~7
设有定义：int n1=0,n2,*p=&n2,*q=&n1;，以下赋值语句中与n2=n1;语句等价的是( )。
*p=*q
p=q
*p=&n1;
p=*q
~A
~~~7
在16位编译系统上，若有定义int a[]={10,20,30},*p=&a;，当执行p++;后，下列说法错误的是( )。
p向高地址移了一个字节
p向高地址移了一个存储单元
p向高地址移了两个字节
p与n+1等价
~A
~~~7
若有定义语句：int k[2][3],*pk[3];，则下列语句中正确的是( )。
pk=k;
pk[0]=&k[1][2];
pk=k[0];
pk[1]=k;
~B
~~~7
若有定义：char(*p)[6];则标识符p( )。
是一个指向字符型变量的指针
是一个指针数组名
是一个指针变量，它指向一个含有6个字符型元素的一维数组
定义不合法
~C
~~~7
下面程序段的运行结果是( )。
#include<stdio.h>
void main()
{ char str[]="abc",*p=str;
printf("%d\n",*(p+3));
}
67
0
字符'C'的地址
字符'C'
~B
~~~7
若有以下定义，则对a数组元素的正确引用是( )。
int a[5],*p=a;
*&a[5]
*a+1
*(p+5)
*(a+2)
~D

###
~~~3
C语言中用[<非0>]表示逻辑"真"，用[<0>]表示逻辑值"假"。
~~~3
C语言中逻辑运算符[<!>]的优先级高于算术运算符。
~~~3
当a=1，b=2，c=3时，以下if语句执行后，a、b、c中的值分别为[<3>]、[<2>]、[<2>]。
if(a>c)
b=a;a=c;c=b;
~~~3
以下程序段的输出结果是[<死循环>]
int k,n,m;
n=10;m=1;k=1;
while(k<=n) m*=2;
printf("%d\n",m);
~~~3
以下程序的输出结果是[<-1>]
main()
{
int x=2;
while(x--);
printf("%d\n",x);
}
~~~3
以下程序段：
s=1.0;
for(k=1;k<=n;k++)
s=s+1.0/(k*(k+1))
printf("%f\n",s);
请填空，使下面的程序段的功能完全与之等同。
s=0.0
[<d=1.0>]
k=0;
do
{
s=s+d;
[<k++>]
d=1.0/(k*(k+1));
}
while[<k<=n>]
printf("%f\n",s);
~~~3
以下程序功能是：从键盘上输入若干个学生的成绩，统计并输出最高成绩和最低成绩，当输入负数时结束输入。请填空。
main()
{
float x,amax,amin;
scanf("%f",&x);
amax=x;
amin=x;
while[<x>=0>]
{
if(x>amax) amax=x;
if[<x<amin>] amin=x;
scanf("%f",&x);
}
printf("\namax=%f\namin=%f\n",amax,amin);
}
~~~5
若有定义int a[3][5];则排列在数组中的第九个元素是[<a[1][3]>]
~~~5
strlen("How are you\n")的值是[<12>]
~~~5
C语言中字符串结束的标志是[<'\0'>]
~~~5
写出一个名为s的单精度实型一维数组，长度是6，所有元素初值均为0，其数组定义语句是[<float s[6]={0};>]
~~~5
strcmp("how","How")的值是[<32或者>0>]
~~~6
C语言程序执行的开始处是[<main函数>]
~~~6
C程序中的一个函数由两部分组成，即[<声明部分>]和[<执行部分>]
~~~6
为了保证被调用函数不返回任何值，其函数定义的类型应为[<void>]
~~~6
下面pi函数的功能是，根据以下公式返回满足精度ε要求的∏的值。请填空。∏/2=1+1/3+(1/3)*(2/5)+(1/3)*(2/5)*（3/7)+(1/3)*(2/5)*（3/7)*(4/9)+...
double pi(double eps)
{double s=0.0,t=1.0;
int n;
for([<n=1>];t>eps;n++)
{
s+=t;
t=n*t/(2*n+1);
}
return (2.0*[<s>]);
}
~~~6
以下函数用以求x的y次方。请填空。
double fun(double x,int y)
{
int i;double z;
for(i=1;i[<<=y>];i++)
z=[<Z*x>];
return z;
}
~~~6
以下程序的功能是计算s=0!+1!+2!+3!+...+n!。请填空。
long f(int n)
{ int i; long s;
s=[<1L>];
for(i=1;i<=n;i++) s=[<S*i>];
return s;
}
main()
{
long s;int k,n;
scanf("%d",&n);
s=[<0>];
for(k=0;k<=n;k++) s=s+[<f(k)>];
printf("%ld\n",s);
}

###
~~~3
下列运算符中优先级最高的运算符是()。
!
%
-=
&&
~A
~~~3
下列运算符中优先级最低的运算符是()。
||
!=
<=
+
~A
~~~3
为表示关系x≥y≥z,应使用的C语言表达式是()。
(x>=y)&&(y>=z)
(x>=y)AND(y>=z)
(x>=y>=z)
(x>=y)&(y>=z)
~A
~~~3
设a、b和c都是int型变量，且a=3，b=4，c=5；则以下的表达式中，值为0的表达式是()。
a&&b
a<=b
a||b+c&&b-c
!(a<b)&&!c||1
~D
~~~5
若有int s[4]={1,2,3,4};则s[s[0]+2*s[2]-s[3]]的值是()。
1
2
3
4
~D
~~~5
对数组的描述正确的是()。
数组一旦定义去大小是固定的，但数组元素的类型可以不同
数组一旦定义去大小是固定的，但数组元素的类型必须相同
数组一旦定义去大小是可变的，但数组元素的类型可以不同
数组一旦定义去大小是可变的，但数组元素的类型必须相同
~B
~~~5
对字符串"Boy"进行完整赋值的操作是()
char s[3]={'B','o','y'}
char s[]="Boy"
char s[3]={"Boy"}
char s[3];s="Boy"
~B
~~~5
在c语言中引用数组元素时，其数组下标的数组类型允许是()
整型常量
整型表达式
整型常量或整型表达式
任何类型的表达式
~C
~~~5
对以下说明语句的正确理解是()
*int a[10]={6,7,8,9,10}
将5个初值依次赋给a[1]至a[5]
将5个初值依次赋给a[0]至a[4]
将5个初值依次赋给a[6]至a[10]
因为数组长度与初值的个数不相同，所以此语句不正确
~B
~~~5
以下程序段给数组所有元素输入数据，应在下划线处填入的是()
*main()
*{
*int a[10],i=0;
*while(i<10) scanf("%d",_______);
*:
*:
*}
a+(i++)
&a(i+1)
a+i
&a[++i]
~D
~~~5
以下程序的输出结果是()
*main()
*{
* int a[]={2,4,6,8},y=1,x,*p;
*p=&a[1];
*for(x=0;x<3;x++) y+=*(p+x);
*printf("%d\n",y);
*}
17
18
19
20
~C
~~~6
下述函数定义形式正确的是()
int f(int x;int y)
int f(int x, y)
int f(int x,int y)
int f(x,y:y)
~C
~~~6
关于函数参数，说法正确的是()
实参与其对应的形参各自占用独立的内存单元
实参与其对应的形参共同占用一个内存单元
只有当实参和形参同名时才占用同一个内存单元
形参是虚拟的，不占用内存单元
~A
~~~6
用数组名作为函数的实参时，传递给形参的是()
数组的首地址
数组的第一个元素
数组中的全部元素
数组的元素个数
~A
~~~6
复合语句中定义的变量的作用范围是()
整个源文件
整个函数
整个程序
所定义的复合语句
~D
~~~6
一个函数的返回值由()确定
return语句中的表达式
调用函数的类型
系统默认的类型
被调用函数的类型
~D
~~~6
以下说法正确的是()
C语言程序总是从第一个定义的函数开始执行
在C语言程序设计中，要调用的函数必须在main函数中定义
C语言程序总是从main函数开始执行
C语言程序中的main函数必须放在程序的开始部分
~C
~~~6
以下函数的类型是()
*fff(float x)
*{
*printf("",x*x);
*}
与参数x的类型相同
void类型
int类型
无法确定
~C
~~~6
以下程序的输出结果是()
*fun(int a,int b)
*{int c;
*c=a+b;
*retutn c;
*}
*main()
*{int x=6,y=7,z=8,r;
*r=func((x--,y++,x+y),z--);
*printf("%d\n",r);
*}
11
20
21
31
~C
~~~10
当说明一个结构体变量时，系统分配给它的内存是()
各成员所需内存总量的总和
结构中第一个成员所需内存量
成员中占内存量最大者所需的容量
结构中最后一个成员所需内存量
~A
~~~10
设有以下说明语句：
*struct stu
*{int a;
* float b;
*}stutype;
*则下面叙述不正确的是()
strut是结构体类型的关键字
strut stu是用户定义的结构体类型
stutype是用户定义的结构体类型名
a和b都是结构体成员名
~C
~~~10
C语言结构体类型变量在执行期间()
所有成员一直驻留在内存中
只有一个成员驻留在内存中
部分成员驻留在内存中
没有成员驻留在内存中
~A
~~~11
若想对文本文件只进行读操作，打开此文件的方式为()
"r"
"W"
"a"
"r+"
~A
~~~11
如果要打开C盘file文件夹下的abc.dat文件，fopen函数中第一个参数应为()
c:file\abc.dat
c:\file\abc.dat
"c:\file\abc.dat"
"c:\\file\\abc.dat"
~D
~~~11
用fopen函数打开文件，操作完毕后用()函数关闭它
fopen
open
fclose
close
~C
~~~11
以下可作为函数fopen中第一个参数的正确格式是()
c:user\test.txt
c:\user\test.txt
"c:\user\test.txt"
"c:\\user\\test.txt"
~D
~~~11
若执行fopen函数时发生错误，则函数的返回值是()
地址值
0
1
EOF
~B
~~~11
若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应是()
"ab++"
"wb+"
"rb+"
"ab"
~B
若以"a+"方式打开一个已存在的文件，则以下叙述正确的是()
文件打开时，原有文件内容不被删除，位置指针移到文件末尾，可作添加和读操作
文件打开时，原有文件内容不被删除，位置指针移到文件开头，可作重写和读操作
文件打开时，原有文件内容不被删除，只可作写操作
以上各种说法皆不正确
~A

###
~~~9
下列程序的功能时：给r输入数据后计算半径为r的圆面积s。程序在编译时出错。
main()
{ int r; float s;
scanf("%d",&r);
s=pi*r*r;
printf("s=%f\n",s);
}
出错的原因是（）。
注释语句书写位置错误
存放圆半径的变量r不应该定义为整型
输出语句中格式描述符号非法
计算圆面积的赋值语句中使用了非法变量
~D
~~~9
以下叙述错误的是（）。
在程序中凡是以“#”开始的语句行都是预处理命令行
预处理命令行的最后不能以分号表示结束
#define MAX是合法的宏定义命令行
C程序对预处理命令行的处理是在程序执行的过程中进行的
~C
~~~9
下列叙述中正确的是（）。
预处理命令行必须位于源文件的开头
在源文件的一行上可以有多条预处理命令
宏名必须用大写字母表示
宏替换不占用程序的运行空间
~D
~~~9
若程序中有宏定义行：#define N 100，则下列叙述中正确的是（）。
宏定义中定义了标识符N的值为整数100
在编译程序对C源程序进行预处理时用100替换标识符N
对C源程序进行编译时用100替换标识符N
在运行时用100替换标识符N
~B
~~~9
程序
#include <stdio.h>
#define M 5
#define N M+M
main()
{ int k;
k=N*N*5;
printf("%d\n",k);
}
的输出结果是（）。
100
50
55
45
~C
~~~9
下列叙述中正确的是（）。
预处理命令行必须位于C源程序的起始位置
在C语言中，预处理命令行都以#开头
每个C程序必须在开头包含预处理命令行：#include<stdio.h>
C语言的预处理不能实现宏定义和条件编译的功能
~B
~~~9
C语言的编译系统对宏命令的处理是（）。
在系统对源程序进行编译前
和其他语句的编译同时进行
在程序连接时进行
在程序运行时进行
~A
~~~9
以下叙述中不正确的是（）。
预处理命令行都必须以“#”号开始，结尾不加分号
在程序中凡是以“#”开始的语句行都是预处理命令行
C程序在执行过程中对预处理命令进行处理
预处理命令可以放在程序的任何位置
~C
~~~9
下面叙述中正确的是（）。
C语言中预处理是指完成宏替换和文件包含指定的文件的调用
预处理命令只能位于C源程序文件的首部
预处理命令可以放在程序中的任何位置
预处理命令结尾需要加分号
~C
~~~9
以下有关宏替换的叙述不正确的是（）。
使用宏定义可以嵌套
宏定义仅仅是符号替换
双引号中出现的宏名不替换
宏名必须用大写字母表示
~D