C语言预处理命令总结大全

合集下载

c语言预处理命令之条件编译(ifdefelseendifif等)

c语言预处理命令之条件编译(ifdefelseendifif等)

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"为了避免那些只能包含一次的头文件被多次包含,可以在头文件中用编译时条件来进行控制。

c语言的预处理指令分3种  1宏定义  2条件编译  3文件包含

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语言第7章预处理命令

C语言第7章预处理命令

7.1.3 撤消宏定义命令 撤消宏定义命令#undef
宏定义命令#define应该写在函数外面,其作用 应该写在函数外面, 宏定义命令 应该写在函数外面 域为该命令之后到该源文件结束; 域为该命令之后到该源文件结束; 也可以用命令#undef撤消已定义的宏,终止该 撤消已定义的宏, 也可以用命令 撤消已定义的宏 宏定义的作用域. 宏定义的ne,#undef命令 , 命令
宏定义就是利用#define命令,用一个标识符(即名字) 命令,用一个标识符(即名字) 宏定义就是利用 命令 代表一个字符串. 代表一个字符串 已经定义的宏还可以用命令#undef撤消. 撤消. 已经定义的宏还可以用命令 撤消
#include "stdio.h" #define PI 3.1415926 main() {int r=4; float l,s,v; l=2*PI*r; s=PI*r*r;
10 20 30 40 50 60 70 80 10 20 30 40 50 60 70
#include "stdio.h" #define N 3+4 main() { int x,y; x=2*N; y=2*(N); printf("x=%d\ny=%d\n",x,y); }
运行结果: 运行结果: x=10 y=14
字符串中含有圆括号中所指定的参数. 字符串中含有圆括号中所指定的参数. 例: #define S(a,b) a*b main( ) { … area=S(3,2); … }
程序用了S(3,2),在宏展开时, ,在宏展开时, 程序用了 代替S(3*2),赋值语句展 用3*2代替 代替 , 开为: 开为:area=3*2;
v=4.0/3*PI*r*r*r; }

C语言程序设计教程CJ_04预处理命令_潭浩强第3版

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:

C语言编译预处理命令

C语言编译预处理命令

编译预处理命令文件包含:把指定的文件插入到预处理命令行所在的位置并取代该命令行,即把指定的文件与当前的源程序文件连接成一个源文件。

#include<文件名>在文件包含目录中去查找指定的文件,并将该文件添加到源文件中。

一个被包含的文件中可以含有文件包含命令来包含另一个文件。

#include“文件名”命令中文件名的位置是当前源文件的位置,若在当前目录中未找到该文件,则再到“包含目录”中去查找。

宏用一个标识符表示一个字符串,称为宏,被定义为宏的标识符称为宏名。

在编译预处理时对程序中所有出现的宏名用宏定义中的字符串去代换,这就是宏替换。

它是由系统编译程序时自动完成的。

无参宏定义#define 标识符字符串如#define PI 3.14使用宏时要注意:(1)宏定义是用宏名来表示一个字符串,在宏展开时用字符串取代宏名。

(2)宏定义不是变量定义或语句,在行末不能加分号,如果加上分号则分号也成为字符串的一部分。

(3)宏定义可以出现在程序的任何地方,其作用域是宏定义命令所在位置开始到源程序结束。

如果要终止其作用域可使用#undef命令。

(4)宏定义允许嵌套,在宏定义的字符串中可以使用已经定义的宏名。

在宏展开时将逐层替换。

(5)#define PI 3.1415926#define AREA PI*y*y有参宏定义#define 宏名(形参表)字符串对带参数的宏,在调用中不仅要进行宏展开,而且还要用实参去替换形参。

带参宏调用的语法格式如下:宏名(实参表);#define M(x) x+1K=M(3);K=3+1定义有参宏时要注意以下几点:(1)有参宏定义中,宏名与形参表之间不能有空格出现。

(2)在函数中,调用时要把实参的值赋给形参,进行“值传递”。

而在带参宏调用中,只是符号替换,不存在值传递问题。

(3)宏定义中的形参只能是标识符,而宏调用中的实参可以是表达式。

宏替换中对实参表达式不做计算直接照原样替换,字符串内的形参通常用括号括起来以避免出错。

c语言程序中的预编译命令

c语言程序中的预编译命令

c语言程序中的预编译命令预编译命令是在编译之前就交由编译器进行相关处理的指令,通常以"#"开头。

预编译命令在整个程序开始编译之前就已经执行。

以下是一些常用的预编译命令:1. #include:用于引入头文件。

例如:```C#include <stdio.h> //引入标准输入输出头文件#include "myheader.h" //引入自定义头文件myheader.h```2. #define:用于定义宏。

例如:```C#define PI 3.14159 //定义宏PI,宏的值是3.14159```3. #undef:用于取消之前定义的宏。

例如:```C#undef PI //取消之前定义的宏PI```4. #ifdef,#ifndef,#endif:用于条件编译。

例如:```C#ifdef PI// 如果宏PI已被定义,则编译以下代码#endif#ifndef PI// 如果宏PI未被定义,则编译以下代码#endif```5. #if, #else, #elif:也是用于条件编译。

例如:```C#if defined(PI)//如果宏PI已被定义,则编译以下代码#else//如果宏PI未被定义,则编译以下代码#endif```6. #error:当某些条件不满足时,输出错误并停止编译。

例如:```C#error "Something went wrong"```7. #pragma:用于实现一些特殊的功能,这个指令和编译器实现有关。

例如:```C#pragma pack(1) //设置结构体的对齐方式为1字节对齐```。

C语言程序设计-谭浩强-第9章预处理命令

C语言程序设计-谭浩强-第9章预处理命令
例 #define S (r) PI*r*r 例 #define POWER(x) x*x 相当于定义了不带参宏S,代表字符串“(r) PI*r*r” x=4; y=6; z=POWER(x+y); 宏展开:z=x+y*x+y; 一般写成: #define POWER(x) ((x)*(x)) 宏展开: z=((x+y)*(x+y));
17/14
§9.1 宏定义 宏体可缺省,表示宏名
不带参数宏定义
定义过或取消宏体
一般形式: 宏体] 一般形式: #define 宏名 [宏体 宏体 功能:用指定标识符 宏名)代替字符序列 宏体) 用指定标识符(宏名 代替字符序列(宏体 功能 用指定标识符 宏名 代替字符序列 宏体
如 #define 定义位置:任意YES 1 一般在函数外面) 定义位置 任意(一般在函数外面 任意 一般在函数外面 #define 例 NO 0 YES #define 1 作用域:从定义命令到文件结束 作用域 从定义命令到文件结束 main() #define PI 3.1415926 #define OUT printf(“Hello,World”); { …….. YES原作用域 #undef可终止宏名作用域 可 } 格式: 格式: #undef 宏名 #undef YES 宏展开:预编译时,用宏体替换宏名 用宏体替换宏名---不作语法检查 宏展开:预编译时 用宏体替换宏名 不作语法检查 #define YES 0 max() 引号中的内容与宏名相同也不置换 YES新作用域 {…….. if(x==YES)WIDTH 80 如 例 #define WIDTH 80 printf(“correct!\n”); 例 #define 宏定义可嵌套, 宏定义可嵌套,不能递归 } else if (x==NO)( WIDTH+40 ) printf(“error!\n”); #define #define LENGTH 3.14159 例 #define PI LENGTH WIDTH+40 宏定义中使用必要的括号() 宏定义中使用必要的括号() 展开后: if(x==1) 展开后var=LENGTH*2; : var=LENGTH*2;printf(“correct!\n”); (×) printf(“2*PI=%f\n”,PI*2); 例 #define MAX MAX+10 × else 宏展开: 宏展开: :printf(“2*PI=%f\n”,3.14159*2); 宏展开 宏展开:var= ((x==0) ) * 2;printf(“error!\n”); 宏展开: if 80+40 宏展开 :var= 80+40*2;

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 test使⽤宏printf(“XYZ”)。

该段不打印“this is a test”⽽打印“XYZ”。

因为预编译器识别出的是“XYZ”4. 如果串长于⼀⾏,在该⾏末尾加上\#define LONG_STRING "this is a very long\string that is used as an example"5. 普遍使⽤⼤写字母定义标识符。

6. ⽤宏代换代替实在的函数的⼀⼤好处是宏替换增加了代码的速度,因为不存在函数调⽤的开销。

但增加速度也有代价:由于重复编码⽽增加了程序长度。

#error#error强迫编译程序停⽌编译,主要⽤于程序调试。

#error指令使预处理器发出⼀条错误消息,该指令的作⽤就是在程序崩溃之前给出⼀定的信息。

#include#include使编译程序将另⼀源⽂件嵌⼊带#include的源⽂件,被读⼊的源⽂件必须⽤双引号或尖括号括起来。

c语言程序的基本结构

c语言程序的基本结构

c语言程序的基本结构C语言是一种广泛应用于计算机编程的高级编程语言,被广泛应用于系统软件、应用软件、嵌入式系统等领域。

了解C语言程序的基本结构对于学习和理解C语言的编程技巧以及写出高效、稳定、易于维护的代码至关重要。

本文将介绍C语言程序的基本结构,以便读者快速上手和编写C语言程序。

一、预处理指令C语言程序通常以预处理指令开始,预处理器会根据这些指令对代码进行预处理,例如移除注释、插入文件等操作。

预处理指令以"#"开头,常见的预处理指令包括:1. #include:用于包含文件,将指定的文件内容插入到当前位置。

例如:`#include <stdio.h>`表示包含标准输入输出头文件。

2. #define:用于定义宏,将一段代码标识为一个宏,并在后续代码中使用。

例如:`#define PI3.14159`定义了一个名为PI的宏,它的值是3.14159。

二、函数声明在C语言程序中,函数是代码的基本组织单元。

函数声明用于向编译器说明函数的名称、参数个数和类型以及返回值类型。

函数声明的语法如下:```返回值类型函数名(参数列表);```例如,以下是一个函数声明的例子:```int add(int a, int b);```三、主函数C语言程序必须包含一个特殊的函数,称为主函数(main函数)。

主函数是程序的入口点,程序在运行时会从主函数开始执行。

主函数的基本结构如下:```返回值类型 main(参数列表) {// 函数体return 0;}```其中,返回值类型通常为int,表示函数执行完成后返回的结果。

参数列表是通过命令行传递给程序的参数,可以为空。

函数体中编写程序的具体逻辑,return语句用于返回结果并结束函数的执行。

```int main() {printf("Hello, World!");return 0;}```四、函数定义函数定义用于给出函数的具体实现。

C语言#define用法总结

C语言#define用法总结

C语言#define用法总结黄海涛,2012-3-3如果你还在为使用#define而迷茫,那请阅读这篇文章;如果读完之后你还在迷茫,那请哪天心情好了,再回来读一遍。

:)欢迎跟着我的思路走……一、概述1、宏定义在C语言中,以#开头的为预处理命令。

定义形式:2、本质其本质是:使用宏定义中的字符串替换(Substitution)宏名。

这只是一种简单的代换,预处理程序对它不作任何检查。

如有错误,只能在编译已被宏展开后的源程序时发现。

3、替换时机预处理是指在进行编译的第一遍扫描(词法扫描和语法分析)之前所作的工作。

由预处理程序负责完成。

在源程序被编译之前,宏替换已经完成,其流程如下:源程序→预处理程序→预处理后的源程序→编译器4、作用域其作用域为宏定义命令起到源程序结束。

如要终止其作用域可使用# undef命令。

5、优缺点▲优点:宏定义使用得当,可以防止出错,提高可移植性,可读性等等;减少函数调用的开销。

▲缺点:可能存在参数副作用;展开后可能比函数调用开销更大。

※规则一:保证在宏替换之后不会发生错误。

二、无参宏定义1、定义的一般形式#define identifier token-sequence#define 标识符字符串2、简单常量●约束1:宏名通常采用易读大写字母表示。

●约束2:宏定义不是说明或语句,在行末不必加分号,如加上分号则连分号也一起替换。

●约束3:宏名在源程序中若用引号引起来,则预处理程序不对其作宏替换。

如:3、字符串为表达式※规则二:无参宏定义中字符串为表达式(即含有运算符),必须加小括号()。

可见,有括号与无括号差别很大,请小心加括号,保证展开后是你所期望的。

参考规则一。

4、5、6三、带参宏定义对带参数的宏,在调用中,不仅要宏展开,而且要用实参去代换形参。

1、带参宏定义的一般形式为:#define identifier(identifier-list) token-sequence#define 宏名(形参表) 字符串在字符串中含有各个形参,形参是标识符。

C语言-预处理命令

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不用双引号包围。

10_c语言编译预处理

10_c语言编译预处理

编译预处理学习要点:1.C程序中,以“#”符号开头的命令是在源程序正式编译前进行处理的,称为“编译预处理”命令。

注意,这里是“命令”,而不是语句,因此最后不能加分号。

一行只能写一个预处理命令行。

C程序中,“宏名”一般用大写,并且中间不能有空格。

2.“宏”定义的作用是当程序中出现“宏名”时,就在“宏名”的位置用对应的“一串符号”替换。

注意,这里纯粹就是“替换”,相当于用“一串符号”去“涂改” “宏名”。

如:#define PI 3.1416 程序中有a=r*r* PI ; 则替换为a=r*r* 3.1416 ;3.带参的“宏”定义也纯粹就是替换。

进行宏替换时,先用实参替换“一串符号”中的形参,然后再用被替换过的“一串符号”替换“宏名(形参表)”。

4.程序中,用双引号括起来的不是宏,不被替换。

5.对带参的“宏”定义,在替换时不要人为的加“括号”。

如:#define W(r) 3.14*r*r 当a=W(a+b); 正确的替换是a=3.14*a+b*a+b; 而不是a=3.14*(a+b)*(a+b) 这两个括号是人为加的。

当然,如果我们是想求半径为a+b的面积时就发生了错误,这时应该把“宏”定义写成#define W(r) 3.14*(r)*(r) 因此,为了在调用过程中不出现二义性,应该把字符序列中出现的参数全部用括号括起来。

6.文件包含编译预处理命令有两种格式:”包含文件名” 和<包含文件名>。

前者,系统先在本程序文件所在的磁盘和路径下寻找包含文件;若找不到,再按系统规定的路径搜索包含文件。

后者,系统仅按系统规定的路径搜索包含文件。

7.“包含文件”可以是任意的文件名扩展名,可以是 .h 也可以是.c ,还可以是其他扩展名。

文件名前还可以加上路径,如:#incl ude “d:\user\file1.c”8.带参数的main()函数是用于在用命令行的形式运行.exe程序文件时接收参数的。

C语言预处理命令

C语言预处理命令

编译预处理作业
程序2: 程序 : # include <stdio.h> int square(int x) {return(x*x); } main() {int i=1; while(i<=5) printf("%d\n",square(i++)); }
编译预处理
文件包含 格式1: 格式1: 文件标识” #include “[d:][path] 文件标识” 按路径搜索….h文件,若找不到, .h文件 按路径搜索 .h文件,若找不到,则按 系统指定的目录搜索。 系统指定的目录搜索。 格式2: 格式2: <头文件名 头文件名> #include <头文件名> 仅按系统指定的目录搜索。 仅按系统指定的目录搜索。Turbo C 默 认为tc include目录 VC安装路径下 tc\ 目录。 认为tc\include目录。VC安装路径下 的include 目录
编译预处理
对语句a=SQARE(n+1) 对语句a=SQARE(n+1) 1、将替换为a=n+1*n+1; 将替换为a=n+1*n+1; 2、将替换为a=(n+1)*(n+1); 将替换为a=(n+1)*(n+1); 将替换为a=((n+1)*(n+1)); 3、将替换为a=((n+1)*(n+1)); 对语句a=2.7/SQARE(3.0) 对语句a=2.7/SQARE(3.0) 将替换为a=2.7/(3.0)*(3.0); 2、将替换为a=2.7/(3.0)*(3.0); 将替换为a=2.7/((3.0)*(3.0)); 3、将替换为a=2.7/((3.0)*(3.0));

C语言中的预编译宏定义

C语言中的预编译宏定义

C语言中的预编译宏定义C语言中的预编译宏定义导语:C初学者可能对预处理器没什么概念,这是情有可原,下面是C中的预编译宏定义,一起来学习下吧:(一) 预处理命令简介预处理命令由#(hash字符)开头, 它独占一行, #之前只能是空白符. 以#开头的语句就是预处理命令, 不以#开头的语句为C中的代码行. 常用的预处理命令如下:#define 定义一个预处理宏#undef 取消宏的定义#include 包含文件命令#include_next 与#include相似, 但它有着特殊的用途#if 编译预处理中的条件命令, 相当于C语法中的if语句#ifdef 判断某个宏是否被定义, 若已定义, 执行随后的语句#ifndef 与#ifdef相反, 判断某个宏是否未被定义#elif 若#if, #ifdef, #ifndef或前面的#elif条件不满足, 则执行#elif 之后的语句, 相当于C语法中的else-if#else 与#if, #ifdef, #ifndef对应, 若这些条件不满足, 则执行#else 之后的语句, 相当于C语法中的else#endif #if, #ifdef, #ifndef这些条件命令的结束标志.defined 与#if, #elif配合使用, 判断某个宏是否被定义#line 标志该语句所在的行号# 将宏参数替代为以参数值为内容的字符窜常量## 将两个相邻的标记(token)连接为一个单独的标记#pragma 说明编译器信息#warning 显示编译警告信息#error 显示编译错误信息(二) 预处理的文法预处理并不分析整个源代码文件, 它只是将源代码分割成一些标记(token), 识别语句中哪些是C语句, 哪些是预处理语句. 预处理器能够识别C标记, 文件名, 空白符, 文件结尾标志.预处理语句格式: #command name(...) token(s)1, command预处理命令的名称, 它之前以#开头, #之后紧随预处理命令, 标准C允许#两边可以有空白符, 但比较老的编译器可能不允许这样. 若某行中只包含#(以及空白符), 那么在标准C中该行被理解为空白. 整个预处理语句之后只能有空白符或者注释, 不能有其它内容.2, name代表宏名称, 它可带参数. 参数可以是可变参数列表(C99).3, 语句中可以利用""来换行.e.g.# define ONE 1 /* ONE == 1 */等价于: #define ONE 1#define err(flag, msg) if(flag)printf(msg)等价于: #define err(flag, msg) if(flag) printf(msg)(三) 预处理命令详述1, #define#define命令定义一个宏:#define MACRO_NAME(args) tokens(opt)之后出现的MACRO_NAME将被替代为所定义的标记(tokens). 宏可带参数, 而后面的标记也是可选的.对象宏不带参数的宏被称为"对象宏(objectlike macro)"#define经常用来定义常量, 此时的宏名称一般为大写的字符串. 这样利于修改这些常量.e.g.#define MAX 100int a[MAX];#ifndef __FILE_H__#define __FILE_H__#include "file.h"#endif#define __FILE_H__ 中的宏就不带任何参数, 也不扩展为任何标记. 这经常用于包含头文件.要调用该宏, 只需在代码中指定宏名称, 该宏将被替代为它被定义的内容.函数宏带参数的宏也被称为"函数宏". 利用宏可以提高代码的运行效率: 子程序的调用需要压栈出栈, 这一过程如果过于频繁会耗费掉大量的CPU运算资源. 所以一些代码量小但运行频繁的代码如果采用带参数宏来实现会提高代码的运行效率.函数宏的参数是固定的情况函数宏的定义采用这样的方式: #define name( args ) tokens其中的args和tokens都是可选的. 它和对象宏定义上的区别在于宏名称之后不带括号.注意, name之后的左括号(必须紧跟name, 之间不能有空格, 否则这就定义了一个对象宏, 它将被替换为以(开始的字符串. 但在调用函数宏时, name与(之间可以有空格.e.g.#define mul(x,y) ((x)*(y))注意, 函数宏之后的参数要用括号括起来, 看看这个例子:e.g.#define mul(x,y) x*y"mul(1, 2+2);" 将被扩展为: 1*2 + 2同样, 整个标记串也应该用括号引用起来:e.g.#define mul(x,y) (x)*(y)sizeof mul(1,2.0) 将被扩展为 sizeof 1 * 2.0调用函数宏时候, 传递给它的参数可以是函数的返回值, 也可以是任何有意义的语句:e.g.mul (f(a,b), g(c,d));e.g.#define (stmt) stmt( a=1; b=2;) 相当于在代码中加入 a=1; b=2 .( a=1, b=2;) 就有问题了: 预处理器会提示出错: 函数宏的参数个数不匹配. 预处理器把","视为参数间的分隔符.((a=1, b=2;)) 可解决上述问题.在定义和调用函数宏时候, 要注意一些问题:1, 我们经常用{}来引用函数宏被定义的内容, 这就要注意调用这个函数宏时的";"问题.example_3.7:#define swap(x,y) { unsigned long _temp=x; x=y; y=_tmp}如果这样调用它: "swap(1,2);" 将被扩展为: { unsigned long _temp=1; 1=2; 2=_tmp};明显后面的;是多余的, 我们应该这样调用: swap(1,2)虽然这样的调用是正确的, 但它和C语法相悖, 可采用下面的方法来处理被{}括起来的内容:#define swap(x,y)do { unsigned long _temp=x; x=y; y=_tmp} while (0)swap(1,2); 将被替换为:do { unsigned long _temp=1; 1=2; 2=_tmp} while (0);在Linux内核源代码中对这种do-while(0)语句有这广泛的应用.2, 有的函数宏是无法用do-while(0)来实现的, 所以在调用时不能带上";", 最好在调用后添加注释说明.eg_3.8:#define incr(v, low, high)for ((v) = (low),; (v) <= (high); (v)++)只能以这样的形式被调用: incr(a, 1, 10) /* increase a form 1 to 10 */函数宏中的参数包括可变参数列表的情况C99标准中新增了可变参数列表的内容. 不光是函数, 函数宏中也可以使用可变参数列表.#define name(args, ...) tokens#define name(...) tokens"..."代表可变参数列表, 如果它不是仅有的'参数, 那么它只能出现在参数列表的最后. 调用这样的函数宏时, 传递给它的参数个数要不少于参数列表中参数的个数(多余的参数被丢弃).通过__VA_ARGS__来替换函数宏中的可变参数列表. 注意__VA_ARGS__只能用于函数宏中参数中包含有"..."的情况.e.g.#ifdef DEBUG#define my_printf(...) fprintf(stderr, __VA_ARGS__)#else#define my_printf(...) printf(__VA_ARGS__)#endiftokens中的__VA_ARGS__被替换为函数宏定义中的"..."可变参数列表.注意在使用#define时候的一些常见错误:#define MAX = 100#define MAX 100;=, ; 的使用要值得注意. 再就是调用函数宏是要注意, 不要多给出";".注意: 函数宏对参数类型是不敏感的, 你不必考虑将何种数据类型传递给宏. 那么, 如何构建对参数类型敏感的宏呢? 参考本章的第九部分, 关于"##"的介绍.关于定义宏的另外一些问题(1) 宏可以被多次定义, 前提是这些定义必须是相同的. 这里的"相同"要求先后定义中空白符出现的位置相同, 但具体的空白符类型或数量可不同, 比如原先的空格可替换为多个其他类型的空白符: 可为tab, 注释...e.g.#define NULL 0#define NULL /* null pointer */ 0上面的重定义是相同的, 但下面的重定义不同:#define fun(x) x+1#define fun(x) x + 1 或: #define fun(y) y+1如果多次定义时, 再次定义的宏内容是不同的, gcc会给出"NAME redefined"警告信息.应该避免重新定义函数宏, 不管是在预处理命令中还是C语句中, 最好对某个对象只有单一的定义. 在gcc中, 若宏出现了重定义, gcc会给出警告.(2) 在gcc中, 可在命令行中指定对象宏的定义:e.g.$ gcc -Wall -DMAX=100 -o tmp tmp.c相当于在tmp.c中添加" #define MAX 100".那么, 如果原先tmp.c中含有MAX宏的定义, 那么再在gcc调用命令中使用-DMAX, 会出现什么情况呢?---若-DMAX=1, 则正确编译.---若-DMAX的值被指定为不为1的值, 那么gcc会给出MAX宏被重定义的警告, MAX的值仍为1.注意: 若在调用gcc的命令行中不显示地给出对象宏的值, 那么gcc 赋予该宏默认值(1), 如: -DVAL == -DVAL=1(3) #define所定义的宏的作用域宏在定义之后才生效, 若宏定义被#undef取消, 则#undef之后该宏无效. 并且字符串中的宏不会被识别e.g.#define ONE 1sum = ONE + TWO /* sum = 1 + TWO */#define TWO 2sum = ONE + TWO /* sum = 1 + 2 */#undef ONEsum = ONE + TWO /* sum = ONE + 2 */char c[] = "TWO" /* c[] = "TWO", NOT "2"! */(4) 宏的替换可以是递归的, 所以可以嵌套定义宏.e.g.# define ONE NUMBER_1# define NUMBER_1 1int a = ONE /* a = 1 */2, #undef#undef用来取消宏定义, 它与#define对立:#undef name如够被取消的宏实际上没有被#define所定义, 针对它的#undef 并不会产生错误.当一个宏定义被取消后, 可以再度定义它.3, #if, #elif, #else, #endif#if, #elif, #else, #endif用于条件编译:#if 常量表达式1语句...#elif 常量表达式2语句...#elif 常量表达式3语句......#else语句...#endif#if和#else分别相当于C语句中的if, else. 它们根据常量表达式的值来判别是否执行后面的语句. #elif相当于C中的else-if. 使用这些条件编译命令可以方便地实现对源代码内容的控制.else之后不带常量表达式, 但若包含了常量表达式, gcc只是给出警告信息.使用它们可以提升代码的可移植性---针对不同的平台使用执行不同的语句. 也经常用于大段代码注释.e.g.#if 0{一大段代码;}#endif常量表达式可以是包含宏, 算术运算, 逻辑运算等等的合法C常量表达式, 如果常量表达式为一个未定义的宏, 那么它的值被视为0.#if MACRO_NON_DEFINED == #if 0在判断某个宏是否被定义时, 应当避免使用#if, 因为该宏的值可能就是被定义为0. 而应当使用下面介绍的#ifdef或#ifndef.注意: #if, #elif, #else之后的宏只能是对象宏. 如果name为名的宏未定义, 或者该宏是函数宏. 那么在gcc中使用"-Wundef"选项会显示宏未定义的警告信息.4, #ifdef, #ifndef, defined.#ifdef, #ifndef, defined用来测试某个宏是否被定义#ifdef name 或 #ifndef name它们经常用于避免头文件的重复引用:#ifndef __FILE_H__#define __FILE_H__#include "file.h"#endifdefined(name): 若宏被定义,则返回1, 否则返回0.它与#if, #elif, #else结合使用来判断宏是否被定义, 乍一看好像它显得多余, 因为已经有了#ifdef和#ifndef. defined用于在一条判断语句中声明多个判别条件:#if defined(VAX) && defined(UNIX) && !defined(DEBUG)和#if, #elif, #else不同, #indef, #ifndef, defined测试的宏可以是对象宏, 也可以是函数宏. 在gcc中使用"-Wundef"选项不会显示宏未定义的警告信息.5, #include , #include_next#include用于文件包含. 在#include 命令所在的行不能含有除注释和空白符之外的其他任何内容.#include "headfile"#include#include 预处理标记前面两种形式大家都很熟悉, "#include 预处理标记"中, 预处理标记会被预处理器进行替换, 替换的结果必须符合前两种形式中的某一种.实际上, 真正被添加的头文件并不一定就是#include中所指定的文件. #include"headfile"包含的头文件当然是同一个文件, 但#include 包包含的"系统头文件"可能是另外的文件. 但这不值得被注意. 感兴趣的话可以查看宏扩展后到底引入了哪些系统头文件.关于#include "headfile"和#include 的区别以及如何在gcc中包含头文件的详细信息, 参考本blog的GCC笔记.相对于#include, 我们对#include_next不太熟悉. #include_next 仅用于特殊的场合. 它被用于头文件中(#include既可用于头文件中, 又可用于.c文件中)来包含其他的头文件. 而且包含头文件的路径比较特殊: 从当前头文件所在目录之后的目录来搜索头文件.比如: 头文件的搜索路径一次为A,B,C,D,E. #include_next所在的当前头文件位于B目录, 那么#include_next使得预处理器从C,D,E目录来搜索#include_next所指定的头文件.可参考cpp手册进一步了解#include_next6, 预定义宏标准C中定义了一些对象宏, 这些宏的名称以"__"开头和结尾, 并且都是大写字符. 这些预定义宏可以被#undef, 也可以被重定义.下面列出一些标准C中常见的预定义对象宏(其中也包含gcc自己定义的一些预定义宏:__LINE__ 当前语句所在的行号, 以10进制整数标注.__FILE__ 当前源文件的文件名, 以字符串常量标注.__DATE__ 程序被编译的日期, 以"Mmm dd yyyy"格式的字符串标注.__TIME__ 程序被编译的时间, 以"hh:mm:ss"格式的字符串标注, 该时间由asctime返回.__STDC__ 如果当前编译器符合ISO标准, 那么该宏的值为1__STDC_VERSION__ 如果当前编译器符合C89, 那么它被定义为199409L, 如果符合C99, 那么被定义为199901L.我用gcc, 如果不指定-std=c99, 其他情况都给出__STDC_VERSION__未定义的错误信息, 咋回事呢?__STDC_HOSTED__ 如果当前系统是"本地系统(hosted)", 那么它被定义为1. 本地系统表示当前系统拥有完整的标准C库.gcc定义的预定义宏:__OPTMIZE__ 如果编译过程中使用了优化, 那么该宏被定义为1.__OPTMIZE_SIZE__ 同上, 但仅在优化是针对代码大小而非速度时才被定义为1.__VERSION__ 显示所用gcc的版本号.可参考"GCC the complete reference".要想看到gcc所定义的所有预定义宏, 可以运行: $ cpp -dM /dev/null7, #line#line用来修改__LINE__和__FILE__.e.g.printf("line: %d, file: %s ", __LINE__, __FILE__);#line 100 "haha"printf("line: %d, file: %s ", __LINE__, __FILE__);printf("line: %d, file: %s ", __LINE__, __FILE__);显示:line: 34, file: 1.cline: 100, file: hahaline: 101, file: haha8, #pragma, _Pragma#pragma用编译器用来添加新的预处理功能或者显示一些编译信息. #pragma的格式是各编译器特定的, gcc的如下:#pragma GCC name token(s)#pragma之后有两个部分: GCC和特定的pragma name. 下面分别介绍gcc中常用的.(1) #pragma GCC dependencydependency测试当前文件(既该语句所在的程序代码)与指定文件(既#pragma语句最后列出的文件)的时间戳. 如果指定文件比当前文件新, 则给出警告信息.e.g.在demo.c中给出这样一句:#pragma GCC dependency "temp-file"然后在demo.c所在的目录新建一个更新的文件: $ touch temp-file, 编译: $ gcc demo.c 会给出这样的警告信息: warning: current file is older than temp-file如果当前文件比指定的文件新, 则不给出任何警告信息.还可以在在#pragma中给添加自定义的警告信息.e.g.#pragma GCC dependency "temp-file" "demo.c needs to be updated!"1.c:27:38: warning: extra tokens at end of #pragma directive1.c:27:38: warning: current file is older than temp-file注意: 后面新增的警告信息要用""引用起来, 否则gcc将给出警告信息.(2) #pragma GCC poison token(s)若源代码中出现了#pragma中给出的token(s), 则编译时显示警告信息. 它一般用于在调用你不想使用的函数时候给出出错信息.e.g.#pragma GCC poison scanfscanf("%d", &a);warning: extra tokens at end of #pragma directiveerror: attempt to use poisoned "scanf"注意, 如果调用了poison中给出的标记, 那么编译器会给出的是出错信息. 关于第一条警告, 我还不知道怎么避免, 用""将token(s)引用起来也不行.(3) #pragma GCC system_header从#pragma GCC system_header直到文件结束之间的代码会被编译器视为系统头文件之中的代码. 系统头文件中的代码往往不能完全遵循C标准, 所以头文件之中的警告信息往往不显示. (除非用#warning显式指明).(这条#pragma语句还没发现用什么大的用处)由于#pragma不能用于宏扩展, 所以gcc还提供了_Pragma:e.g.#define PRAGMA_DEP #pragma GCC dependency "temp-file"由于预处理之进行一次宏扩展, 采用上面的方法会在编译时引发错误, 要将#pragma语句定义成一个宏扩展, 应该使用下面的_Pragma语句:#define PRAGMA_DEP _Pragma("GCC dependency "temp-file"")注意, ()中包含的""引用之前引该加上转义字符.9, #, ###和##用于对字符串的预处理操作, 所以他们也经常用于printf, puts之类的字符串显示函数中.#用于在宏扩展之后将tokens转换为以tokens为内容的字符串常量.e.g.#define TEST(a,b) printf( #a "<" #b "=%d ", (a)<(b));注意: #只针对紧随其后的token有效!##用于将它前后的两个token组合在一起转换成以这两个token 为内容的字符串常量. 注意##前后必须要有token.e.g.#define TYPE(type, n) type n之后调用:TYPE(int, a) = 1;TYPE(long, b) = 1999;将被替换为:int a = 1;long b = 1999;(10) #warning, #error#warning, #error分别用于在编译时显示警告和错误信息, 格式如下:#warning tokens#error tokense.g.#warning "some warning"注意, #error和#warning后的token要用""引用起来!(在gcc中, 如果给出了warning, 编译继续进行, 但若给出了error, 则编译停止. 若在命令行中指定了 -Werror, 即使只有警告信息, 也不编译.【C语言中的预编译宏定义】。

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语⾔的⼀个重要功能,它由预处理程序负责完成。

当对⼀个源⽂件进⾏编译时,系统将⾃动引⽤预处理程序对源程序中的预处理部分作处理,处理完毕⾃动进⼊对源程序的编译。

C语⾔提供多种预处理功能,主要处理#开始的预编译指令,如宏定义(#define)、⽂件包含(#include)、条件编译(#ifdef)等。

合理使⽤预处理功能编写的程序便于阅读、修改、移植和调试,也有利于模块化程序设计。

本⽂参考诸多资料,详细介绍常⽤的⼏种预处理功能。

因成⽂较早,资料来源⼤多已不可考,敬请谅解。

⼆宏定义C语⾔源程序中允许⽤⼀个标识符来表⽰⼀个字符串,称为“宏”。

被定义为宏的标识符称为“宏名”。

在编译预处理时,对程序中所有出现的宏名,都⽤宏定义中的字符串去代换,这称为宏替换或宏展开。

宏定义是由源程序中的宏定义命令完成的。

宏替换是由预处理程序⾃动完成的。

在C语⾔中,宏定义分为有参数和⽆参数两种。

下⾯分别讨论这两种宏的定义和调⽤。

2.1 ⽆参宏定义⽆参宏的宏名后不带参数。

其定义的⼀般形式为:#define 标识符字符串其中,“#”表⽰这是⼀条预处理命令(以#开头的均为预处理命令)。

“define”为宏定义命令。

“标识符”为符号常量,即宏名。

“字符串”可以是常数、表达式、格式串等。

宏定义⽤宏名来表⽰⼀个字符串,在宏展开时⼜以该字符串取代宏名。

这只是⼀种简单的⽂本替换,预处理程序对它不作任何检查。

如有错误,只能在编译已被宏展开后的源程序时发现。

注意理解宏替换中“换”的概念,即在对相关命令或语句的含义和功能作具体分析之前就要进⾏⽂本替换。

【例1】定义常量:1#define MAX_TIME 1000若在程序⾥⾯写if(time < MAX_TIME){.........},则编译器在处理该代码前会将MAX_TIME替换为1000。

C语言程序设计 16-枚举、预处理等汇总

C语言程序设计  16-枚举、预处理等汇总
带参的宏定义在分析程序之前先进行宏展开, S(a+b,c+d)展开时用a+b代替x,用c+d代替y, 展开的结果为:a+b*c+d
24
带参的宏定义使用举例
#define S(x,y) x*y main() { int a=3,b=4,c=5,d=6;
printf("a*b=%d\n", S (aa*b, b ) ) ; printf("a+b*c+d=%d\n" , S(a((+ab+)b*()c,(+cd+)d))));; }
enum weekday day; (2) enum weekday {Sun,Mon,Tue} day; (3) enum {Sun,Mon,Tue} day;
12
三、枚举型变量的使用
1)可对枚举变量赋值,但只能把枚举元素名赋给 枚举变量,不能把枚举元素值直接赋给枚举变量。 如: enum weekday {Sun,Mon, Tue, Wed, Thu,
10
一、枚举类型的定义
• 枚举元素的值也可在定义时重指定。例如: enum weekday {Sun=7,Mon=1, Tue, Wed, Thu,
Fri, Sat} ; 对于没有指定值的元素,按顺序加1,故: Tue是2,Wed是3,…,Sat是6。
11
二、枚举型变量的定义 枚举型变量的定义也有三种方式,如: (1) enum weekday { Sun,Mon,Tue };
3)可用枚举变量进行判断或比较操作。 enum flag {true,false} my_flag; … if (my_flag == true)

二级c语言第九章预处理命令

二级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语言三种预处理功能

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 标识符字符串其中标识符就是所谓的符号常量,也称为“宏名”。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

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命令#i nclude使编译程序将另一源文件嵌入带有#include的源文件,被读入的源文件必须用双引号或尖括号括起来。

例如:#include"stdio.h"或者#include<stdio.h>这两行代码均使用C编译程序读入并编译用于处理磁盘文件库的子程序。

将文件嵌入#i nclude命令中的文件内是可行的,这种方式称为嵌套的嵌入文件,嵌套层次依赖于具体实现。

如果显式路径名为文件标识符的一部分,则仅在那些子目录中搜索被嵌入文件。

否则,如果文件名用双引号括起来,则首先检索当前工作目录。

如果未发现文件,则在命令行中说明的所有目录中搜索。

如果仍未发现文件,则搜索实现时定义的标准目录。

如果没有显式路径名且文件名被尖括号括起来,则首先在编译命令行中的目录内检索。

如果文件没找到,则检索标准目录,不检索当前工作目录。

四条件编译命令有几个命令可对程序源代码的各部分有选择地进行编译,该过程称为条件编译。

商业软件公司广泛应用条件编译来提供和维护某一程序的许多顾客版本。

#if、#else,#elif及#endif#if的一般含义是如果#if后面的常量表达式为true,则编译它与#endif之间的代码,否则跳过这些代码。

命令#endif标识一个#if块的结束。

#if constant-expressionstatement sequence#endifEg:#define MAX 91#include <iostream>using namespace std;int main(){#if MAX > 99cout<<"MAX is bigger than 99"<<endl;#elif MAX > 90cout<<"MAX is bigger than 90"<<endl;#elsecout<<"MAX is smaller than 90"<<endl;#endifreturn 0;}跟在#if后面的表达式在编译时求值,因此它必须仅含常量及已定义过的标识符,不可使用变量。

表达式不许含有操作符sizeof(sizeof也是编译时求值)。

#else命令的功能有点象C语言中的else;#else建立另一选择(在#if失败的情况下)。

注意,#else属于#if块。

#elif命令意义与ELSE IF相同,它形成一个if else-if阶梯状语句,可进行多种编译选择。

#elif后跟一个常量表达式。

如果表达式为true,则编译其后的代码块,不对其它#elif表达式进行测试。

否则,顺序测试下一块。

#if expressionstatement sequence#elif expression1statement sequence#endif在嵌套的条件编译中#endif、#else或#elif与最近#if或#elif匹配。

# ifdef 和# ifndef条件编译的另一种方法是用#ifdef与#ifndef命令,它们分别表示"如果有定义"及"如果无定义"。

# ifdef的一般形式是:# ifdef macronamestatement sequence#endif#ifdef与#ifndef可以用于#if、#else,#elif语句中,但必须与一个#endif。

#define MAX 91#include <iostream>using namespace std;int main(){#ifdef MAXcout<<"hello,MAX!"<<endl;#elsecout<<"where is MAX?"<<endl;#endif#ifndef LEOcout<<"LEO is not defined"<<endl;#endifreturn 0;}命令#undef取消其后那个前面已定义过有宏名定义。

一般形式为:#undef macroname命令#line改变__LINE__与__FILE__的内容,它们是在编译程序中预先定义的标识符。

命令的基本形式如下:#line number["filename"]其中的数字为任何正整数,可选的文件名为任意有效文件标识符。

行号为源程序中当前行号,文件名为源文件的名字。

命令#line主要用于调试及其它特殊应用。

注意:在#line后面的数字标识从下一行开始的数字标识。

#line 100 "jia"cout<<"#line change line and filename!"<<endl; //line 100cout<<__LINE__<<endl; //101cout<<__FILE__<<endl; //jia五 #pragma命令#pragma 为实现时定义的命令,它允许向编译程序传送各种指令。

#pragma的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。

#pragma指令对每个编译器给出了一个方法,在保持与C和C++语言完全兼容的情况下,给出主机或操作系统专有的特征。

依据定义,编译指示是机器或操作系统专有的,且对于每个编译器都是不同的。

其格式一般为: #Pragma Para1 message参数。

Message 参数能够在编译信息输出窗口中输出相应的信息,这对于源代码信息的控制是非常重要的。

其使用方法为:#pragma message(“消息文本”)当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。

当我们在程序中定义了许多宏来控制源代码版本的时候,我们自己有可能都会忘记有没有正确的设置这些宏,此时我们可以用这条指令在编译的时候就进行检查。

假设我们希望判断自己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法#ifdef _X86#pragma message(“_X86 macro activated!”)#endif当我们定义了_X86这个宏以后,应用程序在编译时就会在编译输出窗口里显示“_X86 macro activated!”。

我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了。

2 code_seg 参数。

格式如:#pragma code_seg( ["section-name"[,"section-class"] ] )它能够设置程序中函数代码存放的代码段,当我们开发驱动程序的时候就会使用到它。

3 #pragma once (比较常用)只要在头文件的最开始加入这条指令就能够保证头文件被编译一次。

这条指令实际上在VC6中就已经有了,但是考虑到兼容性并没有太多的使用它。

4 #pragma hdrstop表示预编译头文件到此为止,后面的头文件不进行预编译。

BCB可以预编译头文件以加快链接的速度,但如果所有头文件都进行预编译又可能占太多磁盘空间,所以使用这个选项排除一些头文件。

有时单元之间有依赖关系,比如单元A依赖单元B,所以单元B要先于单元A编译。

你可以用#pragma startup指定编译优先级,如果使用了#pragma package(smart_init) ,BCB就会根据优先级的大小先后编译。

5 #pragma resource "*.dfm"表示把*.dfm文件中的资源加入工程。

*.dfm中包括窗体外观的定义。

6 #pragma warning( disable : 4507 34; once : 4385; error : 164 )等价于:#pragma warning(disable:4507 34) /* 不显示4507和34号警告信息。

如果编译时总是出现4507号警告和34号警告, 而认为肯定不会有错误,可以使用这条指令。

*/#pragma warning(once:4385) // 4385号警告信息仅报告一次#pragma warning(error:164) // 把164号警告信息作为一个错误。

相关文档
最新文档