国家二级C语言机试(编译预处理和指针)模拟试卷13
国家二级C语言机试（编译预处理和指针）模拟试卷13
(总分：52.00，做题时间：90分钟)
一、选择题(总题数：26，分数：52.00)
1.有以下程序#include main() void fun(int*a，int*b) { int x=3，y=5，*p=&x，*q=&y；{ int*c；fun(p，q)；printf("％d，％d，"，*p，*q)；c=a；a=b；b=c；} fun(&x，&y)；printf("％d，％d＼n"，*p，*q)；} 程序运行后的输出结果是
（分数：2.00）
A.3，5，5，3
B.3，5，3，5 √
C.5，3，3，5
D.5，3，5，3
解析：解析：本题考查函数的调用与指针。p和q分别为指向x和y的指针，函数fun()的两个形参均为指针型，主要功能为交换两个指针的指向，当调用结束以后，该操作不能返回主函数。而主函数中，fun(p，q)、fun(&x，&y)的实参均为x与y的地址，因此，两者结果相同，并且两者指针指向的值不能变化。
2.有下列程序： void flint b[]) {int I； for(i=2；i
（分数：2.00）
A.1，2，3，4，5，6，7，8，9，10，
B.1，2，3，4，10，12，14，16，9，10，
C.1，2，6，8，10，12，7，8，9，10，√
D.1，2，6，8，10，12，14，16，9，10，
解析：解析：函数void f(int b[])的功能是对数组b[]中第2个到第5个元素的值逐个扩大2倍。所以在main()函数中，f(a)语句的作用是对数组a[10]中从a[2]到a[5]的各个数字乘以2，因而数组a[10]的元素就变成了{1，2，6，8，10，12，7，8，9，10}。
3.有以下程序 #inclllde int fun(char s[]) main() {int n=0； {char s[10]={'6'，'1'，'*'，'4'，'*'，'9'，'*'，'0'，'*'}；while(*s<='9'&&*s>='0') printf("％d＼n"，fun(s))；{n=10*n+*s-'0'；s++；} } return(n)；} 程序的运行结果是
（分数：2.00）
A.61490
B.61 √
C.9
D.5
解析：解析：在fun函数中，while循环的功能是逐个取字符数组s的字符判断其是否是数字。若是则将这些数字组成一个数保存到变量n中，并返回变量n的值。所以在主函数中调用fun (s)时，将把字符数组s中的数字组成一个数输出。因为当指针s指向数组的第3位时，即字符件'*'，循环条件不成立，循环结束，返回n的值。所以输出n的值为61。
4.若有以下程序#include void sp(int*a){int b=2；main(){int k=3，*p=&k；a=&b；sp(p)；*a=*a*2；printf("％d，％d＼n"，k，*p)； printf("％d，"，*a)；} } 则程序的输出结果是
（分数：2.00）
A.4，3，4
B.4，3，3 √
C.6，3，6
D.6，6，6
解析：解析：主函数中定义指针变量p指向k，调用函数sp(p)，将k的地址传递给形参指针a，函数转到sp运行，a指向b的地址，表达式*a=*a*2，相当于b=b*2，得到*a的数据4输出。函数调用结束，此时a 和b的空间撤销，而对实参k和p的值并没有改变，仍旧是3。
5.若有以下程序 #include int k=7； void f(int**s){int*t=&k； *s=t； printf("％d，％d，％d，"，k，*t，**s)；} main(){int i=3，*p=&i，**r=&p；f(r)；printf("％d，％d，％d＼n"，i，*p，**r)；}
则程序的输出结果是
（分数：2.00）
A.3，7，7，7，7，7
B.7，7，7，3，3，3
C.3，3，3，7，7，7
D.7，7，7，3，7，7 √
解析：解析：本题考查了二级指针，二级指针可以保存一级指针的地址。主函数中p指向i，r指向p，函数调用后s指向p，在f函数中t指向全局变量k=7，s指向t，同时s保存了实参p的地址，此时p也指向t，输出三个7，流程转到主函数，i的值为3，p以及r的值为7。
6.若有以下程序 #include int*f(int*s，int*t){int*k；if(*s
（分数：2.00）
A.3，5，5，3，5
B.5，3，5，3，5
C.5，3，3，5，5
D.3，5，3，5，5 √
解析：解析：本题考查了返回值为指针的函数，函数f的主要功能为第一个参数小于第二个参数，那么交换指针的指向，这对于实参指向的数据时没有影响的。最后返回比较大的元素的地址。主函数中p指向i，q指向i，调用r=f[p，q)，返回q的地址，因此*p=3，*q=5，*r=5。
7.若有以下程序#include main(){int k=3；void sp(int*a){int b=2；sp(&k)；*a=*a*2；printf("％d＼n"，k)； printf("％d，"，*a)； } a=&b； *a=*a*2； printf("％d，"，*a)；} 则程序的输出结果是
（分数：2.00）
A.6，4，6 √
B.6，4，3
C.6，12，12
D.9，4，9
解析：解析：本题考查了指针作为函数的参数，可以接收实参变量的地址，改变实参的值。主函数调用sp(&k)，执行sp函数a指向向k，执行语句*a=*a*2后a指向空间的值k的值为6，改变a的指向以后，此时a指向b，则执行*a=*a*2以后，a指向空间b的值为4。调用结束返回主函数，输出k的值为6。
8.若有以下程序#include int k=7，m=5；void f(int **s){int*t=&k；s=&t；*s=&m；printf("％d，％d，％d，"，k，*t，**s)；} main(){int i=3，*p=&i，**r=&p；f(r)；printf("％d，％d，％d＼n"，i，*p，**r)；} 则程序的输出结果是
（分数：2.00）
A.7，5，7，3，3，3，
B.7，5，7，3，5，7，
C.7，5，5，3，3，3，√
D.7，7，5，3，3，3，
解析：解析：本题考查二级指针作为函数的参数，可以通过函数调用来改变主函数中一级指针的指向。主函数中指针变量p指向i，r指向p，调用f函数，形参指针s指向p，流程转到f函数执行，指针变量t 指向k，s指向t，此时更改了s的指向，s指向了t，更改了s指向的地址空间内容为m的地址，同时t
也指向变量m，因此**s的值为m的值，*t为m的值，k为7。流程返回到主函数，没有对主函数空间的数据和指向作出更改，因此全部为3。
9.若有以下程序 #include int*f(int*s，int*t){int k； if(*s
（分数：2.00）
A.3，5，5，3，5
B.3，5，3，5，5
C.5，3，5，3，5 √
D.5，3，3，5，5
解析：解析：函数f为返回值为指针的函数，主要功能是返回s和t指向空间值大的数据的地址，同时如何s指向空间数据大于t指向空间的数据，那么交换。主函数p和q指向i和j，值为3和5．i的值人于i的值，因此调用函数f以后，返回j的地址，r指向j，同时i和．j的值交换，i=5，j=3，p和q的指向不变，p指向i，q指向j。
10.有以下程序#include int funa(int a，int b){return a+b；} int funb(int a，int b){return a-b；} int sss(int(*t)()，int x，int y){return((*t)(x，y))；} main(){int x；x=sss(funa，9，3)；x+=sss(funb，8，3)； printf("％d＼n"，x)；} 程序运行后的输出结果是
（分数：2.00）
A.1 7 √
B.23
C.24
D.22
解析：解析：函数funa的功能计算两个数据的和，funb的功能计算两个数据的差，函数sss中利用指向函数的指针作为函数的参数，可以在调用的时候，根据接收的函数地址来决定调用那一个函数。主函数中调用x=sss(funa，9，3)，将funa函数的地址传递给t，因此sss函数成为求两个数据的和12，继续将funb 函数地址传给t，求两个数据差为5，和s累加后结果为17。
11.有以下程序void fun(int x，int y，int*c，int*d) {*c=x+y；*d=x-y；} main(){int a=4，b=3，c=0，d=0； fun(a，b，&c，&d)； printf("％d％d＼n"，c，d)；} 程序的输出结果是
（分数：2.00）
A.4 3
B.3 4
C.7 1 √
D.0 0
解析：解析：函数fun有四个形参，功能是利用参数的地址传递来计算前两个参数的和与差。主函数中调用fun函数c计算4+3，d计算4-3值为1。
12.有以下程序 void fun(int*p，int*q){int t；t=*p；*p=*q；*q=t；*q=*p；} main(){int a=0，b=9；fun(&a，&b)； printf("％d％d＼n"，a，b)；} 程序的输出结果是
（分数：2.00）
A.0 0
B.9 9 √
C.9 0
D.0 9
解析：解析：函数fun的主要功能是交换p和q指向的地址空间的数据，然后更改p的指向的地址空间数据，使之和q指向的数据相同。主函数调用fun后，p指向a，q指向b，因此a和b的数据全部为9。13.有以下程序char fun(char*c){if(*c<='Z'&&*c>='A') *c-='A'-'a'；return*c；} main(){char s[81]，*p=s； gets(s)； while(*p)( *p=fun(*)； putchar(*p)； p++；} printf("＼n")；} 若运行时从键盘上输入OPEN THE DOOR，程序的输出结果是
（分数：2.00）
A.oPEN tHE dOOR
B.open the door √
C.OPEN THE DOOR
D.Open The Door
解析：解析：函数fun的主要功能是判断字符是否为大写字符，如果是则转换为小写字符，主函数读入大写字符串，转换成小写。
14.有以下程序 void swap(char*x，char*y) main() {char t； { char*s1="abc"，*s2="123"； t=*x；*x=*y；*y=t； swap(s1，s2)；printf("％s，％s＼n"，s1，s2)； } } 程序执行后的输出结果是
（分数：2.00）
A.abc，123
B.123，abc
C.321，cba
D.1bc，a23 √
解析：解析：函数void swap(char*x，char*y)的功能是交换两个字符*x和*y中的内容。在主函数中字符指针s1指向字符串'abc'，s2指向字符串'123'。所以函数swap(s1，s2)的执行结果就是字符'a'和'1'相
互交换。
15.有以下函数int fun(char*x．char*y){int n=0；while((*x==*y)&&*x!='＼0'){ x++；y++；n++；} return n；} 函数的功能是
（分数：2.00）
A.查找x和y所指字符串中是否有'＼0'
B.统计x和y所指字符串中最前面连续相同的字符个数√
C.将y所指字符串赋给x所指存储空间
D.统计x和y所指字符串中相同的字符个数
解析：解析：在while循环中的判断表达式为(*x==*y)&&*x!='＼0'，所以只要字符串x与y的当前字符不相等时，循环就结束。
16.有以下函数int fun(char*s){char*t=s；while(*t++)；return(t-s)；}该函数的功能是
（分数：2.00）
A.比较两个字符串的大小
B.计算s所指字符串的长度
C.计算s所指字符串占用内存字节的个数√
D.将s所指字符串复制到字符串t中
解析：解析：在函数fun(char*s)中，首先用字符指针变量t指向s，而循环语句while(*t++)；的功能是使指针变量t指向字符串变量s的末尾，这时退出循环，因而语句return(t-s)；返回的就是字符串s所
指字符串的长度。
17.有以下程序(说明：字母A的ASCII码值是65) void fun(char*s){while(*s){ if(*s％2) printf("％c"，*s)；s++；}} main(){char a[]="BYTE"； fun(a)；printf("＼n")；} 程序运行后的输出结果是
（分数：2.00）
A.BT
B.YE √
C.YT
D.BY
解析：解析：程序只输出字母ASCII值为奇数的字母，根据字母B，Y，T，E的ASCII值的奇偶性相应输出。18.有以下程序#include void fun(char**p) {++p；printf("％s＼n"，*p)；} main() {char*a[]=("Morning"，"Afternoon"，"Evening"，"Night")； fhn(a)；} 程序的运行结果是
（分数：2.00）
A.fternoon
B.Morning
C.orning
D.Afternoon √
解析：解析：在程序中，指针的指针变量a和p都是指向字符串的指针。执行fun(a)语句时，p指向的是
字符串数组a的第一个字符串“Morning”，p自加1之后，*p指向了字符串数组a的第2个字符串“Afternoon”。
19.有以下程序 void fun1(char*p) main() {char*q； {char a[]={"Program")，*p； q=p； p=&a[3]；fun1(p)；printf("％s＼n"，a)； while(*q!='＼0') } {(*q)++；q++；}} 程序执行后的输出结果是
（分数：2.00）
A.Prphsbn
B.Prohsbn √
C.Progsbn
D.Program
解析：解析：在函数void funl(char*p)中，语句(*q)++的功能是q所指的字符加1，变成其后面的字符；q++就是指针q指向下一个字符的位置。所以在主函数中，语句p=&a[3]的作用是使指针p指向字符数组a[]中的第四个字符的位置，即p指向字符'g'；然后调用函数：fun1(p)后，字符'g'变成'h'，字符'r'变成's'，字符'a'变成'b'，字符'm'变成'n'，因而字符数组a[]中的内容就成“Prohsbn”。
20.有以下程序 #include main() void fun(char*a，char*b) {char*s="*****a*b*****"，t[80]；{while(*a=='*')a++； fun(s，t)；puts(t)； while(*b=*a){b++；a++；}} } 程序的运行结果是
（分数：2.00）
A.a*b
B.*****a*b
C.a*b**** √
D.ab
解析：解析：主函数main()定义了指向字符串的指针和一个字符数组，接着调用fun(s，t)函数，进行实参向形参传递，函数fun()第一个while语句判断*a中的值为“*”时继续扫描，当遇到不是“*”时结束，接着第二个while循环语句，将*a中从“a”开始的后续所有字符都赋予*b，也就是t[80]中的内容为
“a*b****”。
21.下列函数的功能是void fun(char*a，char*b){while((*b=*a)!='＼0'){a++；b++；}}
（分数：2.00）
A.使指针b指向a所指字符串
B.将a所指字符串和b所指字符串进行比较
C.将a所指字符串赋给b所指空间√
D.检查a和b所指字符串中是否有'＼0'
解析：解析：在while语句的条件中是把字符*a的值赋给字符*b，然后再判断字符*b的值是否等于字符串的结束字符('＼0')，当不等于结束字符('＼0')时，把字符指针变量a，b分别加1，指它们的下一个字符，直到字符串a的结束。这样程序执行的结果就是把字符串a赋给了b所指的存储空间。
22.有以下程序 #include #include void fun(char s[][10]，int n) {char t；int i，j； for(i=0；
is[j][0]){t=s[i][0]；s[i][0]=s[j][0]；s[j][0]=t；}} main() {char ss[5][10]={"bcc"，"bbcc"，"xy"，"aaaacc"，"aabcc"}； fun(ss，5)；printf("％s，％s＼n"，ss[0]，ss[4])；} 程序的运行结果是
（分数：2.00）
A.aaaacc，xy
B.bcc，aabcc
C.xy，aaaacc √
D.aabcc，bcc
解析：解析：函数fun(char s[][10]，int n)通过两重for循环语句，比较二维字符数组s[][10]的每个字符串的首字符大小，如果前一个字符串首字符大于后一个字符串的首字符，则交换这两个字符串的首字符。在主函数中，语句fun(ss，5)的作用是对二维字符数组ss[5][10]的5个字符串的首字符进行从小到大的排序，不影响各个字符串另外的字符。所以排序结束后，5个字符串的第一个字符依次变为a、a、b、b和x；最后输出第1个和第4个字符串。
23.有以下程序 #include main() void fun(char*t，char*s) {char ss[10]="acc"，aa[10]="bbxxyy"；{while(*t!=0)t++； fun(ss，aa)；printf("％s，％s＼n"，ss，aa)； while((*t++=*s++)!=0)；} } 程序的运行结果是
（分数：2.00）
A.acc，bbxxyy
B.accxxyy，bbxxyy
C.accbbxxyy，bbxxyy √
D.accxyy，bbxxyy
解析：解析：fun函数中，第1个while循环语句使指针t指向字符串的末尾，第2个while循环语句实现了字符串t和s的连接。主函数中语句fun(ss，aa)的功能是将字符串aa连接到字符串ss的末尾。24.有以下程序#include #include void fun(char*w，int m) {char s，*p1，*p2；p1=w；p2=w+m-1；while(p1 （分数：2.00）
A.116611
B.161616
C.654321 √
D.123456
解析：解析：函数。fun的功能是将字符串w中的元素从大到小进行排列，所以在主函数中调用函数fun 后，字符串a的元素从大到小进行了排列。
25.有以下程序： #include int b=2； int fun(int*k) {b=*k+b；return(b)；} main() {int a[10]={1，2，3，4，5，6，7，8}，i； for(i=2；i
（分数：2.00）
A.8 10
B.10 28 √
C.10 12
D.10 16
解析：解析：i=2时，fun(&a[2])返回值是b=b+a[1]=2+3=5，b=b+b=5+5=10；i=3时，fun(&a[3])返回值是b=b+a[3]=10+4=14，b=b+b=14+14=28。
26.有以下程序#include #include void fun(int*p1，int*p2，int*s){ s=(int*)calloc(1，sizeof(int))；*s=*p1+*p2；free(s)；} main(){ int a[2]={1，2}，b[2]={40，50}，*q=a；fun(a，b，q)；pfintf("％d＼n"，*q)；} 程序运行后的输出结果是
（分数：2.00）
A.41 √
B.42
C.0
D.1
解析：解析：主函数定义数组a，b，q指向数组a，调用tun函数以后形参接收实参的数据，p1和p2指向数组a和b，同时s指向数组a，在fun函数中改变了s的指向和赋值，但是在程序调用结束之间形参空间全部释放，因此对于s的指向改动不会对主函数参数构成影响。因此主函数中数去*q的值仍然为1。
C语言习题集(预处理命令篇)
第六章预处理命令 6．1 选择题 1．下面叙述中正确的是（）。 A. 带参数的宏定义中参数是没有类型的 B. 宏展开将占用程序的运行时间 C. 宏定义命令是C语言中的一种特殊语句 D. 使用#include命令包含的头文件必须以“.h”为后缀 2．下面叙述中正确的是（）。 A. 宏定义是C语句，所以要在行末加分号 B. 可以使用#undef命令来终止宏定义的作用域 C. 在进行宏定义时，宏定义不能层层嵌套 D. 对程序中用双引号括起来的字符串内的字符，与宏名相同的要进行置换 3．在“文件包含”预处理语句中，当#include后面的文件名用双引号括起时，寻找被包含文件的方式为（）。 A. 直接按系统设定的标准方式搜索目录 B. 先在源程序所在目录搜索，若找不到，再按系统设定的标准方式搜索 C. 仅仅搜索源程序所在目录 D. 仅仅搜索当前目录 4．下面叙述中不正确的是（）。 A. 函数调用时，先求出实参表达式，然后带入形参。而使用带参的宏只是进行简单的 字符替换 B. 函数调用是在程序运行时处理的，分配临时的内存单元。而宏展开则是在编译时进 行的，在展开时也要分配内存单元，进行值传递 C. 对于函数中的实参和形参都要定义类型，二者的类型要求一致，而宏不存在类型问 题，宏没有类型 D. 调用函数只可得到一个返回值，而用宏可以设法得到几个结果 5．下面叙述中不正确的是（）。 A. 使用宏的次数较多时，宏展开后源程序长度增长。而函数调用不会使源程序变长 B. 函数调用是在程序运行时处理的，分配临时的内存单元。而宏展开则是在编译时进 行的，在展开时不分配内存单元，不进行值传递 C. 宏替换占用编译时间 D. 函数调用占用编译时间 6．下面叙述中正确的是( )。 A. 可以把define和if定义为用户标识符 B. 可以把define定义为用户标识符，但不能把if定义为用户标识符 C. 可以把if定义为用户标识符，但不能把define定义为用户标识符 D. define和if都不能定义为用户标识符 7．下面叙述中正确的是（）。 A.#define和printf都是C语句 B.#define是C语句，而printf不是 C.printf是C语句，但#define不是 D.#define和printf都不是C语句
C语言13章习题
C语言1-3章习题(部分) 一、判断题 1、C程序的注释部分可以出现在程序的任何位置,它对程序的编译与运行不 起任何作用。但就是可以增加程序的可读性。(√ ) 2、自增运算符(++)或自减运算符(--)只能用于变量,不能用于常量或表达式。 ( √) 3、c程序可由若干个源程序文件组成。( √) 4、宏替换时先求出实参表达式的值,然后代入形参运算求值。(×) 5、用%s格式符输出字符串时,输出字符不包括结束符’\0’。(√ ) 6、#define指令就是一个预处理编译器指令,不就是程序语句,因此,#define不 能用分号结尾。(√ ) 7、一个程序应包括对数据的描述与对操作的描述,其中对数据的描述也就就 是算法。(× ) 8、在C程序中对用到的所有数据都必须指定其数据类型。(√ ) 9、一个实型变量的值肯定就是精确的。(× ) 10、do-while循环的while后的分号可以省略。(× ) 11、c语言中函数定义不允许嵌套,但调用可嵌套。(√ ) 12、与其她语句一样,预处理命令必须以分号结尾。(× ) 13、在一个源程序中,main函数的位置必须在最开始。(×) 14、函数可以调用自己。(√) 15、scanf函数一次只能读取一个值。 (×) 16、一个函数中可以有一个以上的return语句,执行到哪一个return语句,哪一 个语句起作用。(√) 17、字符串“a”只包含1个字符。( ×) 18、在C语言中,要求对所有用到的变量作强制定义,也就就是“先定义,后使 用”。( √) 19、C程序中,函数的定义可以嵌套,但函数的调用不可以嵌套。(×) 20、C程序中,无论就是整数还就是实数,都能被准确无误地表示。(×) 21、一个C源程序中有且仅有一个main()函数。(√) 22、语句可以用分号或句号结尾。(×)
C语言预处理命令之条件编译(#ifdef,#else,#endif,#if等)
C语言预处理命令之条件编译（#ifdef,#else,#endif,#if等） 预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理。 在C语言中，并没有任何内在的机制来完成如下一些功能：在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行响应的转换。预处理过程还会删除程序中的注释和多余的空白字符。 预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令： 指令用途 #空指令，无任何效果 #include包含一个源代码文件 #define定义宏 #undef取消已定义的宏 #if如果给定条件为真，则编译下面代码 #ifdef如果宏已经定义，则编译下面代码 #ifndef如果宏没有定义，则编译下面代码 #elif如果前面的#if给定条件不为真，当前条件为真，则编译下面代码 #endif结束一个#if……#else条件编译块 #error停止编译并显示错误信息 一、文件包含 #include预处理指令的作用是在指令处展开被包含的文件。包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。标准C编译器至少支持八重嵌套包含。 预处理过程不检查在转换单元中是否已经包含了某个文件并阻止对它的多次包含。这样就可以在多次包含同一个头文件时，通过给定编译时的条件来达到不同的效果。例如： #defineAAA #include"t.c" #undefAAA #include"t.c" 为了避免那些只能包含一次的头文件被多次包含，可以在头文件中用编译时条件来进行控制。例如： /*my.h*/ #ifndefMY_H
(完整版)C语言8~13章复习题
第八章函数 一、选择题 1、以下正确的函数定义是（A ） A) double fun(int x,int y) { } B) double fun(int x;int y) { } C) float fun(int x;y) { } D) float fun(int x,y) { } 2、C语言中，函数返回值的类型是由（ D ）决定。 A）主调函数的类型 B）return语句中表达式的类型 C）由系统临时指定 D）定义该函数时所指定的函数类型 3、下列有关函数的说法正确的是（ D ）。 A)在C语言中，若对函数类型未加说明，则系统隐含类型为void。 B)C函数必须有返回值，否则无法使用。 C)C函数既可以嵌套定义，又可以可递归调用。 D)C函数中，形式参数必须指定为确定的类型。 4、用一维数组名作函数的实际参数，则传递给形式参数的是（A ） A)数组首元素的地址 B)数组中第一个元素的值 C)数组中元素的个数 D)数组中全部元素的值 5、若已定义的函数有返回值，则有关该函数调用的叙述中错误的是（B ） A)调用可以作为独立的语句存在 B)调用可以作为一个函数的形参 C)调用可以作为一个函数的实参 D)调用可以出现在表达式中 6、关于C语言中return语句正确的说法是（C ） A)只能在主函数中出现 B)在每个函数中都必须出现 C)可以在一个函数中出现多次 D)只能在除主函数之外的函数中出现 7、如果在程序中使用了C库函数中的字符串函数，则应在源程序中使用的文件包含命令是（D ） A)#include
c语言第8章编译预处理及位运算习题答案.doc
编译预处理习题 一．单项选择题 1.在宏定义#define A 3.897678中，宏名A代替一个（）。 A）单精度数 B）双精度数 C）常量 D）字符串 2.以下叙述中正确的是 A）预处理命令行必须位于源文件的开头 B）在源文件的一行上可以有多条预处理命令C）宏名必须用大写字母表示D）宏替换不占用程序的运行时间 3.C语言的编译系统对宏命令的处理（）。 A）在程序运行时进行的 B）在程序连接时进行的 C）和C程序中的其它语句同时进行的 D）在对源程序中其它语句正式编译之前进行的 4.在文件包含预处理语句的中，被包含文件名用“< >”括起时，寻找被包含文件的方式 是（）。 A）直接按系统设定的标准方式搜索目录 B）先在源程序所在目录搜索，再按系统设定的标准方式搜索 C）仅仅在源程序所在目录搜索 D）仅仅搜索当前目录 5.以下说法中正确的是 A）#define和printf都是C语句 B）#define是C语句，而printf不是 C）printf是C语句，但#define不是D）#define和printf都不是C语句 6.#define A 3.897678 #include
编译预处理
第九章编译预处理 9.1 选择题 【题9.1】以下叙述中不正确的是。 A）预处理命令行都必须以#号开始 B）在程序中凡是以#号开始的语句行都是预处理命令行 C）C程序在执行过程中对预处理命令行进行处理 D）以下是正确的宏定义 #define IBM_PC 【题9.2】以下叙述中正确的是。 A）在程序的一行上可以出现多个有效的预处理命令行 B）使用带参的宏时，参数的类型应与宏定义时的一致 C）宏替换不占用运行时间，只占编译时间 D）在以下定义中C R是称为“宏名”的标识符 #define C R 045 【题9.3】请读程序： #define ADD(x) x+x main() { int m=1,n=2,k=3; int sum=ADD(m+n)*k; printf(“sum=%d”,sum); } 上面程序的运行结果是。 A）sum=9 B）sum=10 C）sum=12 D）sum=18 【题9.4】以下程序的运行结果是。 #define MIN(x,y) (x)<(y)?(x):(y) main() { int i=10,j=15,k; k=10*MIN(i,j); printf(“%d\n”,k); } A）10 B）15 C）100 D）150 【题9.5】在宏定义#define PI 3.14159中，用宏名PI代替一个。 A）常量B）单精度数C）双精度数D）字符串
【题9.6】以下程序的运行结果是。 #include
《二级C语言程序设计》章节题库(编译预处理和动态存储分配)【圣才出品】
第13章编译预处理和动态存储分配 1．以下叙述中正确的是（）。 A．在C语言中，预处理命令行都以“#”开头 B．预处理命令行必须位于C源程序的起始位置 C．#include
【解析】通常，预处理命令位于源文件的开头，也可以写在函数与函数之间。答案选择A选项。 3．以下关于宏的叙述中正确的是（）。 A．宏名必须用大写字母表示 B．宏定义必须位于源程序中所有语句之间 C．宏替换没有数据类型限制 D．宏调用比函数调用耗费时间 【答案】C 【解析】A项错误，在C语言中，宏名可以是任何合法的C语言标识符，只不过通常习惯用大写字母；B项错误，宏可以根据需要出现在程序的任何一行的开始部位；D项错误，宏定义是“编译预处理”命令，它们的替换过程在编译时期就已经完成了，因此不会占有程序运行的时间。答案选择C选项。 4．以下关于宏的叙述错误的是（）。 A．宏替换不具有计算功能 B．宏是一种预处理指令 C．宏名必须用大写字母构成 D．宏替换不占用运行时间 【答案】C 【解析】宏名习惯采用大写字母，以便与一般变量区别，但是并没有规定一定要用大写字母，答案选择C选项。
C语言程序设计教案 第九章 编译预处理
第九章编译预处理 课题：第九章编译预处理 教学目的:1、了解预处理的概念及特点 2、掌握有参宏与无参宏的定义及使用，领会文件包含的使用及效果 教学重点：教学难点：掌握宏的使用，文件包含有参宏与无参宏的使用 步骤一复习引导 ANSI C标准规定可以在C源程序中加入一些“预处理命令”，以改进程序设计环境，提高编程效率。 这些预处理命令是由ANSI C统一规定的，但它不是C语言本身的组成部分，不能直接对它们进行编译。必须在对程序进行通常的编译之前，先对程序中这些特殊的命令进行“预处理”，即根据预处理命令对程序作相应的处理。经过预处理后程序不再包括预处理命令了，最后再由编译程序对预处理后的源程序进行通常的编译处理，得到可供执行的目标代码。 步骤二讲授新课 C语言与其他高级语言的一个重要区别是可以使用预处理命令和具有预处理的功能。C 提供的预处理功能主要有以下三种：宏定义、文件包含、条件编译。 分别用宏定义命令、文件包含命令、条件编译命令来实现。为了与一般C语句相区别，这些命令以符号“ #” 开头。 §9.1宏定义 宏：代表一个字符串的标识符。 宏名：被定义为“宏”的标识符。 宏代换(展开)：在编译预处理时，对程序中所有出现的“宏名”，用宏定义中的字符串去代换的过程。 一、不带参数的宏定义 一般形式：#define 标识符字符串 #define PI 3.1415926 main() { float l, s, r, v; printf( “input radius:” ); scanf( “%f”, &r ); l = 2.0*PI*r; s = PI*r*r; v = 3.0/4*PI*r*r*r; printf(“%10.4f,%10.4f,%10.4\n”, l, s, v); }
C语言条件编译及编译预处理阶段
C语言条件编译及编译预处理阶段 一、C语言由源代码生成的各阶段如下： C源程序－>编译预处理－>编译－>优化程序－>汇编程序－>链接程序－>可执行文件其中编译预处理阶段，读取c源程序，对其中的伪指令（以#开头的指令）和特殊符号进行处理。或者说是扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。预处理过程先于编译器对源代码进行处理。 在C 语言中，并没有任何内在的机制来完成如下一些功能：在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行响应的转换。预处理过程还会删除程序中的注释和多余的空白字符。 二、伪指令（或预处理指令）定义 预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令： 指令用途 # 空指令，无任何效果 #include 包含一个源代码文件 #define定义宏 #undef取消已定义的宏 #if如果给定条件为真，则编译下面代码 #ifdef 如果宏已经定义，则编译下面代码 #ifndef 如果宏没有定义，则编译下面代码 #elif如果前面的#if给定条件不为真，当前条件为真，则编译下面代码， 其实就是elseif的简写 #endif结束一个#if……#else条件编译块 #error停止编译并显示错误信息 三、预处理指令主要包括以下四个方面： 1、宏定义指令 宏定义了一个代表特定内容的标识符。预处理过程会把源代码中出现的宏标识符替换成宏定义时的值。宏最常见的用法是定义代表某个值的全局符号。宏的第二种用法是定义带参数的宏（宏函数），这样的宏可以象函数一样被调用，但它是在调用语句处展开宏，并
2012-2013学年第二学期C++程序设计复习提纲
一、选择题 1.下列关于对象的描述中，错误的是___________。 A.对象是类的别名 B.对象是类的实例 C.一个类可以定义多个对象 D.对象之间通过消息进行通信 2.在对字符数组进行初始化时，___________是正确的。 A.char s1[]=”abcd”； B.char s2[3]=”xyz”； C.char s3[][3]={‘a’，‘x’，‘y’}； D.char s4[2][3]={”xyz”，”mnp”}； 3.联合成员的地址值和所占的字节数___________。 A.都相同 B.都不同 C.前者相同，后者不同 D.前者不同，后者相同 4.文件包含命令中被包含的文件的扩展名___________。 A.必须为.h B.不能用.h C.必须是.c D.不一定是.h 5.下列while循环的次数是___________。 while(int i=0) i--； A.0 B.1 C.5 D.无限 6.在函数说明中，下列___________项是不必要的。 A.函数的类型 B.函数参数类型和名字 C.函数名字 D.返回值表达式 7.在传值调用中，要求___________。 A.形参和实参类型类型任意，个数相等 B.实参和形参类型都完全一致，个数相等 C.实参和形参对应的类型一致，个数相等 D.实参和形参对应的类型一致，个数相等 8.在一个函数中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用_____比较合适。 A.内联函数 B.重载函数 C.递归调用 D.嵌套调用 9.下列有关对函数模板参数的描述，错误的是___________。 A.函数模板是一组函数的样板 B.函数模板是定义重载函数的一种工具 C.模板函数是函数模板的一个实例 D.模板函数在编译时不生成可执行代码 10.下列各种函数中，___________不是类的成员函数。 A.构造函数 B.析构函数 C.友元函数 D.复制构造函数 11.___________不是构造函数的特征。 A.构造函数的函数名与类名相同 B.构造函数可以重载 C.构造函数可以设置默认参数 D.构造函数必须指定类型说明 12.下述静态数据成员的特性中，___________是错误的。 A.说明静态数据成员时前边要加修饰符static B.静态数据成员要在类体外进行初始化 C.引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符 D.静态数据成员不是所有对象所共用的 13.关于delete运算符的下列描述中，___________是错误的。 A.它必须用于new返回的指针 B.它也适用于空指针 C.对一个指针可以使用多次该运算符 D.指针名前只用一对方括号符，不管所删除数组的维数 14.派生类的构造函数的成员初始化值表中，不能包含___________。 A.基类的构造函数 B.派生类中子对象的初始化 C.派生类中静态数据成员的初始化 D.派生类中一般数据成员的初始化 15.下列运算符中，在C++语言中不能重载的是_______________。 A. * B. >= C. :: D. / 16.下列关于面向对象语言的基本要素的描述中，正确的是___________。 A.封装性和重载性 B.多态性和继承性 C.继承性和聚合性 D.封装性和继承性 17.在int b[][3]={{1}，{3，2}，{4，5，6}，{0}}；中b[2][2]的值是___________。 A.0 B.5 C.6 D.2 18.下列各运算符中，___________运算的结合性是从左到右。 A.三目 B.赋值 C.比较 D.单目 19.预处理命令在程序中都是以___________开关的。 A. * B. # C. ： D. / 20.下列for循环的次数为___________。 for(int i(0)，x=0；!x&&i<=5；i++)；
NOIP复赛复习13预处理与前缀和
NOIP复赛复习13预处理与前缀和 一、预处理 所谓预处理，顾名思义，就是事先计算好需要的值或事先处理某些东西，有时候你会发现你做一个题目出现了TLE，原因就是重复的计算会导致效率不高（或者说你的预处理不够“优雅”）。 A、直接把结果预处理 XTUOJ 1052 题意：某一个数字集合定义如下： 1.0属于这个集合； 2.如果x属于这个集合，那么2x+1,3x+1也属于这个集合； 3.集合只包含按增序排列的前100000个元素。 集合按增序排列，根据输入的元素序号，输出对应的元素值。 输入 每行一个整数n（n<100000），表示元素的序号（从0开始记数），如果是-1，则输入结束。 输出 每行输出对应元素的值。 Sample Input 1 2
3 4 5 -1 Sample Output 1 3 4 7 9 分析：很明显，不能也不好直接判断是否存在于这个集合中，只需要把所有存在于这个集合中标记，并且预处理这些元素的序号，之后输出就行了，那么一次预处理便可以知道所有序号对应的元素了。 #include
b[0] = 1; for (i = 0; i < MAX; i++) if (b[i] == 1) b[2*i+1] = b[3*i+1] =1; for (i = 0, j = 0; i < 100000; j++) if (b[j] == 1) a[i++] = j; while (cin >> n, n != 1) cout <
程序设计试卷13
一、单项选择题（总分21） 1. （分值：1.0 分）若有以下定义和语句： int s[4][5],(*p)[5]; p=s; 则指针对s 数组中第三个元素的正确引用形式是（）。 A: p[0][3] B: p[1][2] C: p[0][2] D: p[1][3] 序号：92 难度：1 考查点：指针 2. （分值：1.0 分）定义整型变量x,y,z 并赋初始值6 的正确语句是__________。 A: int x=y=z=6; B: int x=6,y=6,z=6; C: x=y=z=6; D: int x,y,z=6; 序号：113 难度：1 考查点：C++基础知识 3. （分值：1.0 分）下列描述中哪个是正确的__________。 A: 私有派生的子类无法访问父类的成员 B: 类A 的私有派生子类的派生类C 无法初始化其祖先类A 对象的属性，因为类A 的成员对类C 是不可访问的 C: 私有派生类不能作为基类派生子类 D: 私有派生类的所有子孙类将无法继续继承该类的成员 序号：126 难度：1 考查点：继承与派生 4. （分值：1.0 分）34 A: 1 B: 2 C: 3 D: 4 序号：140 难度：1 考查点：数组 5. （分值：1.0 分）有以下函数： 一、判断题 1.C语言中，为了区别一般的变量，符号常量必须用大写字母表示。错 2.C语言中，强制类型转换后，原变量的值和数据类型不变。对 3.switch…case结构中条件表达式和常量表达式值可以为float类型。错 4.C语言中，do-while语句构成的循环只能用break语句退出。错 5.C语言中，数组元素的下标是从1开始的，下标不能越界。错 6.一个数组中的所有元素可以具有不相同的数据类型。错 7.C语言中，实参的个数、类型和位置必须与形参的定义一一对应。对 8.所有的函数调用前都必须进行函数原型说明。错 9.C语言通过文件指针对它所指向的文件进行操作。对 10.在程序运行过程中，可通过赋值语句改变常量的值。错 11.在一个循环体中，break和continue只能出现一次。错 12.C语言中，字符串以字符数组形式存放，且规定了用?\0?作为结束标记。对 13.常量、表达式可以做为函数的形参。错 14.C语言程序是函数体程序，main()是主函数。对 15.在程序运行过程中，可通过重定义改变变量的类型。错 16.在if语句中使用break，可退出选择结构。错 17.函数的递归调用同样适用于主函数main()。对 18.指针变量存放的是地址信息，所以对指针变量进行加、减等算术运算是没有意义的。错 19.C语言数据文件由二进制数据序列组成，C语言中能读写二进制文件。对 20.C语言中的文本文件以ASCII码形式存储数据。对 二、单项选择题 1.下面各选项中，均是C语言合法标识符的选项组是（B）。 A. 33 we auto B. _23 me _3ew C. _43 3e_ else D. ER -DF 32 2.若在定义语句：int a,b,c,*p=&c;之后，接着执行以下选项中的语句，则能正确执行的语句是（C）。 A. scanf("%d",&p); B. scanf("%d%d%d",a,b,c); C. scanf("%d",p); D. scanf("%d",a,b,c); 3.表达式：(int)((double)9/2)-(9)%2的值是（B ）。 A.0 B.3 C.4 D.5 4.以下程序段的描述，正确的是（C ）。 x=-1; do {x=x*x;} while（!x）; A. 是死循环 B. 循环执行两次 C. 循环执行一次 D. 有语法错误 5.在下述程序中，判断i>j共执行的次数是（D ）。 main（） { int i=0, j=10, k=2, s=0; for （;;） { i+=k; if（i>j） { printf（"%d",s）； break; C语言预处理命令总结大全 (2012-02-13 17:18) 标签: C语言预处理分类：C编程 C程序的源代码中可包括各种编译指令，这些指令称为预处理命令。虽然它们实际上不是C语言的一部分，但却扩展了C程序设计的环境。本节将介绍如何应用预处理程序和注释简化程序开发过程，并提高程序的可读性。ANSI标准定义的C 语言预处理程序包括下列命令： #define，#error，＃include，#if，#else，#elif，#endif，#ifdef，#ifndef，#undef，#line，#pragma等。非常明显，所有预处理命令均以符号#开头，下面分别加以介绍。 一 #define 命令#define定义了一个标识符及一个串。在源程序中每次遇到该标识符时，均以定义的串代换它。ANSI标准将标识符定义为宏名，将替换过程称为宏替换。命令的一般形式为： #define identifier string 注意： 1该语句没有分号。在标识符和串之间可以有任意个空格，串一旦开始，仅由一新行结束。 2宏名定义后，即可成为其它宏名定义中的一部分。 3 宏替换仅仅是以文本串代替宏标识符，前提是宏标识符必须独立的识别出来，否则不进行替换。例如： #define XYZ this is a tes 使用宏printf("XYZ")；//该段不打印"this is a test"而打印"XYZ"。因为预编译器识别出的是"XYZ" 4如果串长于一行，可以在该行末尾用一反斜杠' \'续行。 #defineLONG_STRING"this is a very long\ string that is used as an example" 5 C语言程序普遍使用大写字母定义标识符。 6 用宏代换代替实在的函数的一大好处是宏替换增加了代码的速度，因为不 存在函数调用的开销。但增加速度也有代价：由于重复编码而增加了程序长度。 二 #error 命令#error强迫编译程序停止编译，主要用于程序调试。 #error指令使预处理器发出一条错误消息，该消息包含指令中的文本.这条指令的目的就是在程序崩溃之前能够给出一定的信息。 三 #include (1) 下面叙述错误的是（）。 A) “#define PRICE 30”命令的作用是定义一个与30等价的符号常量PRICE B) C源程序中加入一些预处理命令是为了改进程序设计环境，提高编程效率 C) “#include <>”命令的作用是在预处理时将文件中的实际内容代替该命令 D) 宏定义也是C语句，必须在行末加分号 (2) 若有定义：#define PI 3，则表达式PI*2*2的值为（）。 A) 4 B) 不确定 C) 12 D) 322 (3) 以下程序的运行结果是（）。 #define X a+b main( ) { int a=3,b=4,s1; s1=2*X; printf("%d\n",s1); } A) 8 B) 14 C) 10 D) 6 (4) 若有定义#define F 2+3，则表达式F*F的值为（）。 A) 13 B) 17 C) 25 D) 11 (5) 下面叙述正确的是（）。 A) 宏名必须用大写字母表示 B) 一个源程序只能有一个预编译处理命令行 C) 宏展开不占用运行时间，只占用编译时间 D) 预处理命令也是C语句，必须以分号结束 (6) 下列程序中定义的二维数组a的（）。 # define M 3 # define N 4 void main( ) { int a[M][N]; …… } A、第一维和第二维都为4 B、第一维和第二维都为3 C、第一维为4，第二维为3 D、第一维为3，第二维为4 (7) 下列程序的运行结果是（）。 # define M 5 # define N M+1 # define NN N*N-M void main( ) { printf(“%d\n”,3*NN); } A、108 B、16 C、21 D、103 (8) 下列叙述正确的是（）。 A、宏定义中的宏名必须用大写字母表示 B、为提高程序运行速度可在源程序中加入一些宏定义 C、一个C语言源程序只能有一条预处理命令 D、宏定义不占用程序运行时间，但与程序中的语句一样需要编译 (9) 下列叙述错误的是（）。 A、宏定义可出现在源程序中任意合适的位置，且必须在行末加分号 B、预处理命令行都必须以#号开始 C、C语言源程序中加入一些预处理命令是为了改进程序设计环境，提高编程效率 D、# define PER 的作用是用标识符PER代表 (10) 下列程序的运行结果是（）。 # define K 5 void main( ) { int a=3,b=4; printf(“%d\n”,K*(a+b)); } A、20 B、15 C、5 D、35 (11) 以下叙述正确的是（）。 A) 一个源程序只能由一个编译预处理命令行 B) 编译预处理命令都必须以"#"开头 C) "#define PRICE=30"定义了与30等价的符号常量PRICE 第12章 C 语言的编译预处理 C 语言属于高级语言，用C 语言编写的程序称为源程序，这种用高级语言编写的源程序 计算机是不能直接执行的，必须经过C 语言的编译系统把源程序编译成目标程序（机器指令构成的程序）并连接成可执行程序，计算机才可以执行。因此，用C 语言来处理问题，必须经过程序的编写→编译及连接→运行三个主要过程。然而，为了减少C 源程序编写的工作量，改善程序的组织和管理，帮助程序员编写易读、易改、易于移植、便于调试的程序，C 语言编译系统提供了预编译功能。 所谓的预编译功能是指：编译器在对源程序正式编译前，可以根据预处理指令先做一些 特殊的处理工作，然后将预处理结果与源程序一起进行编译。 C 语言提供的编译预处理功能主要有三种：文件包含、宏定义、条件编译。这三种功能 分别以三条编译预处理命令#include 、#define 、#if 来实现。编译预处理指令不属于C 语言的 语法范畴，因此，为了和C 语句区别开来，预处理指令一律以符号“#”开头，以“回车” 结束，每条预处理指令必须独占一行。 12.1 文件包含预处理 “包含”的英文单词为“include ”，所谓“文件包含”预处理，就是在源文件中通过“#include ”命令指示编译器将另一段源文件包含到本文件中来。 例如，源文件f1.c 中有一句“#include f2.c ”编译预处理命令，如图12-1(a)所示。编译预处理后文件f1.c 的完整结构如图12-1(c)所示。 图12-1 文件包含编译预处理命令 编译时先将f2.c （图12-1(b)）的内容复制嵌入到f1.c （图12-1(a)）中来，即进行“包含” 预处理，然后对调整好的完整的f1.c （图12-1(c)）进行编译，得到相应的目标代码。换句话说，由f1.c 和f2.c 组成程序的目标代码（.obj ）和用一个源文件（类似于图c ）的目标代码（.obj ）完全一样。但是用#include 包含f2.c 的方式编写程序可以使其他的程序重用f2.c 的代码，并且使源文件简洁明了。 “文件包含”指令有两种使用方式： 第一种形式，用尖括号（即小于号<、大于号>）括起被包含源文件的名称： #include <文件名> f1.c ……… ……… ……… ……………… ……………… ……………… ……………… ……………… ……………… #include f2.c ……………… ……………… ……………… ……………… ……………… ……………… f1.c (a) 预编译前 (b) (c) 预编译后 入门 TMS320C6000 优化编译程序 v 6.0 Beta 使用手册 文献编号: SPRU187N 2005年7月 入门 目录 序言 (13) 1 软件开发工具简介 (17) 1.1 软件开发工具概述.......................................................... ................ (18) 1.2 C/C++ 编译器概述 (20) 1.2.1 ISO 标准 (20) 1.2.2 输出文件 (20) 1.2.3 编译器界面 (20) 1.2.4 编译器操作 (21) 1.2.5 实用程序 (21) 1.3 Code Composer Studio 和编译器 (22) 2 使用 C/C++ 编译器 (23) 2.1 关于编译器 (24) 2.2 执行 C/C++ 编译器 (25) 2.3 设置选项改变编译器的行为 (26) 2.3.1 常用选项 (32) 2.3.2 机器特殊选项 (33) 2.3.3 选择目标CPU版本 (-mv 选项) (33) 2.3.4 符号调试和剖析选项 (34) 2.3.5 指定文件名 (34) 2.3.6 改变编译程序解释文件名的方式(-fa, -fc, -fg, -fl, -fo 和 -fp 选项) (35) 2.3.7 改变编译程序解释和命名扩展名的方式(-ea, -ec, -el, -eo, -ep 和 -es 选项) (36) 2.3.8 设置目录(-fb, -ff, -fr, -fs, and -ft Options) (36) 2.3.9 控制汇编器的选项 (37) 2.3.10 不推荐的选项 (38) 2.4 通过环境变量来控制编译器 (38) 2.4.1 设置默认的编译器选项 (C_OPTION 和 C6x_C_OPTION) (38) 2.4.2 设置备用目录名 (C_DIR 和 C6x_C_DIR) (39) 2.5 控制预处理器 (39) 2.5.1 预定义宏名 (40) 2.5.2 #include 文件的搜索目录 (40) 2.5.3 生成预处理列表文件 (-ppo 选项) (41) 2.5.4 预处理后继续编译 (-ppa 选项) (42) 2.5.5 生成带注释的预处理列表文件 (-ppc 选项) (42) 2.5.6 生成带行控制信息的预处理列表文件(-ppl 选项) (42) 2.5.7 为程序生成工具生成预处理输出文件 (-ppd 选项) (42) 2.5.8 生成包含#include伪指令的文件列表 (-ppi 选项) (42) 2.6 理解诊断信息 (42) 2.6.1 控制诊断 (44) 2.6.2 如何使用诊断抑制选项 (44) C语言预处理命令总结大全 标签: C语言预处理分类：C编程 C程序的源代码中可包括各种编译指令，这些指令称为预处理命令。虽然它们实际上不是C语言的一部分，但却扩展了C程序设计的环境。本节将介绍如何应用预处理程序和注释简化程序开发过程，并提高程序的可读性。ANSI标准定义的C语言预处理程序包括下列命令： #define，#error，＃include，#if，#else，#elif，#endif，#ifdef，#ifndef，#undef，#line，#pragma等。非常明显，所有预处理命令均以符号#开头，下面分别加以介绍。 一 #define 命令#define定义了一个标识符及一个串。在源程序中每次遇到该标识符时，均以定义的串代换它。ANSI标准将标识符定义为宏名，将替换过程称为宏替换。命令的一般形式为： #define identifier string 注意： 1该语句没有分号。在标识符和串之间可以有任意个空格，串一旦开始，仅由一新行结束。 2宏名定义后，即可成为其它宏名定义中的一部分。 3 宏替换仅仅是以文本串代替宏标识符，前提是宏标识符必须独立的识别出来，否则不进行替换。例如： #define XYZ this is a tes 使用宏printf("XYZ")；//该段不打印"this is a test"而打印"XYZ"。因为预编译器识别出的是"XYZ" 4如果串长于一行，可以在该行末尾用一反斜杠' \'续行。 #defineLONG_STRING"this is a very long\ string that is used as an example" 5 C语言程序普遍使用大写字母定义标识符。 6 用宏代换代替实在的函数的一大好处是宏替换增加了代码的速度，因为不存在函数调用 的开销。但增加速度也有代价：由于重复编码而增加了程序长度。 二 #error 命令#error强迫编译程序停止编译，主要用于程序调试。 #error指令使预处理器发出一条错误消息，该消息包含指令中的文本.这条指令的目的就是在程序崩溃之前能够给出一定的信息。 三 #include 命令＃i nclude使编译程序将另一源文件嵌入带有＃include的源文件，被读入的源文件必须用双引号或尖括号括起来。例如： ＃include"stdio.h"或者＃include
以下程序段中不能根据x 值正确计算出y 值的是（）。 A: if (x>0) y=1; else if (x==0) y=0; else y= -1; B: y=0;if (x>0) y=1; else if (x<0) y= -1; C: y=0; if (x>=0) if (x>0) y=1; else y= -1; D: if (x>=0) if (x>0) y=1; else y=0; else y= -1; 序号：195 难度：1 考查点：程序控制结构 6. （分值：1.0 分）下面哪一C++ 语言表达式不能正确表示数学关系a＜x≤b。选项为 __________。 A: a13本程序设计语言基础复习题
C语言预处理命令总结大全
预处理的考试试题
第12章 C语言的编译预处理
TMS320C6000 优化编译程序(中文版)
C语言预处理命令总结大全
- c语言编译预处理
- C语言预处理命令之条件编译
- C语言编程常见问题解答之编译预处理
- 3分钟弄懂c语言预处理
- C语言三种预处理功能
- C语言习题集(预处理命令篇)
- c语言编译预处理及位运算习题答案
- 第12章 C语言的编译预处理
- C语言编译预处理文件练习题
- c语言习题集合预处理命令)
- c语言预处理命令之条件编译(ifdefelseendifif等)
- c语言第8章 编译预处理及位运算习题答案
- C语言预处理命令总结大全
- C语音编译预处理练习题
- C语言三种预处理
- C语言条件编译及编译预处理阶段
- 大学计算机程序设计基础(C语言)--第7章编译预处理概论
- C语言预处理命令的总结大全
- C语言编译预处理命令
- c语言第8章编译预处理及位运算习题答案.doc