第9章 预处理命令
C语言 第九章 预处理命令
目的: 简化程序的编写 ; 提高程序的模块化、可读性、可移植性。
有三种类型的预处理命令: 1. 宏定义命令; 2. 文件包含命令; 3. 条件编译命令。
为了与C语句区别,这些命令均以“ # ”开头。
处理流程: 第一次编译扫描时,将预编译命令处理完， 然后再进行正式编译,生成目标代码。
#define f(a)
(a)* b
若有：f(x+y) 则应有：
(x+y)b
若有：f(x+y+z) 则应有：
预编译后, z = f(x+y) 变成: z = x+y*b 结果为: z=31
(x+y+z)b
（这个结果与初始设想不一致）
“带参数宏定义” 必须注意以下几个方面: 1. 宏定义时要考虑实参(替换)的各种可能, 防止出 现二义性。
3. #include后的文件名既可用“ ”，也可用< >， 二者区别:
“ ”首先在当前目录中找，然后再去标准目录中找。
< > 只在标准目录(include目录)中找。
为提高预处理的搜索效率，通常对自定义的 非标准头文件使用方式一；而对系统提供的标准 头文件(如：math.h、stdio.h等)使用方式二。
将返回值 6 将返回值 8
但二者还是有区别的：
1) 宏替换在预编译时进行；
而函数调用在程序运行时进行
2) 宏展开时，仅仅是将宏体中的形参简单 地置换为实参，不计算实参值，也不会带来任何 返回值； 而函数调用要进行： l 计算实参值（假定用 2+3、 9–1作为实参将 被计算出来）、 l参数传递（将 5、8 传给形参x、y）、
这些文件要用到公用信息时，只要在文件 中加入#include “f.h”这么一行命令既可。这样 就不必在f1.c、…… 、fn.c每个文件中都去重 复定义这些公用的信息。
第九章预处理命令(5503)
1.下面叙述中正确的是（A ）。
A.带参数的宏定义中参数是没有类型的B.宏展开将占用程序的运行时间C.宏定义命令是C语言中的一种特殊语句D.使用#include命令包含的头文件必须以“.h”为后缀2.在宏定义#define PI3.14159中，用宏名代替一个（ D ）A.常量B.单精度数C.双精度数D.字符串3.下面有关宏替换的叙述不正确的是（ D ）A.宏替换不占用运行时间B.宏名无类型C.宏替换只是字符替换D.宏名必须用大写字母表示4.C语言的编译系统对宏命令的处理是（ D ）A.在程序运行时进行的B.和C程序中的其他语句同时进行编译的C.在程序连接时进行的D.在对源程序中其它成分正式编译之前进行的5.下列定义不正确的是（C ）。
A.#define PI 3.141592B.#define S345C.int max(x,y); int x,y; { }D.static char c6.有如下宏定义 #define s(a) a*3 ，则执行表达式x=s(1+2)后，变量x的值为（ D）。
A.10B.9C.8D.77.以下说法中正确的是（ D）。
A.#define是C语句B.#define是库函数C.#define是自定义函数D.#define是预处理命令8.在“文件包含”预处理语句的使用形式中，当#include后面的文件用了“”（双引号）时，寻找被包含文件的方式是（B）。
A.直接按系统设定的标准方式搜索目录B.先在源程序所在目录搜索，再按系统设定的标准方式搜索C.仅仅搜索源程序所在目录D.仅仅搜索当前目录9.以下叙述正确的是（ B ）。
A.可以把define和if定义为用户标识符B.可以把define定义为用户标识符，但不能把if定义为用户标识符C.可以把if定义为用户标识符，但不能把define定义为用户标识符D.define和if都不能定义为用户标识符10.以下叙述中正确的是（ B ）。
预处理指令详解
#pragma#pragma 预处理指令详解在所有的预处理指令中，#Pragma 指令可能是最复杂的了，它的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。
#pragma指令对每个编译器给出了一个方法,在保持与C和C++语言完全兼容的情况下,给出主机或操作系统专有的特征。
依据定义,编译指示是机器或操作系统专有的,且对于每个编译器都是不同的。
其格式一般为: #Pragma Para其中Para 为参数，下面来看一些常用的参数。
(1)message 参数。
Message 参数是我最喜欢的一个参数，它能够在编译信息输出窗口中输出相应的信息，这对于源代码信息的控制是非常重要的。
其使用方法为：#Pragma message(“消息文本”)当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。
当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有正确的设置这些宏，此时我们可以用这条指令在编译的时候就进行检查。
假设我们希望判断自己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法#ifdef _X86#Pragma message(“_X86 macro activated!”)#endif当我们定义了_X86这个宏以后，应用程序在编译时就会在编译输出窗口里显示“_X86 macro activated!”。
我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了。
(2)另一个使用得比较多的pragma参数是code_seg。
格式如：#pragma code_seg( ["section-name"[,"section-class"] ] )它能够设置程序中函数代码存放的代码段，当我们开发驱动程序的时候就会使用到它。
(3)#pragma once (比较常用）只要在头文件的最开始加入这条指令就能够保证头文件被编译一次，这条指令实际上在VC6中就已经有了，但是考虑到兼容性并没有太多的使用它。
C语言程序设计教程CJ_04预处理命令_潭浩强第3版
Page 6
辽宁师范大学
蔡静
带参宏替换 函数调用 编译时替换, 运行时调用, 编译时替换 不占用内存 运行时调用 占用内存 只替换不计算 计算 替换使程序代码加长 不加长 存在数据类型问题 不存在数据类型问题
Page 7
辽宁师范大学
蔡静
9.2 “文件包含 处理 文件包含”处理 文件包含
通过预处理命令#include把另一个文件的全部内容包含到本 文件中。 格式1： #include <文件名 文件名> 文件名 只按系统指定的标准方式(从编译系统所在子目录中)检索 文件目录。 格式 2： #include “文件名” 文件名” 文件名 系统首先在当前源文件所在目录中寻找该文件，若找不到， 再按系统指定的标准方式检索其他文件目录。 例：9.6
Page 9
辽宁师范大学
蔡静
Thanks
Page 8
辽宁师范大学
蔡静
9.3 条件编译
指定满足某条件才能对指定语句进行编译，称为条件编译。 几种形式： 程序段2】 程序段 】 #endif
#ifndef 标识符 程序段1 程序段 【#else 程序段2】 程序段 】 #endif
#if 表达式 程序段1 程序段 【#else 程序段2】 程序段 】 #endif
Page 5
辽宁师范大学
蔡静
二、带参数的宏替换/宏定义 带参数的宏替换 宏定义
格式： #define 宏名 形参表 宏名(形参表 形参表) 例：#define S(M, N) M*N
字符串
说明： 带参数的宏定义不是进行简单字符串替换，还要进行参数 替换。形参表列中的参数出现在字符串中。 宏展开只是将程序语句中宏名后括号内的实参代替 #define命令中的形参，并不计算。 宏名与其后括号间不能有空格。 例9.3-9.5：
预处理命令
二、表演区 （一）什么是表演区 表演区以幼儿表演游戏为设计核心，通过道具吸引幼儿积极参加故事表 演、游戏等活动。 （二）表演区的环境布置与材料投放 表演区可以分为固定式和活动式表演区角两类。 固定式的表演区角是指在活动室内辟出一定区域，存放表演所需要的用 具。 活动式的表演区角则是根据表演需要，临时在走廊、门厅、过道或室外 等地方设置表演场所，便于及时放置和收拢。
第9章 预处理命令
• 9. 1 概述 • 9. 2 宏定义 • 9. 3 文件包含 • 9. 4 条件编译
9. 2 宏定义
• 9. 2. 1 无参宏定义
• 无参宏的宏名后不带参数。 • 其定义的一般形式为 • #define 标识符字符串 • 其中, #表示这是一条预处理命令; 凡是以#开头的指令均为预处理命
果果：“老师，一分钟是多久呢？” 教师：“就是一会儿，我一转身。” 贝贝：“我知道，最细的秒针走一圈，挺长的。” 佳佳：“一分钟就是我们从门口走到后面的窗子那里。” 教师：“一分钟能做什么？” 佳佳：“给花浇水。” 果果：“唱完一首歌。” 贝贝：“搬来一把椅子。”……
学习目标
1. 了解幼儿日常交谈的主要特点及指导要求。 2. 掌握语言区角的环境布置与材料投放要求，能科学地开展语言区角活 动的指导。 3. 学会设计听说游戏的玩法，并能评析幼儿园听说游戏。
上一页 下一页 返回
9. 2 宏定义
• 【例9 - 2】不作宏代换程序举例。
上一页 下一页 说明: • 虽然已定义宏名OK 表示100, 但在printf 语句中OK 被引号括起来, 因
此不作宏代换。 • 程序的运行结果为“OK”, 这表示把“OK” 当字符串处理。
上一页 下一页 返回
义时, 必须十分注意, 应保证在宏代换之后不发生错误。
.net 预处理详解
.net 预处理详解在使用.net框架进行软件开发时，我们经常会遇到需要在编译阶段对代码进行预处理的情况。
预处理是指在编译代码之前，通过指定一些预处理指令来控制代码的编译过程。
预处理指令在代码中以`#`符号开头，告诉编译器应该如何处理代码。
在本文中，我们将详细介绍.net 框架中常用的预处理指令及其用法。
1. 条件编译条件编译是预处理中最常用的功能之一，它可以根据一些条件来决定是否编译一段特定的代码。
通过使用`#if`和`#endif`指令，我们可以在代码中嵌入任意条件来控制编译过程。
例如，我们可以使用条件编译来根据不同的操作系统平台编译不同的代码片段：```csharp#if WINDOWSConsole.WriteLine("This is a Windows platform.");#elif LINUXConsole.WriteLine("This is a Linux platform.");#endif```上述代码中，`#if`指令用于判断是否为Windows平台，如果是则输出相应的信息；`#elif`指令用于判断是否为Linux平台，如果是则输出相应的信息。
通过条件编译，我们可以根据具体情况选择性地编译代码，以实现更好的跨平台兼容性。
2. 定义常量预处理指令还可以用于定义常量，在编译过程中将其替换为指定的值。
通过`#define`指令可以定义一个常量，并在代码中使用该常量。
例如：```csharp#define MAX_VALUE 100int value = MAX_VALUE;```上述代码中，我们使用`#define`指令定义了一个名为`MAX_VALUE`的常量，并将其设置为100。
之后，在代码中使用该常量时，编译器会将其替换为实际的值。
这样可以提高代码的可读性和维护性。
3. 跳过代码有时候，在调试或者测试代码时，我们需要暂时跳过一些代码片段而不编译它们。
预处理命令
3
math.h——文件包含数学程序。 reg51.h——文件中包含51单片机的特殊寄存器定义。 reg52.h——文件中包含52单片机的特殊寄存器定义。 setjmp.h——文件包含定义jmp_buf类型和setjmp和longjmp程序原型。 stdarg.h——文件包含可变长度参数列表程序。 stdlib.h——文件包含存储区分配程序。 stdio.h——文件包含标准输入和输出程序。 string.h——文件包含字符串操作程序、缓冲区操作程序。 对于51单片机而言，源程序开头必须要包含reg51.h头文件，因为该文件对51单片 机的相关位及寄存器进行了定义，这样在程序中才可以正常使用寄存器等资源。
#else 程序段2
#endif 若常量表达式成立，则编译程序1，否则编译程序2。
5
单片机原理及应用
单片机原理及应用
C51语言中提供了各种预处理命令，其作用类似于汇编程序中的伪指令。在编译环 境对源程序进行编译前，需要先对程序中的预处理命令进行处理，然后将处理结果和源 程序一起编译。C51语言中的预处理命令包括宏定义命令、文件包含命令和条件编译命 令等。通常，除条件编译命令外，预处理命令一般放在函数体之外，并且通常都放置在 源文件的开头。
句如下：
outputs=0xff;
/*输出 1111 1111 */
进行编译时，预处理器会将整个程序中的所有outputs替换为P2。
2．文件包含命令
#include命令的功能是将指定的定义或声明文件放入程序之中，该命令常用于引入 标准库函数文件。下面是一些常用的C51头文件：
absacc.h——包含允许直接访问8051不同存储区的宏定义。 assert.h——文件定义宏，用来建立程序的测试条件。 ctype.h——包含字符转换和分类程序。 intrins.h——文件包含指示编译器产生嵌入式固有代码的程序原型。
C语言程序设计教案 第九章 编译预处理
第九章编译预处理课题：第九章编译预处理教学目的:1、了解预处理的概念及特点2、掌握有参宏与无参宏的定义及使用，领会文件包含的使用及效果教学重点：教学难点：掌握宏的使用，文件包含有参宏与无参宏的使用步骤一复习引导ANSI C标准规定可以在C源程序中加入一些“预处理命令”，以改进程序设计环境，提高编程效率。
这些预处理命令是由ANSI C统一规定的，但它不是C语言本身的组成部分，不能直接对它们进行编译。
必须在对程序进行通常的编译之前，先对程序中这些特殊的命令进行“预处理”，即根据预处理命令对程序作相应的处理。
经过预处理后程序不再包括预处理命令了，最后再由编译程序对预处理后的源程序进行通常的编译处理，得到可供执行的目标代码。
步骤二讲授新课C语言与其他高级语言的一个重要区别是可以使用预处理命令和具有预处理的功能。
C 提供的预处理功能主要有以下三种：宏定义、文件包含、条件编译。
分别用宏定义命令、文件包含命令、条件编译命令来实现。
为了与一般C语句相区别，这些命令以符号“ #” 开头。
§9.1宏定义宏：代表一个字符串的标识符。
宏名：被定义为“宏”的标识符。
宏代换(展开)：在编译预处理时，对程序中所有出现的“宏名”，用宏定义中的字符串去代换的过程。
一、不带参数的宏定义一般形式：#define 标识符字符串#define PI 3.1415926main(){ 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);}例如：由键盘输入y值，求表达式：3(y2+3y)+ 4(y2+3y)+ y(y2+3y)#define M (y*y+3*y)main(){ int s, y;printf( “Input a number :”); scanf (“%d”,&y);s=3*M+4*M+y*M; p rintf(“s=%d\n”,s);}先宏展开：s=3*(y*y+3*y) +4*( y*y+3*y) + y*(y*y+3*y)再与源程序合并说明：⑴宏名一般用大写表示，以便与变量名区分。
C语言程序设计 第3版 第9章 编译预处理
#include "test2.c" static int sum(int n) {
int i,s=0; for(i=1;i<=n;i++)
s=s+fact(i); return s; }
static int fact(int n) {
C语言程序设计
第9章 编译预处理
第1讲：编译预处理基本形式
提纲
1.宏定义 2.文件包含 3.条件编译
1.宏定义
不带参数宏定义 带参数宏定义
格式：
#define 标识符 字符串
功能：
指定标识符代替一个较复杂的字符串。
注意说明：
（1）宏名一般习惯用大写字母，例如宏名PI。 （2）宏名用做代替一个字符串，不作语法检查。 （3）宏定义无需在末尾加“；” （4）宏定义的有效范围为#undef命令终止。 （5）在进行宏定义时，可以引用已定义的宏名。
char web[50]; int i=0; gets(web); while(web[i]!='\0') {
#if(R==1) if(web[i]>='A'&&web[i]<='Z') {web[i]=web[i]+32; i++;}
#else if(web[i]>='a'&&web[i]<='z') {web[i]=web[i]-32; i++;}
形式3：
#ifndef 标识符 程序段1
#else 程序段2
预处理指令
9.1.2 有参宏定义
1．带参宏定义的一般格式 ． #define 宏名 形参表 语言符号字符串 宏名(形参表 形参表) 2．带参宏的调用和宏展开 ． 实参表) （1）调用格式：宏名 实参表 ）调用格式：宏名(实参表 （2）宏展开：用宏调用提供的实参字符串，直接置换 ）宏展开：用宏调用提供的实参字符串， 宏定义命令行中、相应形参字符串，非形参字符保持不变。 宏定义命令行中、相应形参字符串，非形参字符保持不变。 3．说明 ． （1）定义有参宏时，宏名与左圆括号之间不能留有空 ）定义有参宏时， 否则， 格。否则，Ｃ编译系统将空格以后的所有字符均作为替代 字符串，而将该宏视为无参宏。 字符串，而将该宏视为无参宏。 （2）有参宏的展开，只是将实参作为字符串，简单地 ）有参宏的展开，只是将实参作为字符串， 置换形参字符串，而不做任何语法检查。在定义有参宏时， 置换形参字符串， 而不做任何语法检查。在定义有参宏时， 在所有形参外和整个字符串外，均加一对圆括号。 在所有形参外和整个字符串外，均加一对圆括号。
第9章
预处理命令
ห้องสมุดไป่ตู้
所谓预处理命令是指，在对源程序进行编译之前， 所谓预处理命令是指，在对源程序进行编译之前，先 对源程序中的编译预处理命令进行处理； 对源程序中的编译预处理命令进行处理；然后再将处理的 结果，和源程序一起进行编译，以得到目标代码。 结果，和源程序一起进行编译，以得到目标代码。 9.1 宏定义 9.2 文件包含 9.3 条件编译
9.3 条件编译
条件编译可有效地提高程序的可移植性， 条件编译可有效地提高程序的可移植性，并广泛地应 用在商业软件中，为一个程序提供各种不同的版本。 用在商业软件中，为一个程序提供各种不同的版本。 1．一般格式 ． ＃if 常量表达式 程序段1； 程序段 ； [＃else ＃ 程序段2； 程序段 ；] ＃endif 2．功能：当表达式为非0（“逻辑真”）时，编译程序 ．功能：当表达式为非 （ 逻辑真” 段1，否则编译程序段 。 ，否则编译程序段2。
C语言910章
C语言教案第九章预处理命令1.C语言中以“#”号开头的行，均为“编译预处理”命令行2.宏作为一个预处理命令，只是简单的文本代换3.在字符串代换过程中，一定要注意不要添加任何字符4.不带参数的宏定义及使用，注意宏中括号的用法5.*当宏定义在一行中写不下，需换行时应在最后一个字符后加“\”6.带参数的宏定义及使用7.注意宏名一般使用大写字母，而参数则不限8.文件包含的两种方法（书上212页）9.*条件编译习题217页：2，3，5第十章指针1.地址和指针的概念，指针型变量的定义2.指针型变量的基类型3.取地址运算符& 和指针运算符*4.通过指针为变量赋值及通过指针找出变量的值的方法5.*为指针变量赋“空”值：p=NULL或p=’\0’ 或p=0（NULL为预定义符，ASCII码值为0）6.函数的形参为指针变量时的数据传递7.通过传送地址值，在被调函数中直接改变主调函数中变量的值8.*函数返回地址值9.指针变量取代数组作函数参数10.一维数组与指针11.一维数组中的几种等价形式：设有定义int a[10], *p=a;数组元素的地址——&a[i], a+i, p+i, &p[i]数组元素——a[i], *(a+i), *(p+i), p[i]12.移动指针，每次移动一个单元13.*指针比较，通常两个或多个指针指向同一目标时比较才有意义14.*数组元素的地址作实参15.*函数的指针形参与函数体中数组的区别16.二维数组与指针17.一个二维数组可看作由多个一维数组构成18.几种等价形式：设有定义int a[5][6], *p=a[0]; 则存在着关于变量和变量的地址间的如下等价形式二维数组元素的地址——&a[i][j], a[i]+j, *(a+i)+j, &a[0][0]+列数*i+j,a[0]+列数*i+j 二维数组元素——a[i][j], *(a[i]+j), *(*(a+i)+j), *(&a[0][0]+列数*i+j),(*(a+i))[j]19.指向指针的指针：int a[5][6], **p=a;20.指针数组：int a[5][6], *p[4]; 定义了具有四个元素的基本整型指针数组21.行指针：int a[5][6], (*p)[6]; 定义了一个指向具有六个元素的一维数组的指向指针的指针型变量22.*二维数组名和指针数组作为实参在函数中的数据传递23.*二级指针和行指针作为实参在函数中的数据传递24.*字符串与指针，直接用字符型指针变量记录字符串的地址25.*指向函数的指针习题278页：2，3，4，9，10，14，15。
第九章改 预处理命令习题答案
第九章习题答案一、单项选择题1．A2．B3．C4．D5．B6．C7．A8．D9．D10．C11．B12．C13．D14．C二、填充题1．编译处理编译预处理2．非静态存储类型变量和外部函数3．74．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<b?a:b)(3) #define isalnum(c) (c>=’0’&& c<=’9’)(4) #define isupper( c) (c>=’A’&& c<=’Z’)(5) #define islower( c) (c>=’a’ && c<=’z’)三、程序分析题1.运行结果: -32.运行结果: 7,473.运行结果：50 254.运行结果：x=9, y=55.运行结果：9 9 116.输出结果: x|y&z=3x^y&~z=1x&y&z=0!x|x=1~x|x=-1四、程序设计题1．解：#include <stdio.h>#include <math.h>#define S(a, b, c) 0.5* (a+b+c)#define AREA(a, b, c) sqrt (S(a, b, c)*(S(a, b, c)-a)* (S(a, b, c )-b)* (S(a, b, c)-c)) void main ( ){ float a, b, c;printf (“输入三角形的三条边长：a, b, c\n”);scanf (“%f, %f, %f”, &a, &b, &c) ;if (( a+b>c)&& (b+c>a) && (c+a>b)){ printf (“周长=%f\n”, 2*S(a, b, c ));printf (“面积=%f\n”, AREA(a, b, c ));}else printf (“a, b, c 的长度不能构成三角形\n”) ;}2．解：#include <stdio.h>#include <stdlib.h>void main (int argc, char *argv[ ]){ int a, b;if (argc<3) { printf (“Parameter missing!\n”) ; exit(0); }a=atoi (argv[1]) ;b=atoi (argv[2]) ; //在stdlib.h中有库函数atoi, 把字符串转换成整数printf (“%5d + %5d = %5d\n”, a, b, a+b) ;printf (“%5d - %5d = %5d\n”, a, b, a-b) ;printf (“%5d * %5d = %5d\n”, a, b, a*b) ;printf (“%5d / %5d = %5d\n”, a, b, a/b) ;printf (“%5d %% %5d = %5d\n”, a, b, a%b) ;}3．解：#include <stdio.h>#include <stdlib.h>void main (int argc, char *argv[]){ int i, sum=0;for (i=1; i<argc; i++) sum=sum+atoi (argv[i]) ;printf (“和= %d\n”, sum);}4．解：#include <stdio.h>#include <stdlib.h>#include <string.h>void main (int argc, char *argv[]){ if (argc<3){ printf (“Parameter missing!\n”) ; exit(0); } if ( strcmp (argv[1], argv[2])>0) puts (argv[1]) ;else puts (argv[2]) ;}。
第9章预处理定义
C语言程序设计（第三版） My email:chenguot@
area=S(a); printf(“r=%f\narea=%f\n”,a,area);
area=3.1415926*a*a;
}
C语言程序设计（第三版） My email:chenguot@
10
§9.1 宏定义(7)
如下宏定义：
说明：
#define S (r) PI*r*r
⑴对带参数的宏的展开只是将语对句于中语的句宏名后面括号内的实
file1.c 或
file2.c
#include<file2.c>
#include <文件名> B
A
file1.c
A B
C语言程序设计（第三版） My email:chenguot@
16
§将包9.宏含2代到表用“文输户出程件格序包式中做：含出”头文处件理，并(2) （2）主文件file1.c
（好1处）：将“格文式件宏包做含成”头命文令件可fo以rm节at.省h 程序设计void人m员ain的() 重复劳动。
#如inc：lud某e <单std位io.的h>人员往往使用一组固定的符号{ 常量（g=9.81,
#pdie=fi3n.e1P4R15p9ri2nt6f,e=2.718,c=…），可以把这些宏int定a,b义,c,d命; 令组成 ##一量定ddeeff个包义iinnee头含这ND文到些L“%“件自符\dn””，己号然所常后写量各的，人源相都文当可件于以中工用。业这上#in样的cl每标ud个准e命人零令cah=就件a1将r;b可，s=t这r2i以拿n;cg些=[不来]3=;符d“必就C=4号H;重用IN常A复。”;
1、预处理——精选推荐
1、预处理1、预处理命令的定义 使⽤库函数之前，应该⽤#include引⼊对应的头⽂件。
这种以#号开头的命令称为预处理命令。
所谓预处理是指在进⾏编译时的第⼀遍扫描（词法扫描和语法分析）之前所做的⼯作。
预处理是C语⾔的⼀个重要功能，它由于处理程序负责完成。
当编译⼀个程序时，系统将⾃动调⽤预处理程序对程序中“#”开头的预处理部分进⾏处理，处理完毕之后可以进⼊源程序的编译阶段。
C语⾔源⽂件要经过编译、链接才能⽣成可执⾏程序： （1）编译（Compile）会将源⽂件（.c⽂件）转换为⽬标⽂件。
对于 VC/VS，⽬标⽂件后缀为.obj；对于GCC，⽬标⽂件后缀为.o。
编译是针对单个源⽂件的，⼀次编译操作只能编译⼀个源⽂件，如果程序中有多个源⽂件，就需要多次编译操作。
（2）链接（Link）是针对多个⽂件的，它会将编译⽣成的多个⽬标⽂件以及系统中的库、组件等合并成⼀个可执⾏程序。
在实际开发中，有时候在编译之前还需要对源⽂件进⾏简单的处理。
例如，我们希望⾃⼰的程序在 Windows 和 Linux 下都能够运⾏，那么就要在 Windows 下使⽤ VS 编译⼀遍，然后在 Linux 下使⽤ GCC 编译⼀遍。
但是现在有个问题，程序中要实现的某个功能在 VS 和GCC 下使⽤的函数不同（假设 VS 下使⽤ a()，GCC 下使⽤ b()），VS 下的函数在 GCC 下不能编译通过，GCC 下的函数在 VS 下也不能编译通过，怎么办呢？ 这就需要在编译之前先对源⽂件进⾏处理：如果检测到是 VS，就保留 a() 删除 b()；如果检测到是 GCC，就保留 b() 删除 a()。
这些在编译之前对源⽂件进⾏简单加⼯的过程，就称为预处理（即预先处理、提前处理）。
预处理主要是处理以#开头的命令，例如#include <stdio.h>等。
预处理命令要放在所有函数之外，⽽且⼀般都放在源⽂件的前⾯。
预处理是C语⾔的⼀个重要功能，由预处理程序完成。
C语言 选择题库第9章 编译预处理和动态存储分配
第9章编译预处理和动态存储分配1.以下叙述中正确的是()。
A) 在C语言中，预处理命令行都以"#"开头B) 预处理命令行必须位于C源程序的起始位置C) #include <stdio.h>必须放在C程序的开头D) C语言的预处理不能实现宏定义和条件编译的功能参考答案：A【解析】预处理命令是以"#"号开头的命令，它们不是C语言的可执行命令，这些命令应该在函数之外书写，一般在源文件的最前面书写，但不是必须在起始位置书写，所以B)，C)错误。
C)语言的预处理能够实现宏定义和条件编译等功能，所以D)错误。
2．以下关于宏的叙述中正确的是()。
A) 宏替换没有数据类型限制B) 宏定义必须位于源程序中所有语句之前C) 宏名必须用大写字母表示D) 宏调用比函数调用耗费时间参考答案：A【解析】宏定义写在函数的花括号外边，作用域为其后的程序，通常在文件的最开头，所以B)选项中宏定义必须位于源程序中所有语句之前是错误的。
宏名一般用大写，但不是必须用大写，所以C)选项错误。
宏展开不占运行时间，只占编译时间，函数调用占运行时间(分配内存、保留现场、值传递、返回值)，所以D)选项错误。
3．有以下程序：#include <stdio.h>#define PT 3.5 ；#define S(x) PT*x*x ；main(){int a＝1，b＝2；printf("%4.1f\n" ，S(a＋b))；}程序运行后的输出结果是()。
A) 7.5 B) 31.5 C) 程序有错无输出结果D) 14.0参考答案：C【解析】宏定义不是C语句，末尾不需要有分号。
所以语句printf("%4.1f\n" ，S(a＋b))；展开后为printf("%4.1f\n" ,3.5；*a＋b*a＋b；)；所以程序会出现语法错误。
第九章 预处理命令
第九章 预处理命令一、选择题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<stdio.h>#define ADD(x) x+xvoid main ( ){ int m=1,n=2,k=3,sum ;sum = ADD(m+n)*k ;printf(“%d\n”,sum) ;A）9 B）10 C）12 D）188.以下程序的运行结果是 。
#include<stdio.h>#define MIN(x,y) (x)>(y) ? (x) : (y)void main ( ){ int i=10, j=15 , k;k = 10*MIN(i,j);printf(“%d\n”,k);}A）10 B）15 C）100 D）1509.以下程序的运行结果是 。
c#中预处理指令#if的使用
c#中预处理指令#if的使用c#中预处理指令#if的使用引导语：预处理(pre-treatment)，是指在进行最后加工完善以前进行的准备过程，具体应用在不同的行业或领域，会有不同的解释，以下是店铺整理的预处理指令#if的使用，欢迎参考阅读!#if 使您可以开始条件指令，测试一个或多个符号以查看它们是否计算为true。
如果它们的计算结果确实为true，则编译器将计算位于#if 与最近的 #endif 指令之间的所有代码。
例如#define DEBUG// ...#if DEBUGConsole.WriteLine("Debug version");#endif可以使用运算符==（相等）、!=（不相等）、&&（与）及||（或）来计算多个符号。
还可以用括号将符号和运算符分组。
备注使用 #if 以及 #else、#elif、#endif、#define 和 #undef 指令，可以包括或排除基于由一个或多个符号组成的条件的代码。
这在编译调试版本的`代码或编译特定配置时最为有用。
以 #if 指令开始的条件指令必须用 #endif 指令显式终止。
#define 使您可以定义一个符号，通过将该符号用作传递给 #if 指令的表达式，使该表达式计算为 true。
也可以用/define 编译器选项来定义符号。
可以用#undef 来取消定义符号。
用 /define 或 #define 定义的符号与具有同一名称的变量不冲突。
即，不应将变量名传递到预处理器指令，并且只能用预处理器指令计算符号。
用 #define 创建的符号的范围是在其中定义该符号的文件。
示例// preprocessor_if.cs#define DEBUG#define VC_V7using System;public class MyClass{static void Main(){#if (DEBUG && !VC_V7)Console.WriteLine("DEBUG is defined");#elif (!DEBUG && VC_V7)Console.WriteLine("VC_V7 is defined");#elif (DEBUG && VC_V7)Console.WriteLine("DEBUG and VC_V7 are defined");#elseConsole.WriteLine("DEBUG and VC_V7 are not defined"); #endif}}DEBUG and VC_V7 are defined【c#中预处理指令#if的使用】。
二级c语言第九章预处理命令
如果在程序中有下面的语句： R1=Radium(100); 那么，在编译预处理时，宏展开的顺序为从左到右进行置换，如果字符串 中包含宏中的形参，则将其用程序语句中相应的实参来替代，而字符串中的 其它字符原样保留。 因此，在处理上述语句时，将用 sqrt(area/PI) 替代 Radium(100)，同时将 字符串sqrt(area/PI)中的形参area用实参l00来替代，并把已定义的宏PI的值代 入，经宏展开后，该语句变为“ R1=sqrt(100/3.14159); ”。
内蒙古科技大学 工程训练中心
预处理命令概述
所谓预处理，就是指源程序被正式编译之前所进行的处理工作，这 是C语言和其他高级语言之间的一个重要区别。
所有的预处理指令均以“#”开头，在它前面不能出现空格以外的字 符，而且在行结尾处没有分号。 “预处理命令” 的作用不是实现程序的功能，它们是发布给编译系 统的信息。它们告诉编译系统，在对源程序进行编译之前应该做些什么， 所以称这类语句为编译预处理命令。 C语言在执行一个C程序时，如果程序中有预处理命令，则首先进行 编译预处理(即根据预处理命令对源程序进行预先处理)，然后再将经过 预处理的源程序编译成目标文件，而后进行目标文件的连接，当这些工 作都顺利通过后，才最终执行目标代码。这种执行过程大大提高了编程 效率。
PI 的有效范围
因为#undef 的作用是终止宏定义，因此PI的作用域从它定义开始到 #undef结束。在这以后，如果程序中出现 PI，则它不代表3.14159 。使 用#undef可以灵活控制宏定义的作用范围。
2019年1月8日5时29分 工程训练中心 徐国海
（二）带参数宏定义 (了解) 定义的一般格式为： #define 宏名(形式参数列表) 字符串
C语言9
第 九 章 编 译 预 处 理
7-1
宏定义 不带参数的宏定义 带参数的宏定义
7-1-1 7-1-2
7-2
7-3
文件包含
条件编译
9-1
宏定义
例9-1 请看下面的程序： #define PI 3.14159 main() {float r,l,s; scanf("%f",&r); l=2*PI*r; s=PI*r*r; printf("l=%7.2f,s=%7.2f\n",l,s); } 程序的第一行内容：#define PI 3.14159 就是一个宏定义，PI 称为宏名，其作用是用标识符PI代表3.14159这样一串字符。在此之后 的程序中就可以用标识符PI代替3.14159，称为宏引用。 预处理时，程序中的PI 将被所定义的串3.14159替换，称为宏展开 或宏替换，如程序中的语句：l=2*PI*r;和s=PI*r*r;中的宏展开后分别 为：l=2*3.14159*r;和s=3.14159*r*r;。 有两种形式的宏 ：不带参数的宏和带参数的宏。
9-2
文件包含(1)
一个C 程序由若干个源程序组成，而一个源文件还可以将另一个源 文件的全部内容包含进来，即将指定源文件的内容包含在当前文件中。 例如有两个源文件file1.c和file2.c，文件的内容分别如下： file1.c的内容： int max(int x,int y) {int z; if(x>y) z=x; else z=y; return z; } file2.c的内容： #include "file1.c" main() {int a,b,c; scan("%d,%d",&a,&b); c=max(a,b); printf("c=%d\n",c); }
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第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声明。
如果需要修改程序中常用的一些参数，可以不必修改每个程序，只需将这些参数放在一个头
文件中，在需要是修改头文件即可，但，被包含文件修改后，凡包含此文件的所有文件都要全部重新编译。