C语言_8_预处理
C语言中级教材培训课程—预处理
C 语言中级培训预处理的概念编译前编译预处理器语言中，以“＃”开头的语句统称为编译预处理命令。
以“＃”开始，末尾这些命令必须在一行的开头以“＃”开始，末尾不加分号，并且每条命令独占一行不加分号，并且每条命令独占一行，以区别于一为什么要用” 预处理”最小原则丁”的方式，由语言之外的预处理命令或函数提供。
就连处理预处理命令的预处理器C语言的预处理命令“预处理”前的预处理//有的系统是/ ，如VC++什么是宏#define PI (3.1415926)宏定义指令宏名字符串宏定义为什么要用宏定义-文字名称比数字要容易理解得多，一个好的宏名可以望文知义。
120使用宏的弊端：使用宏定义时需要注意的要点：宏替换的弊端：#define PF(x)x*x()()()/*#define PF(x)(x)*(x)*//*#define PF(x)((x)*(x))*/main()注意替换时不求值，{只是字符串的原样替换int a=2,b=3,c;c=PF(a+b)/PF(a+1);printf("\nc=%d",c);}按第一种宏定义：c=a+b*a+b/a+1*a+1；按第二种宏定义：()()()()；c=(a+b)*(a+b)/(a+1)*(a+1)按第三种宏定义：c=((a+b)*(a+b))/((a+1)*(a+1))；多用括号就万事大吉了吗？2：在定义宏时不要为宏加分号。
#define assert(e)\续行符#define assert(e) \宏定义实例——无参宏定义举例宏定义实例——带参数的宏定义举例宏定义实例——用宏定义构建机制#ifdef AFXDLL #ifdef _AFXDLL{0000AfxSig end(AFX PMSG)0}\ {0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \函数调用和宏定义的区别宏定义和类型定义的区别struct student*struct student *st uct stude t请分析下面语句的含义(*((UINT1*)(_data_)))定义了一个带参宏，它能将参数强转成无符号字符类型的地址，再将该地址中的值取出。
C语言中的预处理指令
C语言中的预处理指令在C语言编程中，预处理指令是一种特殊的指令，用于在编译阶段之前对源代码进行处理。
预处理指令以井号（#）开头，并且不是被编译器执行的实际指令，而是由预处理器处理的。
本文将详细介绍C语言中的预处理指令，并探讨其在程序开发中的作用和用法。
一、什么是预处理指令预处理指令是在编译阶段之前对源代码进行处理的指令。
它的作用是在编译之前对源文件进行一些文本替换、条件编译或者简单的文本粘贴工作。
预处理指令以井号（#）开头，且位于编译单位（源文件或头文件）的最开始位置。
二、预处理指令的作用1. 宏定义宏定义是预处理指令中使用最广泛的功能之一。
通过宏定义，可以为一段代码或者一个常量起一个易于记忆和使用的名字，从而提高代码的可读性和维护性。
下面是一个宏定义的示例：```c#define MAX_NUM 100```在这个例子中，宏定义了一个名为MAX_NUM的常量，它的值为100。
在后续的代码中，可以使用MAX_NUM来代表100，避免了重复书写代码的问题。
2. 文件包含预处理指令还可以使用#include指令将其他文件的内容包含到当前文件中。
这种方式可以在不同的源文件中共享代码，提高代码的复用性。
下面是一个文件包含的示例：```c#include <stdio.h>```通过#include指令，可以将系统库文件stdio.h中的代码包含到当前文件中，以便后续代码可以使用stdio.h中定义的函数和类型。
3.条件编译条件编译是预处理指令中非常重要的概念。
通过条件编译，可以根据条件的真假选择性地编译代码。
这在不同的操作系统、不同的编译器或者不同的编译选项下具有重要的意义。
下面是一个条件编译的示例：```c#ifdef DEBUGprintf("Debug mode\n");#endif```在这个例子中，只有在编译时定义了DEBUG宏的情况下，才会编译并执行printf语句。
C语言的预处理命令有哪些？
问：关于C语言中的预处理命令？答：我们可以在C源程序中插入传给编译程序的各种指令，这些指令被称为预处理器指令（等价于汇编语言中的伪指令），它们扩充了程序设计的环境。
现把常用的预处理命令总结如下：1. 预处理程序按照ANSI标准的定义，预处理程序应该处理以下12条指令：#if、#ifdef、#ifndef、#else、#elif、#endif、#define、#undef、#line、#error、#pragma、#include。
显然，所有的12个预处理指令都以符号#开始，，每条预处理指令必须独占一行。
2. #define#define指令定义一个标识符和一个串（也就是字符集），在源程序中发现该标识符时，都用该串替换之（原样替换，不要附加任何人为理解上的符号）。
这种标识符称为宏名字，相应的替换称为宏代换。
一般形式如下：#define macro-name char-sequence这种语句不用分号结尾。
宏名字和串之间可以有多个空格符，但串开始后只能以新行终止。
在C语言里宏定义只用来做的宏名替换，而不做语法检查的,因而它不是C语句，所以宏定义的语句结尾不需要加分号。
宏也在C里也叫预处理命令，因为宏是在程序编译前先进行字符替换的，所以叫预处理.例如：我们使用LEFT代表1，用RIGHT代表0，我们使用两个#define指令：#define LEFT 1#define RIGHT 0每当在源程序中遇到LEFT或RIGHT时，编译程序都用1或0替换。
定义一个宏名字之后，可以在其他宏定义中使用,例如：#define ONE 1#define TWO ONE+ONE#define THREE ONE+TWO宏代换就是用相关的串替代标识符。
因此，如果希望定义一条标准错误信息时，可以如下定义：#define ERROR_MS “Standard error on input \n”如果一个串长于一行，可在行尾用反斜线”\”续行，如下：#define LONG_STRING “This is a very very long \s tring that is used as an example”3. #error#error指令强制编译程序停止编译，它主要用于程序调试（放在错误的分支中，一旦进入错误的分支就显示该信息）。
c语言第8章 编译预处理及位运算习题答案
编译预处理习题一．单项选择题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 <stdio.h>main( ){ printf(“A=%f ”,A);}程序运行结果为（）。
A） 3.897678=3.897678 B） 3.897678=A C） A=3.897678 D）无结果7.有宏定义：#define LI(a,b) a*b#define LJ(a,b) (a)*(b)在后面的程序中有宏引用：x=LI(3+2,5+8);y=LJ(3+2,5+8);则x、y的值是（）。
A） x=65,y=65 B） x=21,y=65 C） x=65,y=21 D）x=21,y=218.有以下程序# define f(x) (x*x)main(){ int i1, i2;i1=f(8)/f(4) ; i2=f(4+4)/f(2+2) ;printf("%d, %d\n",i1,i2);}程序运行后的输出结果是A）64, 28 B）4, 4 C）4, 3D）64, 649.以下程序的输出结果是#define M(x,y,z) x*y+zmain(){ int a=1,b=2, c=3;printf(“%d\n”, M(a+b,b+c, c+a));}A) 19 B) 17 C) 15 D) 1210.有以下程序#define N 5#define M1 N*3#define M2 N*2main(){ int i;i=M1+M2; printf(“%d\n”,i);}程序编译后运行的输出结果是：A) 10 B) 20 C) 25 D) 3011.有如下程序#define N 2#define M N+1#define NUM 2*M+1#main(){ int i;for(i=1;i<=NUM;i++)printf(“%d\n”,i);}该程序中的for循环执行的次数是A) 5 B) 6C) 7 D) 812.位运算是对运算对象按二进制位进行操作的运算，运算的对象是____数据，以___的形式参与运算。
c语言的预处理指令分3种 1宏定义 2条件编译 3文件包含
c语⾔的预处理指令分3种 1宏定义 2条件编译 3⽂件包含宏简介1.C语⾔在对源程序进⾏编译之前，会先对⼀些特殊的预处理指令作解释(⽐如之前使⽤的#include⽂件包含指令)，产⽣⼀个新的源程序(这个过程称为编译预处理),之后再进⾏通常的编译所有的预处理指令都是以#开头，并且结尾不⽤分号2.预处理指令分3种 1> 宏定义 2> 条件编译 3> ⽂件包含3.预处理指令在代码翻译成0和1之前执⾏4.预处理的位置是随便写的5.预处理指令的作⽤域：从编写指令的那⼀⾏开始，⼀直到⽂件结尾，可以⽤#undef取消宏定义的作⽤6.宏名⼀般⽤⼤写或者以k开头，变量名⼀般⽤⼩写 宏定义可以分为2种：不带参数的宏定义和带参数的宏定义。
⼀、不带参数的宏定义1.⼀般形式#define 宏名字符串⽐如#define ABC 10右边的字符串也可以省略，⽐如#define ABC2.作⽤它的作⽤是在编译预处理时，将源程序中所有"宏名"替换成右边的"字符串"，常⽤来定义常量.3.使⽤习惯与注意1> 宏名⼀般⽤⼤写字母，以便与变量名区别开来，但⽤⼩写也没有语法错误2> 对程序中⽤双引号扩起来的字符串内的字符，不进⾏宏的替换操作。
3> 在编译预处理⽤字符串替换宏名时，不作语法检查，只是简单的字符串替换。
只有在编译的时候才对已经展开宏名的源程序进⾏语法检查4> 宏名的有效范围是从定义位置到⽂件结束。
如果需要终⽌宏定义的作⽤域，可以⽤#undef命令5> 定义⼀个宏时可以引⽤已经定义的宏名#define R 3.0#define PI 3.14#define L 2*PI*R#define S PI*R*R举例1 #include <stdio.h>2#define COUNT 434int main()5 {6char *name = "COUNT";78 printf("%s\n", name);910int ages[COUNT] = {1, 2, 67, 89};1112#define kCount 41314for ( int i = 0; i<COUNT; i++) {15 printf("%d\n", ages[i]);16 }1718// 从这⾏开始，COUNT这个宏就失效19#undef COUNT2021//int a = COUNT 写这个报错2223return0;24 }⼆、带参数的宏定义1.⼀般形式#define 宏名(参数列表) 字符串2.作⽤在编译预处理时，将源程序中所有宏名替换成字符串，并且将字符串中的参数⽤宏名右边参数列表中的参数替换3.使⽤注意1> 宏名和参数列表之间不能有空格，否则空格后⾯的所有字符串都作为替换的字符串2> 带参数的宏在展开时，只作简单的字符和参数的替换，不进⾏任何计算操作。
C语言程序设计知识点—第8章 指针结构体与预处理命令
指针使用示例 2 void main() { int num1 = 50, num2 = 100; int *ptr1, *ptr2; ptr1 = &num1; printf(" num1 的值是： %d", *ptr1); printf("\n num1 的地址是： %x \n", ptr1); ptr2 = &num2; printf("\n num2 的值是： %d", *ptr2); printf("\n num2 的地址是： %x \n", ptr2); *ptr2 = *ptr1; printf("\n 重新赋值后 num2 的值是： %d", *ptr2); printf("\n 重新赋值后 num2 的地址是： %x\n", ptr2); }
C 语言程序设计知识点
主讲教师：杨剑
第 8 章：指针、结构体与预处理命令
1. 本章目标
理解指针的概念 定义指针变量 掌握对指针的操作 理解指针和数组的关系 理解结构体的概念和定义 理解预处理指令
2. 内存地址
内存是一个连续编址的空间，每一个存储单元都有一个固定的编号，称为内存地址。 内存地址通常用 16 进制数表示。
c语言第8章-编译预处理及位运算习题答案doc资料
c语言第8章-编译预处理及位运算习题答案编译预处理习题一．单项选择题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 <stdio.h>main( ){ printf(“A=%f ”,A);}程序运行结果为（）。
A） 3.897678=3.897678 B） 3.897678=A C） A=3.897678 D）无结果7.有宏定义：#define LI(a,b) a*b#define LJ(a,b) (a)*(b)在后面的程序中有宏引用：x=LI(3+2,5+8);y=LJ(3+2,5+8);则x、y的值是（）。
A） x=65,y=65 B） x=21,y=65 C） x=65,y=21 D）x=21,y=218.有以下程序# define f(x) (x*x)main(){ int i1, i2;i1=f(8)/f(4) ; i2=f(4+4)/f(2+2) ;printf("%d, %d\n",i1,i2);}程序运行后的输出结果是A）64, 28 B）4, 4 C）4, 3D）64, 649.以下程序的输出结果是#define M(x,y,z) x*y+zmain(){ int a=1,b=2, c=3;printf(“%d\n”, M(a+b,b+c, c+a));}A) 19 B) 17 C) 15 D) 1210.有以下程序#define N 5#define M1 N*3#define M2 N*2main(){ int i;i=M1+M2; printf(“%d\n”,i);}程序编译后运行的输出结果是：A) 10 B) 20 C) 25 D) 3011.有如下程序#define N 2#define M N+1#define NUM 2*M+1#main(){ int i;for(i=1;i<=NUM;i++)printf(“%d\n”,i);}该程序中的for循环执行的次数是A) 5 B) 6C) 7 D) 812.位运算是对运算对象按二进制位进行操作的运算，运算的对象是____数据，以___的形式参与运算。
C语言预处理命令总结大全：宏定义
C语⾔预处理命令总结⼤全：宏定义C程序的源代码中可包括各种编译指令，这些指令称为预处理命令。
虽然它们实际上不是C语⾔的⼀部分，但却扩展了C程序设计的环境。
本节将介绍如何应⽤预处理程序和注释简化程序开发过程，并提⾼程序的可读性。
ANSI标准定义的C语⾔预处理程序包括下列命令：#define，#error，＃include，#if，#else，#elif，#endif，#ifdef，#ifndef，#undef，#line，#pragma等。
⾮常明显，所有预处理命令均以符号#开头，下⾯分别加以介绍。
⼀ #define命令#define定义了⼀个标识符及⼀个串。
在源程序中每次遇到该标识符时，均以定义的串代换它。
ANSI标准将标识符定义为宏名，将替换过程称为宏替换。
命令的⼀般形式为：#define ID 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 ⽤宏代换代替实在的函数的⼀⼤好处是宏替换增加了代码的速度，因为不存在函数调⽤的开销。
但增加速度也有代价：由于重复编码⽽增加了程序长度。
C语言对源程序处理的四个步骤：预处理、编译、汇编、链接——预处理篇
C语⾔对源程序处理的四个步骤：预处理、编译、汇编、链接——预处理篇预处理1）预处理的基本概念C语⾔对源程序处理的四个步骤：预处理、编译、汇编、链接。
预处理是在程序源代码被编译之前，由预处理器（Preprocessor）对程序源代码进⾏的处理。
这个过程并不对程序的源代码语法进⾏解析，但它会把源代码分割或处理成为特定的符号为下⼀步的编译做准备⼯作。
2）预编译命令Ｃ编译器提供的预处理功能主要有以下四种：1)⽂件包含 #include2)宏定义 #define3)条件编译 #if #endif ..4)⼀些特殊作⽤的预定义宏a、⽂件包含处理1）⽂件包含处理⽂件包含处理”是指⼀个源⽂件可以将另外⼀个⽂件的全部内容包含进来。
Ｃ语⾔提供了#include命令⽤来实现“⽂件包含”的操作。
2）#include< > 与 #include ""的区别" "表⽰系统先在file1.c所在的当前⽬录找file1.h，如果找不到，再按系统指定的⽬录检索。
< >表⽰系统直接按系统指定的⽬录检索。
注意：1. #include <>常⽤于包含库函数的头⽂件2. #include " "常⽤于包含⾃定义的头⽂件 （⾃定义的头⽂件常⽤“ ”，因为使⽤< >时需要在系统⽬录检索中加⼊⾃定义头⽂件的绝对地址/相对地址否则⽆法检索到该⾃定义的头⽂件，编译时会报错）3. 理论上#include可以包含任意格式的⽂件(.c .h等) ，但我们⼀般⽤于头⽂件的包含。
b、宏定义1）基本概念在源程序中，允许⼀个标识符（宏名）来表⽰⼀个语⾔符号字符串⽤指定的符号代替指定的信息。
在C语⾔中，“宏”分为：⽆参数的宏和有参数的宏。
2）⽆参数的宏定义#define 宏名 字符串例: #define PI 3.141926在编译预处理时，将程序中在该语句以后出现的所有的PI都⽤3.1415926代替。
C语言三种预处理功能
比如#define MAX(a,b) ((a)>(b)?(a):(b))则遇到 MAX(1+2,value)则会把它替换成： ((1+2)>(value)?(1+2):(value))注意事项和无参宏差不多。 但还是应注意
#define FUN(a) "a"
则，输入 FUN(345)会被替换成什么？ 其实，如果这么写，无论宏的实参是什么，都不会影响其被替换成"a"的命运。也就是说， ""内的字符不被当成形参，即使它和一模一样。那么，你会问了，我要是想让这里输入 FUN(345)它就替换成"345"该怎么实现呢？请看下面关于#的用法
带参数
除了一般的字符串替换，还要做参数代换
格式： #define 宏名（参数表） 字符串
例如：
#define S(a,b) a*b area=S(3,2)；//第一步被换为 area=a*b; ，第二步被换为 area=3*2;
（1）实参如果是表达式容易出问题
#define S(r) r*r area=S(a+b);//第一步换为 area=r*r;,第二步被换为 area=a+b*a+b;
值传递、返回值）。
冷门重点编辑
#define 用法
1、用无参宏定义一个简单的常量
#define LEN 12
这个是最常见的用法，但也会出错。比如下面几个知识点你会吗？可以看下：
（1）#define NAME "zhangyuncong" 程序中有"NAME"则，它会不会被替换呢？ （2）#define 0x abcd 可以吗？也就是说，可不可以用不是标识符的字母替换成别的东 西？ （3）#define NAME "zhang 这个可以吗？ （4）#define NAME "zhangyuncong" 程序中有上面的宏定义，并且，程序里有句： NAMELIST 这样，会不会被替换成"zhangyuncong"LIST 四个题答案都是十分明确的。 第一个，""内的东西不会被宏替换。这一点应该大家都知道; 第二个，宏定义前面的那个必须是合法的用户标识符; 第三个，宏定义也不是说后面东西随便写，不能把字符串的两个""拆开; 第四个：只替换标识符，不替换别的东西。NAMELIST 整体是个标识符，而没有 NAME 标识符，所以不替换。 也就是说，这种情况下记住：#define 第一位置第二位置 （1） 不替换程序中字符串里的东西； （2） 第一位置只能是合法的标识符（可以是关键字）； （3） 第二位置如果有字符串，必须把""配对； （4） 只替换与第一位置完全相同的标识符。 还有就是老生常谈的话：记住这是简单的替换而已，不要在中间计算结果，一定要替换出 表达式之后再算。
C语言-预处理命令
我们可以在C源程序中插入传给编译程序的各中指令，这些指令被称为预处理器指令，它们扩充了程序设计的环境。
现把常用的预处理命令总结如下：1. 预处理程序按照ANSI标准的定义，预处理程序应该处理以下指令：#if #ifdef #ifndef #else #elif#endif#define#undef#line#error#pragma#include显然，上述所有的12个预处理指令都以符号#开始，，每条预处理指令必须独占一行。
2. #define#define指令定义一个标识符和一个串（也就是字符集），在源程序中发现该标识符时，都用该串替换之。
这种标识符称为宏名字，相应的替换称为宏代换。
一般形式如下：#define macro-name char-sequence这种语句不用分号结尾。
宏名字和串之间可以有多个空白符，但串开始后只能以新行终止。
例如：我们使用LEFT代表1，用RIGHT代表0，我们使用两个#define指令：#define LEFT 1#define RIGHT 0每当在源程序中遇到LEFT或RIGHT时，编译程序都用1或0替换。
定义一个宏名字之后，可以在其他宏定义中使用,例如：#define ONE 1#define TWO ONE+ONE#define THREE ONE+TWO宏代换就是用相关的串替代标识符。
因此，如果希望定义一条标准错误信息时，可以如下定义：#define ERROR_MS “Standard error on input \n”如果一个串长于一行，可在行尾用反斜线”\”续行，如下：#define LONG_STRING “This is a very very long \String that i s used as an example”3. #error#error指令强制编译程序停止编译，它主要用于程序调试。
#error指令的一般形式是：#error error-message注意，宏串error-message不用双引号包围。
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.4 预定义宏
• 预定义宏是C编译器预先定义好的宏，不是 用户定义的，因而不能出现在＃define与＃ undef语句中。 • 如： _ _FILE_ _ _ _DATE_ _ 等一些常见预定义宏标识符。
【例】预定义宏使用举例。
main() { printf("%s\n",__FILE__); printf("%s\n",__DATE__); printf("%s\n",__TIME__); }
结果显示： c:\data\a.c May 22 2001 21:02:54
9.5 运算符＃和＃＃
在带参数的宏替换中，若形参中含有＃： • #：
“字符串” • 例如： #字符串 #define display(i) printf(#i) ……；display(This is a test);…… 则替换为：printf(“This is a test”);
若有宏定义：#define MOD(x,y) x%y
则执行以下语句后的输出为＿＿＿＿
int z, a=15, b=100; z=MOD(b,a); printf(“%d\n”,z++); A 11 C 6 B 10 D 宏定义不合法
若有宏定义如下： #define x 5 #define Y X+1 #define Z Y*X/2 那么执行以下printf语句后，输出结果是____. int a; a=Y; printf(“%d\n”,Z); printf(“%d\n”,--a); A 7 B 12 C 12 D 7 6 6 5 5
＃include “文件名称” ＃include <文件名称>
• 在一些版本的C语言中，还允许“文件名”中 带路径。
C语言预处理命令详解
C语⾔预处理命令详解⼀前⾔预处理(或称预编译)是指在进⾏编译的第⼀遍扫描(词法扫描和语法分析)之前所作的⼯作。
预处理指令指⽰在程序正式编译前就由编译器进⾏的操作，可放在程序中任何位置。
预处理是C语⾔的⼀个重要功能，它由预处理程序负责完成。
当对⼀个源⽂件进⾏编译时，系统将⾃动引⽤预处理程序对源程序中的预处理部分作处理，处理完毕⾃动进⼊对源程序的编译。
C语⾔提供多种预处理功能，主要处理#开始的预编译指令，如宏定义(#define)、⽂件包含(#include)、条件编译(#ifdef)等。
合理使⽤预处理功能编写的程序便于阅读、修改、移植和调试，也有利于模块化程序设计。
本⽂参考诸多资料，详细介绍常⽤的⼏种预处理功能。
因成⽂较早，资料来源⼤多已不可考，敬请谅解。
⼆宏定义C语⾔源程序中允许⽤⼀个标识符来表⽰⼀个字符串，称为“宏”。
被定义为宏的标识符称为“宏名”。
在编译预处理时，对程序中所有出现的宏名，都⽤宏定义中的字符串去代换，这称为宏替换或宏展开。
宏定义是由源程序中的宏定义命令完成的。
宏替换是由预处理程序⾃动完成的。
在C语⾔中，宏定义分为有参数和⽆参数两种。
下⾯分别讨论这两种宏的定义和调⽤。
2.1 ⽆参宏定义⽆参宏的宏名后不带参数。
其定义的⼀般形式为：#define 标识符字符串其中，“#”表⽰这是⼀条预处理命令(以#开头的均为预处理命令)。
“define”为宏定义命令。
“标识符”为符号常量，即宏名。
“字符串”可以是常数、表达式、格式串等。
宏定义⽤宏名来表⽰⼀个字符串，在宏展开时⼜以该字符串取代宏名。
这只是⼀种简单的⽂本替换，预处理程序对它不作任何检查。
如有错误，只能在编译已被宏展开后的源程序时发现。
注意理解宏替换中“换”的概念，即在对相关命令或语句的含义和功能作具体分析之前就要进⾏⽂本替换。
【例1】定义常量：1#define MAX_TIME 1000若在程序⾥⾯写if(time < MAX_TIME){.........}，则编译器在处理该代码前会将MAX_TIME替换为1000。
c语言中的预处理
c语言中的预处理
C语言中的预处理是指在编译程序开始之前，先对源程序进行一些处理，以便于后续的编译过程更加高效和准确。
预处理程序通常包括以下几个步骤：
1. 文件包含：使用#include指令将其他文件中的代码插入到当前文件中，以便于复用和管理代码。
2. 宏定义：使用#define指令定义宏，将代码中经常出现的重复内容替换为宏名，以减少代码量和提高可读性。
3. 条件编译：使用#ifdef、#ifndef、#if、#elif、#else、endif 等指令，根据编译时定义的宏来选择编译哪些代码段，以便于实现不同平台、不同版本之间的兼容性。
4. 其他预处理指令：包括#pragma、#error、#warning等，用于指定编译器的行为、输出错误信息等。
预处理程序使用特定的符号来表示不同的指令，例如#表示预处理指令的起始符号。
预处理程序的输出结果会进一步被编译器处理，生成可执行文件。
在实际的开发过程中，预处理程序可以帮助开发人员管理代码、提高代码的可读性和可维护性，同时也可以用来实现一些高级的编译器特性，如代码优化、跨平台支持等。
- 1 -。
C语言三种预处理功能
C语言三种预处理功能1. 宏定义2. 文件包含3. 条件编译伪指令（或预处理指令）定义：预处理指令是以#号开头的代码行。
#号必须是该行除了任何空白字符外的第一个字符。
#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。
整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。
下面是部分预处理指令：指令用途 # 空指令，无任何效果 #include 包含一个源代码文件 #define 定义宏 #undef 取消已定义的宏 #if 如果给定条件为真，则编译下面代码 #ifdef 如果宏已经定义，则编译下面代码 #ifndef 如果宏没有定义，则编译下面代码 #elif 如果前#if条件不为真，当前条件为真，则编译下面代码，其实就是else if的简写 #endif 结束一个#if……#else条件编译块 #error 停止编译并显示错误信息特殊符号预编译程序可以识别一些特殊的符号。
预编译程序对于在源程序中出现的这些串将用合适的值进行替换。
注意，是双下划线，而不是单下划线。
FILE包含当前程序文件名的字符串LINE表示当前行号的整数DATE包含当前日期的字符串STDC如果编译器遵循ANSI C标准，它就是个非零值TIME包含当前时间的字符串//例#include<stdio.h> int main() { printf("Hello World!\n"); printf("%s\n",__FILE__); printf("%d\n",__LINE__); return 0; }1. 宏定义不带参数宏定义又称为宏代换、宏替换，简称“宏”。
预处理（预编译）工作也叫做宏展开：将宏名替换为字符串，即在对相关命令或语句的含义和功能作具体分析之前就要换。
格式：#define 标识符字符串其中标识符就是所谓的符号常量，也称为“宏名”。
C语言的预处理程序与注释
C语言的预处理程序与注释C程序的源代码中可包括各种编译指令，这些指令称为预处理命令。
虽然它们实际上不是C语言的一部分，但却扩展了C程序设计的环境。
本节将介绍如何应用预处理程序和注释简化程序开发过程，并提高程序的可读性。
1、C语言的预处理程序ANSI标准定义的C语言预处理程序包括下列命令：#define #error ＃include #if#else #elif #endif #ifdef#ifndef #indef #line #pragma非常明显，所有预处理命令均以符号＃开头，下面分别加以介绍。
2、#define命令＃define定义了一个标识符及一个串。
在源程序中每次遇到该标识符时，均以定义的串代换它。
ANSI标准将标识符定义为宏名，将替换过程称为宏替换。
命令的一般形式为：＃define identifier string注意，该语句没有分号。
在标识符和串之间可以有任意个空格，串一旦开始，仅由一新行结束。
例如，如希望TURE取值１，FALSE取值０，可说明两个宏#define#define TURE 1#define FALSE 0这使得在源程序中每次遇到TURE或FALSE就用０或１代替。
例如，在屏幕上打印“012”:printf("%d%d%d"，FALSE，TRUE，TRUE+1)；宏名定义后，即可成为其它宏名定义中的一部分。
例如，下面代码定义了O NE、TWO及THREE的值。
#define ONE 1#define TWO ONE+ONE#define THREE ONE+TWO懂得宏替换仅仅是以串代替标识符这点很重要。
因此，如果希望定义一个标准错误信息，可编写如下代码：#define E_MS "standard error on input\n"printf(E_MS)；编译程序遇到标识符E_MS时，就用“standard error on input\n”替换。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
宏定义
对于宏定义的说明
宏名在源程序中若用引号括起来，则预处理程 序不对其作宏代换 宏定义允许嵌套，在宏定义的字符串中可以使 用已经定义的宏名。在宏展开时由预处理程序 层层代换 习惯上宏名用大写字母表示，以便于与变量区 别。但也允许用小写字母 对“输出格式”作宏定义，可以减少书写麻烦
采用条件编译，则根据条件只编译其中的 程序段1或程序段2，生成的目标程序较短
如果条件选择的程序段很长，采用条件编 译的方法是十分必要的
预处理命令
概念：
所谓预处理是指在进行编译的第一遍扫描(词法 扫描和语法分析)之前所作的工作。预处理是Ｃ 语言的一个重要功能，它由预处理程序负责完 成。当对一个源文件进行编译时，系统将自动 引用预处理程序对源程序中的预处理部分作处 理，处理完毕自动进入对源程序的编译。
预处理命令
作用：
Ｃ语言提供了多种预处理功能，如宏定义、文 件包含、条件编译等。合理地使用预处理功能 编写程序,能够使程序 便于阅读、修改、移植和调试， 也有利于模块化程序设计。
C 语言程序设计
预处理命令
周闻钧 朱宏明
本讲内容
概述 宏定义
无参宏定义 带参宏定义
文件包含 条件包含 实例
预处理命令
位置： 在前面各章中，已多次使用过以“ #” 号开头的 预处理命令。如包含命令 #include ，宏定义命 令#define等。在源程序中这些命令都放在函数 之外，而且一般都放在源文件的前面，它们称 为预处理部分。
宏定义
对于宏定义的说明
宏定义是用宏名来表示一个字符串，在宏展开时又以 该字符串取代宏名，这只是一种简单的代换，字符串 中可以含任何字符，可以是常数，也可以是表达式， 预处理程序对它不作任何检查。如有错误，只能在编 译已被宏展开后的源程序时发现 宏定义不是说明或语句，在行末不必加分号，如加上 分号则连分号也一起置换 宏定义必须写在函数之外，其作用域为宏定义命令起 到源程序结束。如要终止其作用域可使用#undef命令
文件包含
对于文件包含的说明
包含命令中的文件名可以用双引号括起来，也可以用 尖括号括起来
使用尖括号表示在包含文件目录中去查找(包含目录是由用户 在设置环境时设置的)，而不在源文件目录去查找 使用双引号则表示首先在当前的源文件目录中查找，若未找到 才到包含目录中去查找。用户编程时可根据自己文件所在的目 录来选择某一种命令形式
宏定义
Ｃ语言允许宏带有参数。在宏定义中的参数称为 形式参数，在宏调用中的参数称为实际参数 对带参数的宏，在调用中，不仅要宏展开，而且 要用实参去代换形参 带参宏定义的一般形式为
#define 宏名(形参表) 字符串 在字符串中含有各个形参 宏名(实参表)；
带参宏调用的一般形式为
宏定义
对于带参宏定义的说明
带参宏定义中，宏名和形参表之间不能有空格出现 在带参宏定义中，形式参数不分配内存单元，因此不 必作类型定义。而宏调用中的实参有具体的值。要用 它们去代换形参，因此必须作类型说明。这是与函数 中的情况不同的。在函数中，形参和实参是两个不同 的量，各有自己的作用域，调用时要把实参值赋予形 参，进行“值传递”。而在带参宏中，只是符号代换， 不存在值传递的问题 在宏定义中的形参是标识符，而宏调用中的实参可以 是表达式
宏定义
无参宏的宏名后不带参数 其定义的一般符串
其中的“#”表示这是一条预处理命令。凡 是以“#”开头的均为预处理命令。 “define”为宏定义命令。“标识符”为所 定义的宏名。“字符串”可以是常数、表 达式、格式串等
宏定义
在前面介绍过的符号常量的定义就是一种 无参宏定义。此外，常对程序中反复使用 的表达式进行宏定义 例如：#define M (y*y+3*y)它的作用是指 定标识符M来代替表达式(y*y+3*y)。在编 写源程序时，所有的(y*y+3*y)都可由M代 替，而对源程序作编译时，将先由预处理 程序进行宏代换，即用(y*y+3*y)表达式去 置换所有的宏名M，然后再进行编译。
第三种形式：
#if 常量表达式 程序段1 #else 程序段2 #endif
它的功能是，如常量表达式的值为真(非0)，则对 程序段1 进行编译，否则对程序段2进行编译。因 此可以使程序在不同条件下，完成不同的功能
条件编译
条件编译当然也可以用条件语句来实现
用条件语句将会对整个源程序进行编译， 生成的目标代码程序很长
宏定义
对于带参宏定义的说明
在宏定义中，字符串内的形参通常要用括号括 起来以避免出错 对于宏定义不仅应在参数两侧加括号，也应在 整个字符串外加括号 宏定义也可用来定义多个语句，在宏调用时， 把这些语句又代换到源程序内
文件包含
文件包含是C预处理程序的另一个重要功能 文件包含命令行的一般形式为
宏定义
在Ｃ语言源程序中允许用一个标识符来表示一个 字符串，称为“宏”。被定义为“宏”的标识符 称为“宏名”。在编译预处理时，对程序中所有 出现的“宏名”，都用宏定义中的字符串去代换， 这称为“宏代换”或“宏展开”。 宏定义是由源程序中的宏定义命令完成的。宏代 换是由预处理程序自动完成的。 在Ｃ语言中，“宏”分为有参数和无参数两种。
宏定义
上例程序中首先进行宏定义，定义M来替代 表达式(y*y+3*y),在s=3*M+4*M+5* M中作 了宏调用。在预处理时经宏展开后该语句 变为： s=3*(y*y+3*y)+4*(y*y+3*y)+5*(y*y+3*y);
#define M (y*y+3*y) main(){ int s,y; printf("input a number: scanf("%d",&y); s=3*M+4*M+5*M; printf("s=%d\n",s); }
");
宏定义
但要注意的是，在宏定义中表达式 (y*y+3*y)两边的括号不能少。否则会发生 错误。如当作以下定义后：#define M y*y+3*y,在宏展开时将得到下述语句： s=3*y*y+3*y+4*y*y+3*y+5*y*y+3*y； 这相当于：3y2+3y+4y2+3y+5y2+3y； 显然与原题意要求不符。计算结果当然是 错误的。因此在作宏定义时必须十分注意。 应保证在宏代换之后不发生错误
#include "文件名“
在前面我们已多次用此命令包含过库函数 的头文件
例如 #include"stdio.h" #include"math.h"
文件包含
文件包含命令的功能是把指定的文件插入该命令 行位置取代该命令行，从而把指定的文件和当前 的源程序文件连成一个源文件 在程序设计中，文件包含是很有用的。一个大的 程序可以分为多个模块，由多个程序员分别编程。 有些公用的符号常量或宏定义等可单独组成一个 文件，在其它文件的开头用包含命令包含该文件 即可使用。这样，可避免在每个文件开头都去书 写那些公用量，从而节省时间，并减少出错
条件编译
第一种形式：
#ifdef 标识符 程序段1 #else 程序段2 #endif
它的功能是，如果标识符已被 #define命令定义过则对程 序段1进行编译；否则对程序段2进行编译。如果没有程序 段2(它为空)，本格式中的#else可以没有，即可以写为：
#ifdef 标识符 程序段 #endif
条件编译
第二种形式：
#ifndef 标识符 程序段1 #else 程序段2 #endif
与第一种形式的区别是将ifdef改为ifndef。它的 功能是，如果标识符未被#define命令定义过则对 程序段1进行编译，否则对程序段2进行编译。这 与第一种形式的功能正相反
条件编译
一个include命令只能指定一个被包含文件，若有多个 文件要包含，则需用多个include命令 文件包含允许嵌套，即在一个被包含的文件中又可以 包含另一个文件
条件编译
预处理程序提供了条件编译的功能 按不同的条件去编译不同的程序部分，因而产生 不同的目标代码文件。这对于程序的移植和调试 是很有用的 条件编译有三种形式