第9章 预处理命令
第9章预处理命令
宏定义不是Ｃ语句，所以不能在行尾加分号。如果加了分号则会连分号一起进行臵换。
可以用#undef命令终止宏定义的作用域。
对程序中用“”括起来的内容（即字符串内的字符），即使与宏名相同，也不进行臵换。宏定义只做字符替换，不分配内存空间。
宏名不是变量，不分配存储空间，也不能对其进行赋值。
在宏展开时，预处理程序仅对宏名作简单的字符串替换，不作任何检查。
在进行宏定义时，可以引用已定义的宏名
无参宏定义的一般格式：
#define 标识符字符串
将这个标识符（名字）称为“宏名”，在用预编译时将宏名替换成字符串的过程称为“宏展开”。#define是宏定义命令。
带参宏定义的一般格式：
#define 宏名(形参表)字符串
带参宏的调用和宏展开：
调用格式：宏名(实参表)；
宏展开(又称为宏替换)的方法：用宏调用提供的实参直接臵换宏定义中相应的形参，非形参字符保持不变。
定义有参宏时，宏名与左圆括号之间不能留有空格。否则，Ｃ编译系统会将空格以后的所有字符均作为替代字符串，而将该宏视为无参宏。
有参宏的展开，只是将实参作为字符串，简单地臵换形参字符串，而不做任何语法检查。
为了避免出错,可以在所有形参外，甚至整个字符串外，均加上一对圆括号。
如: #define S(r) 3.14*(r)*(r)
则：area=S(a+b); 展开后为: area=3.14*(a+b)*(a+b);
调用有参函数时，是先求出实参的值，然后再复制一份给形参。而展开有参宏时，只是将实参简单地臵换形参。函数调用是在程序运行时处理的，为形参分配临时的内存单元；而宏展开则是在编译前进行的，在展开时不分配内存单元，不进行值的传递，也没有“返回值”的概念。调用函数只可得到一个返回值，而用宏可以设法得到几个结果。
在有参函数中，形参都是有类型的，所以要求实参的类型与其一致；而在有参宏中，形参和宏名都没有类型，只是一个简单的符号代表，因此，宏定义时，字符串可以是任何类型的数据。
使用宏次数多时，宏展开后源程序变长，因为每展开一次都是程序增长，而函数调用不会使源程序变长。
宏替换不占用运行时间，只占编译时间。而函数调用则占用运行时间（分配单元、保留现场、值传递、返回）。
在程序中如果有带实参的宏，则按#define命令行中指定的字符串从左到右进行臵换。如果字符串中包含宏中的形参，则将程序语句中相应的实参（可以是常量、变量或表达式）代替形参。如果宏定义中的字符串中的字符不是参数字符，则保留。
通常如果调用库函数，则用< >,使用用户自己编写的文件，则用“”。两种格式的区别仅在于：
⑴使用“”：系统首先到当前目录下查找被包含文件，如果没找到，再到系统指定的“包
含文件目录”去查找。
⑵使用< >：直接到系统指定的“包含文件目录”（include）去查找。
预编译时不作任何检查。只有编译已被宏展开后的源程序时才会发现语法错误并报错。
通常情况下，源程序中所有的行都参加编译，但有时希望对其中一部分内容只在满足一定条件才进行编译，则需要用到条件编译。
（1）一般格式
＃ifdef 标识符
程序段1；
＃else
程序段2；
＃endif
它的作用是若指定的标识符已经被#define命令定义过，则在程序编译阶段编译程序段1，否则，编译程序段2.。其中，#else部分可以没有。
2）#ifndef 标识符
程序段1
#else
程序段2
#endif
它的作用是若指定的标识符未被#define命令定义过，则在程序编译阶段编译程序段1，否则，编译程序段2.。
（3）#if 表达式
程序段1
#else
程序段2
#endif
它的作用是当指定的表达式的值为真（非零），则在程序编译阶段编译程序段1，否则，编译程序段2.。
(1) 一个#include命令只能指定一个被包含文件，如果要包含ｎ个文件，要用ｎ个#include 命令。
(2) 如果文件１包含文件２，而在文件２中要用到文件３的内容，则可在文件１中用两个include命令分别包含文件２和文件３，而且文件３应出现在文件２之前，即在file1.c中定义。
(3) 在一个被包含文件中又可以包含另一个被包含文件，即文件包含是可以嵌套的。
(4) 在#include命令中，文件名可以用双撇号或尖括号括起来。
(5) 被包含文件（file2.h）与其所在的文件（即用#include命令的源文件file2.c），在预编译后已成为同一个文件（而不是两个文件）。因此，如果file2.h中有全局静态变量，它也在file1.h 文件中有效，不必用extern声明。
如果需要修改程序中常用的一些参数，可以不必修改每个程序，只需将这些参数放在一个头
文件中，在需要是修改头文件即可，但，被包含文件修改后，凡包含此文件的所有文件都要全部重新编译。
编译预处理
第九章编译预处理 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语言预处理命令之条件编译(#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
第九章 编译预处理
第九章编译预处理 一、单选题 1．以下对宏替换的叙述不正确的是 A）宏替换只是字符的替换B）宏替换不占运行时间 C）宏名无类型，其参数也无类型 D）带参的宏替换在替换时，先求出实参表达式的值，然后代入形参运算求值2．宏定义#define PI 3.14中的宏名PI代替 A)一个单精度实数）B)一个双精度实数 C)一个字符串 D)不确定类型的数 3．有以下宏定义 #define k 2 #define X(k) ((k+1)*k) 当C程序中的语句y = 2 * (K + X(5));被执行后， A)y中的值不确定 B)y中的值为65 C)语句报错 D)y中的值为34 4．以下程序的输出结果是 #define MIN(x, y) (x) < (y) ? (x) : (y) main() { int i , j, k; i = 10; j = 15; k = 10 * MIN(i, j); printf(“%d\n”, k); }
A）15 B）100 C）10 D）150 5．以下程序中的for循环执行的次数是 #define N 2 #define M N + 1 #define NUM (M + 1) * M / 2 main() { int i; for(i = 1; i <= NUM; i++); pritnf(“%d\n”, i ); } A）5 B）6 C）8 D）9 6．以下程序的输出结果是 #include “stdio.h” #define FUDGF(y) 2.84 + y #define PR(a) printf(“%d”, (int) ( a ) ) #define PRINT1(a) PR(a); putchar(‘\n’) main() { int x = 2; PRINTF1(FUDGF(5) * X); } A）11 B）12 C）13 D）15 7．以下程序的输出结果是 #define FMT “%d,” main()
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中的预处理命令是由ANSIC统一规定的，但它不是C语言的本身组成部分，不能直接对它们进行编译，因为编译程序无法识别它们。必须对程序进行通常的编译（包括词法和语法分析，代码生成，优化等）之前，先对程序中这些特殊的命令进行“预处理”，例如：如果程序中用#include命令包含一个文件“stdio.h”，则在预处理时，将stdio.h文件中的实际内容代替该命令。经过预处理后的程序就像没有使用预处理的程序一样干净了，然后再由编译程序对它进行编译处理，得到可供执行的目标代码。现在的编译系统都包括了预处理，编译和连接部分，在进行编译时一气呵成。我们要记住的是预处理命令不是C语言的一部分，它是在程序编译前由预处理程序完成的。 C提供的预处理功能主要有三种：宏定义，文件包含，条件编译。它们的命令都以“#”开头。 一，宏定义：用一个指定的标识符来代表一个字符串，它的一般形式为： #define 标识符字符串 #define PI 3.1415926 我们把标识符称为“宏名”，在预编译时将宏名替换成字符串的过程称为“宏展开”，而#define 是宏定义命令。 几个应该注意的问题： 1，是用宏名代替一个字符串，也就是做简单的置换，不做正确性检查，如把上面例子中的1写为小写字母l，预编译程序是不会报错的，只有在正式编译是才显示出来。 2，宏定义不是C语句，不必在行未加分号，如果加了分号则会连分号一起置换。 3，#define语句出现在程序中函数的外面，宏名的有效范围为定义命令之后到本源文件结束，通常#define命令写在文件开头，函数之前，作为文件的一部分，在此文件范围内有效。4，可以用#undef命令终止宏定义的作用域。如： #define PI 3.1415926 main(){ } #undef PI mysub(){ } 则在mysub中PI 不代表3.1415926。 5，在进行宏定义时，可以引用已定义的宏名，可以层层置换。 6，对程序中用双撇号括起来的字符串内的字符，即使与宏名相同，也不进行置换。 7，宏定义是专门用于预处理命令的一个专有名词，它与定义变量的含义不同，只做字符替换不做内存分配。 带参数的宏定义，不只进行简单的字符串替换，还进行参数替换。定义的一般形式为：#define 宏名（参数表）字符串 如：#define S(a,b) a*b,具体使用的时候是int area; area=(2,3); 对带参数的宏定义是这样展开置换的：在程序中如果有带参数的宏（如area=(2,3)），则按#define命令行中指定的字符串从左到右进行置换。如果串中包含宏中的形参（如a,b），则将程序语句中的相关参数（可以是常量，变量，或表达式）代替形参。如果宏定义中的字符串中的字符不是参数字符（如上*），则保留，这样就形成了置换的字符串。 带参数的宏与函数有许多相似之处，在调用函数时也是在函数名后的括号内写实参，也要求实参与形参的数目相等，但它们之间还有很大的不同，主要有： 1，函数调用时，先求出实参表达式的值，然后代入形参，而使用带参的宏只是进行简单的字符替换。
第9章 预处理命令
第9章预处理命令 宏定义不是Ｃ语句，所以不能在行尾加分号。如果加了分号则会连分号一起进行臵换。 可以用#undef命令终止宏定义的作用域。 对程序中用“”括起来的内容（即字符串内的字符），即使与宏名相同，也不进行臵换。宏定义只做字符替换，不分配内存空间。 宏名不是变量，不分配存储空间，也不能对其进行赋值。 在宏展开时，预处理程序仅对宏名作简单的字符串替换，不作任何检查。 在进行宏定义时，可以引用已定义的宏名 无参宏定义的一般格式： #define 标识符字符串 将这个标识符（名字）称为“宏名”，在用预编译时将宏名替换成字符串的过程称为“宏展开”。#define是宏定义命令。 带参宏定义的一般格式： #define 宏名(形参表)字符串 带参宏的调用和宏展开： 调用格式：宏名(实参表)； 宏展开(又称为宏替换)的方法：用宏调用提供的实参直接臵换宏定义中相应的形参，非形参字符保持不变。 定义有参宏时，宏名与左圆括号之间不能留有空格。否则，Ｃ编译系统会将空格以后的所有字符均作为替代字符串，而将该宏视为无参宏。 有参宏的展开，只是将实参作为字符串，简单地臵换形参字符串，而不做任何语法检查。 为了避免出错,可以在所有形参外，甚至整个字符串外，均加上一对圆括号。 如: #define S(r) 3.14*(r)*(r) 则：area=S(a+b); 展开后为: area=3.14*(a+b)*(a+b); 调用有参函数时，是先求出实参的值，然后再复制一份给形参。而展开有参宏时，只是将实参简单地臵换形参。函数调用是在程序运行时处理的，为形参分配临时的内存单元；而宏展开则是在编译前进行的，在展开时不分配内存单元，不进行值的传递，也没有“返回值”的概念。调用函数只可得到一个返回值，而用宏可以设法得到几个结果。 在有参函数中，形参都是有类型的，所以要求实参的类型与其一致；而在有参宏中，形参和宏名都没有类型，只是一个简单的符号代表，因此，宏定义时，字符串可以是任何类型的数据。 使用宏次数多时，宏展开后源程序变长，因为每展开一次都是程序增长，而函数调用不会使源程序变长。 宏替换不占用运行时间，只占编译时间。而函数调用则占用运行时间（分配单元、保留现场、值传递、返回）。 在程序中如果有带实参的宏，则按#define命令行中指定的字符串从左到右进行臵换。如果字符串中包含宏中的形参，则将程序语句中相应的实参（可以是常量、变量或表达式）代替形参。如果宏定义中的字符串中的字符不是参数字符，则保留。
第八章 预处理命令
第八章预处理命令 一、选择题 1.C语言中，宏定义有效范围从定义处开始，到源文件结束处结束，但可以用 来提前解除宏定义的作用。（0级） A)# ifdef B)endif C)# undefine D)# undef 2.以下不正确的叙述是。（0级） A)预处理命令都必须以“#”号开始 B)在程序中凡是以“#”号开始的语句行都是预处理命令行 C)C语言在执行过程中对预处理命令行进行处理 D)# define ABCD是正确的宏定义 3.以下正确的叙述是。（0级） A)在程序的一行中可以出现多个有效的预处理命令行 B)使用带参宏时，参数的类型应与宏定义时的一致 C)宏替换不占用运行时间，只占编译时间 D)宏定义不能出现在函数内部 4.以下不正确的叙述是。（0级） A)宏替换不占用运行时间 B)宏名无类型 C)宏替换只是字符替换 D)宏名必须用大写字母表示 5. 以下正确的叙述是。（0级） A)C语言的预处理功能是指完成宏替换和包含文件的调用 B)预处理命令只能位于C源程序文件的首部 C)凡是C源程序中行首以“#”标识的控制行都是预处理命令 D)C语言的编译预处理就是对源程序进行初步的语法检查 6.在文件包含预处理语句（# include）的使用形式中，当之后的文件名用“”（双引号） 括起时，寻找被包含文件的方式是。（0级） A)直接按系统设定的标准方式搜索目录 B)先在源程序所在目录搜索，再按系统设定的标准方式搜索 C)仅仅搜索源程序所在目录 D)仅仅搜索当前目录 7.在文件包含预处理语句（# include）的使用形式中，当之后的文件名用<>（尖引号） 括起时，寻找被包含文件的方式是。（0级） A)直接按系统设定的标准方式搜索目录 B)先在源程序所在目录搜索，再按系统设定的标准方式搜索 C)仅仅搜索源程序所在目录 D)仅仅搜索当前目录 8.C语言的编译系统对宏命令的处理。（0级） A)在程序运行时进行的 B)在程序连接时进行的 C)和C程序中的其它语句同时进行编译的
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二级 第9章 编译预处理和动态存储分配
1.以下叙述中正确的是()。 A) 在C语言中，预处理命令行都以"#"开头 B) 预处理命令行必须位于C源程序的起始位置 C) #include 预处理命令行都必须以【1】号开始. 答案： ======(答案1)====== # 设有以下宏定义 # define WIDTH 80 # define LENGTH (WIDTH +40) 则执行赋值语句:v= LENGTH*20;(v为int型变量)后,v的值是【1】. 答案： ======(答案1)====== 2400 设有以下宏定义 # define WIDTH 80 # define LENGTH WIDTH +40 则执行赋值语句:v= LENGTH*20;(v为int型变量)后,v的值是【1】.80+40*20 答案： ======(答案1)====== 880 以下程序的运行结果是【1】. #include #define MIN(x,y) (x) main() { inti=10,j=15,k ; k=10*MIN(i,j); printf("%d\n",k); } 答案： ======(答案1)====== 100 下列程序运行结果为: #define P 3 #define S(a) P*a*a main() {intar; ar=S(3+5);//3*3+5*3+5 printf("\n%d",ar); } #define宏都是直接替换的，不会计算后再替换。s(3+5) = p*3+5*3+5 = 9+15+5 =29 若想计算后在替换，需要加上括号： #define S(a) P*(a)*(a) 若有宏定义如下: #define X 5 #define Y X+1 #define Z Y*X/2 则执行以下printf语句后,输出结果是(). inta;a=Y; printf("%d ",Z); printf("%d\n",--a); A) 7 6 B) 12 6 C) 12 5 D) 7 5 答案：D 请读程序: #include 第九章编译预处理与带参数的主函数 一、单项选择题 1.C程序中，以#号带头的行是预编译（A）。 A.命令 B.语句 C.函数 D.字符串 2.下列正确的预编译命令是（B）。 A.define PI 3.14159 B.#define p(a,b) strcpy(a,b) C. #include stdio.h D. # define PI3.14159 3.下列命令或语句中，正确的是（C）。 A.#define MYNAME= “ABC” B.#include stdio.h C. for(i=0;i<10;i++); D.struct int stu{int name}; 4.下列命令或语句中，正确的是（A）。 A.#define PI 3.14159 B. include “stdio.h” C.for(i=0,i<10,i++)a++ D.static struct {int i;}b={2}; 5.下列命令或语句中，错误的是（B）。 A. #define PI 3.14159 B.#include 第九章预处理 A部分（本、专科必做） 一、选择题 以下不正确的叙述是（D） A、宏替换不占用运行时间。 B、宏名无类型。 C、宏替换只是字符替换。 D、宏名必须用大写字母表示。 C语言的编译系统对宏命令的处理（D） A、在程序运行时进行的。 B、在程序连接时进行。 C、和C程序中的其它语句同时进行编译的。 D、在对源程序中其它语句正式编译之前进行的。 3、以下程序的输出结果是（C）。 A、15 B、100 C、10 D、150 #define MIN(x,y) (x)<(y)?(x):(y) void main() { int I,j,k; i=10;j=15;k=10*MIN(i,j); printf(“%d\n”,k); } 4、以下叙述中正确的是（D） 用#include包含的文件的后缀必须是“.h”。 若一些源程序中包含某个头文件；当该文件有错时，只需对该头文件进行修改，包含此头文件的所有源程序不必重新进行编译。 宏命令行可以看作是一行C语句。 预处理是在编译之前进行的。 5、以下叙述中正确的是（C） A、源程序中所有的行都参加编译。 B、宏定义常量与const定义常量是一样的。 C、宏定义可以嵌套定义，即在宏定义中的字符串可以引用另一个宏定义的标识符。 D、以上都不正确。 二、填空题 以下程序中for 循环执行的次数是 6 。 #define N 2 #define M N+1 #define NUM (M+1)*M/2 void main() { int i; for(i=1;i<=NUM;i++); printf(“%d\n”,i); } 2、以下程序的输出结果是x=93 。 #define A 3 #define B(a) ((A+1)*a) 第九章习题答案 一、单项选择题 1．A 2．B 3．C 4．D 5．B 6．C 7．A 8．D 9．D 10．C 11．B 12．C 13．D 14．C 二、填充题 1．编译处理编译预处理 2．非静态存储类型变量和外部函数 3．7 4．printf(“%d\n”,m); 5．fopen(“a.txt”,”rw”); 6．x[i]>=’A’&&x[i]<=’Z’ 7．“ i=%d\n” 8．(1) #define MAX(a,b,c) (2) #define MIN(a,b) (a 四、程序设计题 1．解： #include 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 第九章 编译预处理 编译指令（编译预处理指令）：C 源程序除了包含程序命令（语句）外，还可以使用各种编译指令（编译预处理指令）。编译指令（编译预处理指令）是给编译器的工作指令。这些编译指令通知编译器在编译工作开始之前对源程序进行某些处理。编译指令都是用“#”引导。 编译预处理：编译前根据编译预处理指令对源程序的一些处理工作。C 语言编译预处理主要包括宏定义、文件包含、条件编译。 编译工作实际分为两个阶段：编译预处理、编译。广义的编译工作还包括连接。 9、1 宏定义 宏定义：用标识符来代表一个字符串（给字符串取个名字）。C 语言用“#define ”进行宏定义。C 编译系统在编译前将这些标识符替换成所定义的字符串。 宏定义分为不带参数的宏定义和带参数宏定义。 9、1、1 不带参数宏定义（简单替换） 1 其中：标识符-宏名。 2、宏调用：在程序中用宏名替代字符串。 3、宏展开：编译预处理时将字符串替换宏名的过程，称为宏展开。 说明： （1）宏名遵循标识符规定，习惯用大写字母表示，以便区别普通的变量。 （2）#define 之间不留空格，宏名两侧空格（至少一个）分隔。 （3）宏定义字符串不要以分号结束，否则分号也作为字符串的一部分参加展开。从这点上 看宏展开实际上是简单的替换。 例如：#define PI 3.14; 展开为s=3.14；*r*r ；(导致编译错误) （4）宏定义用宏名代替一个字符串，并不管它的数据类型是什么，也不管宏展开后的词法 和语法的正确性，只是简单的替换。是否正确，编译时由编译器判断。 例如：#define PI 3.I4 照样进行宏展开（替换），是否正确，由编译器来判断。 （5）#define 宏定义宏名的作用范围从定义命令开始直到本源程序文件结束。可以通过 #undef 终止宏名的作用域。 第九章 预处理命令 一、选择题 1.以下叙述不正确的是 。 A）预处理命令行都必须以＃开始 B）在程序中凡是以＃开始的语句行都是预处理命令行 C）C程序在执行过程中对预处理命令行进行处理 D）预处理命令行可以出现在C程序中任意一行上 2.以下叙述中正确的是 。 A）在程序的一行上可以出现多个有效的预处理命令行 B）使用带参数的宏时，参数的类型应与宏定义时的一致 C）宏替换不占用运行时间，只占用编译时间 D）C语言的编译预处理就是对源程序进行初步的语法检查 3.以下有关宏替换的叙述不正确的是 。 A）宏替换不占用运行时间B）宏名无类型 C）宏替换只是字符替换D）宏名必须用大写字母表示 4.在“文件包含”预处理命令形式中，当#include后面的文件名用””（双引号）括起时，寻找被包含文件的方式是 。 A）直接按系统设定的标准方式搜索目录 B）先在源程序所在目录中搜索，再按系统设定的标准方式搜索 C）仅仅搜索源程序所在目录 D）仅仅搜索当前目录 5.在“文件包含”预处理命令形式中，当＃include后名的文件名用<>（尖括号）括起时，寻找被包含文件的方式是 。 A）直接按系统设定的标准方式搜索目录 B）先在源程序所在目录中搜索，再按系统设定的标准方式搜索 C）仅仅搜索源程序所在目录 D）仅仅搜索当前目录 6.在宏定义#define PI 3.1415926中，用宏名PI代替一个 。 A）单精度数B）双精度数C）常量D）字符串 7.以下程序的运行结果是 。 #include 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 (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预处理命令行
第九章编译预处理与带参数的主函数
第九章 预处理
第九章改 预处理命令习题答案
c语言预处理命令总结大全
第九章编译预处理
第九章 预处理命令
C语言预处理命令总结大全
预处理的考试试题