什么是预编译
预编译又称为预处理,是做些代码文本的替换工作处理#开头的指令,比如拷贝#include 包含的文件代码，#define宏定义的替换,条件编译等就是为编译做的预备工作的阶段主要处理#开始的预编译指令预编译指令指示了在程序正式编译前就由编译器进行的操作，可以放在程序中的任何位置。常见的预编译指令有：(1)#include 指令该指令指示编译器将xxx.xxx文件的全部内容插入此处。若用<>括起文件则在系统的INCLUDE目录中寻找文件，若用" "括起文件则在当前目录中寻找文件。一般来说，该文件是后缀名为"h"或"cpp"的头文件。注意：<>不会在当前目录下搜索头文件，如果我们不用<>而用""把头文件名扩起，其意义为在先在当前目录下搜索头文件，再在系统默认目录下搜索。(2)#define指令该指令有三种用法: 第一种是定义标识，标识有效范围为整个程序，形如#define XXX，常与#if配合使用；第二种是定义常数，如#define max 100，则max代表100（这种情况下使用const定义常数更好，原因见注1）；第三种是定义"函数"，如#define get_max(a, b) ((a)>(b)?(a):(b)) 则以后使用get_max(x,y)就可以得到x和y中较大的数（这种方法存在一些弊病，见注2）。(3)#if、#else和#endif指令这些指令一般这样配合使用：#if defined(标识) //如果定义了标识要执行的指令#else 要执行的指令#endif 在头文件中为了避免重复调用(比如说两个头文件互相包含对方)，常采用这样的结构：#if !(defined XXX) //XXX为一个在你的程序中唯一的标识符，//每个头文件的标识符都不应相同。//起标识符的常见方法是若头文件名为"abc.h" //则标识为"abc_h" #define XXX 真正的内容，如函数声明之类#endif 注1：因为：const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误（边际效应）。注2：例如get_max(a++, b)时，a++会被执行多少次取决于a和b的大小！所以建议还是用内联函数而不是这种方法提高速度。虽然有这样的弊病，但这种方法的确非常灵活，因为a和b可以是各种数据类型。预编译头的概念：
所谓的预编译头就是把一个工程中的那一部分代码,预先编译好放在一个文件里(通常是
以.pch为扩展名的)，这个文件就称为预编译头文件这些预先编译好的代码可以是任何的
C/C++代码--------甚至是inline的函数，但是必须是稳定的，在工程开发的过程中不会被经常改变。如果这些代码被修改，则需要重新编译生成预编译头文件。注意生成预编译头文件
是很耗时间的。同时你得注意预编译头文件通常很大，通常有6-7M大。注意及时清理那些没有用的预编译头文件。
也许你会问：现在的编译器都有Time stamp的功能，编译器在编译整个工程的时候，它只会编译那些经过修改的文件，而不会去编译那些从上次编译过，到现在没有被修改过的文件。那么为什么还要预编译头文件呢？答案在这里，我们知道编译器是以文件为单位编译的，一个文件经过修改后，会重新编译整个文件，当然在这个文件里包含的所有头文件中的东西（.eg Macro, Preprocesser ）都要重新处理一遍。VC的预编译头文件保存的正是这部分信息。以避免每次都要重新处理这些头文件。
预编译头的作用：
方法一：手动方法
根据上文介绍，预编译头文件的作用当然就是提高便宜速度了，有了它你没有必要每次都编译那些不需要经常改变的代码。编译性能当然就提高了。
预编译头的使用：
要使用预编译头，我们必须指定一个头文件，这个头文件包含我们不会经常改变的代码和其他的头文件，然后我们用这个头文件来生成一个预编译头文件（.pch文件）
想必大家都知道StdAfx.h这个文件。很多人都认为这是VC提供的一个“系统级别”的，编译器带的一个头文件。其实不是的，这个文件可以是任何名字的。我们来考察一个典型的由AppWizard生成的MFC Dialog Based程序的预编译头文件。（因为AppWizard会为我们指定好如何使用预编译头文件，默认的是StdAfx.h，这是VC起的名字）。我们会发现这个头文件里包含了以下的头文件：
#include
#include
#include
#include
#include
这些正是使用MFC的必须包含的头文件，当然我们不太可能在我们的工程中修改这些头文件的，所以说他们是稳定的。
那么我们如何指定它来生成预编译头文件。我们知道一个头文件是不能编译的。所以我们还需要一个cpp文件来生成.pch 文件。这个文件默认的就是StdAfx.cpp。在这个文件里只有一句代码就是：#include “Stdafx.h”。原因是理所当然的，我们仅仅是要它能够编译而已―――也就是说，要的只是它的.cpp的扩展名。我们可以用/Yc编译开关来指定StdAfx.cpp 来生成一个.pch文件，通过/Fp编译开关来指定生成的pch文件的名字。打开project
->Setting->C/C++ 对话框。把Category指向Precompiled Header。
在图中我们的Project Options(右下角的那个白的地方)可以看到/Fp “debug/PCH.pch”，这就是指定生成的.pch文件的名字，默认的通常是<工程名>.pch（我的示例工程名就是PCH）。
这时原来的Project Option变成了Source File Option（原来是工程，现在是一个文件，当然变了）。在这里我们可以看到/Yc开关，/Yc的作用就是指定这个文件来创建一个Pch文件。/Yc后面的文件名是那个包含了稳定代码的头文件，一个工程里只能有一个文件的可以有YC开关。VC就根据这个选项把StdAfx.cpp编译成一个Obj文件和一个PCH文件。
在这里，Precomplier 选择了Use ………一项，头文件是我们指定创建PCH 文件的stdafx.h
文件。事实上，这里是使用工程里的设置，/Yu”stdafx.h”。
这样，我们就设置好了预编译头文件。也就是说，我们可以使用预编译头功能了。以下是注意事项：
1):如果使用了/Yu，就是说使用了预编译，我们在每个.cpp文件的最开头，我强调一遍是最开头，包含你指定产生pch文件的.h文件（默认是stdafx.h）不然就会有问题。如果你没有包含这个文件，就告诉你Unexpected file end. 如果你不是在最开头包含的，你自己试以下就知道了，绝对有很惊人的效果…..
2）如果你把pch文件不小心丢了，根据以上的分析，你只要让编译器生成一个pch文件就可以了。也就是说把stdafx.cpp（即指定/Yc的那个cpp文件）从新编译一遍就可以了。当然你可以傻傻的Rebuild all。简单一点就是选择那个cpp文件，按一下Ctrl + F7就可以了。方法二。自动使用
很简单只要指定/YX就可以了。或者在上图中选择Automatic………就可以了。注意的事情是如果你指定了/Yc /Yu的话，/Yx是会被忽略的。前者的优先级别高一些。
第六章预处理命令 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语句
#if #ifdef和#ifndef的用法和区别 #if #ifdef和#ifndef用法 移位运算符的优先级高于条件运算符，重载是不能改变运算符优先级的，这点要注意，所以代码应当像下面这样调整，写宏的时候一定要注意优先级，尽量用括号来屏蔽运算符优先级。#define MAXIMUM(x,y) ((x)>(y)?(x):(y)) #define MINIMUM.... #include 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.在宏定义#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中的预处理命令是由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，函数调用时，先求出实参表达式的值，然后代入形参，而使用带参的宏只是进行简单的字符替换。 预编译#define #ifdef #endif用法 2010-08-05 10:08 最近在看Linux底层代码，发现好多代码里有#define #ifdef #endif，找了个介绍详细的文章，供大家参考： #ifdef的用法 灵活使用#ifdef指示符，我们可以区隔一些与特定头文件、程序库和其他文件版本有关的代码。 代码举例：新建define.cpp文件 ＃include “iostream.h” int main() { #ifdef DEBUG cout<< “Beginning execution of main()”; #endif return 0; } 运行结果为：Press any key to continue 改写代码如下： ＃include “iostream.h” #define DEBUG int main() { #ifdef DEBUG cout<< “Beginning execution of main()”; #endif return 0; } 运行结果为：Beginning execution of main() Press any key to continue更一般的情况是，#define 语句是包含在一个特定的头文件中。 比如，新建头文件head.h，在文件中加入代码： #ifndef DEBUG #define DEBUG #endif 而在define.cpp源文件中，代码修改如下： ＃include “iostream.h” ＃include “head.h” int main(){ #ifdef DEBUG cout<< “Beginning execution of main()”; #endif return 0; } 运行结果如下：Beginning execution of main() Press any key to continue 结论：通过使用#ifdef指示符，我们可以区隔一些与特定头文件、程序库和其他文件版本有关的代码。 “#ifdef”的运用magicchip 发表于 2007-8-16 9:10:00 “#ifdef”在C++中运用 常常在建立header file的时候需要先写一段文字 比如下面这段话 #ifdef HEADERFILENAME_H #define HEADERFILENAME_H class ClassName { … }; #endif 那段#ifdef有必要写吗? 其实有些无写都不会影响代码的Runtime 不过对运行速度和文件大小有一定的影响 大概很多人很喜欢用＃i nclude来抓取文件吧 炎也很喜欢 总是在main.cpp中include一次 然后又在classfile.cpp中又使用一次 C51几个预编译指令的用法 标签: 指令用法编译2009-07-31 10:47 预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理。 在C语言中，并没有任何内在的机制来完成如下一些功能：在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行响应的转换。预处理过程还会删除程序中的注释和多余的空白字符。 预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令： 指令用途 #空指令，无任何效果 #include包含一个源代码文件 #define定义宏 #undef取消已定义的宏 #if如果给定条件为真，则编译下面代码 #ifdef如果宏已经定义，则编译下面代码 #ifndef如果宏没有定义，则编译下面代码 #elif如果前面的#if给定条件不为真，当前条件为真，则编译下面代码 #endif结束一个#if……#else条件编译块 #error停止编译并显示错误信息 一、文件包含 #include预处理指令的作用是在指令处展开被包含的文件。包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。标准C编译器至少支持八重嵌套包含。 预处理过程不检查在转换单元中是否已经包含了某个文件并阻止对它的多次包含。这样就可以在多次包含同一个头文件时，通过给定编译时的条件来达到不同的效果。例如： #define AAA 3.9.1排除和包含代码 或许最常用的预处理器指令就是用于控制什么时候以及如何包含代码的指令。举个例子来说，要使代码能够同时由C# 2.0和之前的C# 1.2版本编译器进行编译，可以使用一个预处理器指令，在遇到1.2编译器的时候，就排除C# 2.0特有的代码。我们的tic-tac-toe例子和代码清单 3-52对此进行了演示。 代码清单3-52遇到C# 1.x编译器的时候排除C# 2.0代码 在这个例子中，调用了System.Console.Clear()方法，这是只有2.0 CLI才支持的方法。使用#if和#endif预处理器指令，这一行代码就只有在定义了预处理器符号CSHARP2的前提下才会编译。 预处理器指令的另一个应用是适应不同平台之间的差异，比如用WINDOWS和LINUX #if指令将Windows和Linux特有的API包围起来。开发者经常用这些指令来取代多行注释 （/*...*/），因为它们更容易通过定义恰当的符号或者通过一次搜索/替换来移除。预处理器指令最后一个常见的用途是调试。如果用一个#if DEBUG指令将调试代码包围起来，那么在大多数IDE中，都能在最终的发布版本中移除这些代码。IDE默认将DEBUG符号用于调试编译，将RELEASE符号用于发布版本。 为了处理else-if条件，可以在#if指令中使用#elif指令，而不是创建两个完全独立的#if块，如代码清单3-53所示。 代码清单3-53使用#if、#elif和#endif指令 #if LINUX ... #elif WINDOWS ... #endif 输出3-28展示了在使用Mono编译器的前提下，如何实现相同的功能。 多文件结构和编译预处理命令 C++完整的源程序一般由三部分构成：类的定义，类成员的实现，主函数 在较大的项目中，常需要多个源文件（即多个编译单元），c++要求一个类的定义必须在使用该类的编译单元中。因此，把类的定义写在头文件中。 （重点）一个项目至少分三个文件：类定义文件（.h）、类实现文件（.cpp）、类的使用文件（.cpp） （重点）对于复杂的程序：每个类都有单独的类定义和类实现。这样做的好处：可以对不同的文件进行单独编写、编译，最后链接，同时利用类的封 装性，在程序的调试和修改时只对其中某一个类的定义和实现修改，其余保持不动。 预处理指令声明中出现的注释以及一行单独一个#符号的情况在预编译处理过程中都会被 忽略掉。 宏定义在c++中依然使用，但最好的方式是在类型说明语句中用const修饰来取代宏定义。（重点）大型程序中，往往需要使用很多头文件，因此要发现重复包含并不容易。要解决这个问题，我们可以在头文件使用条件编译。（三种方式） 表1是所有预处理指令和意义 指令意义 #define 定义宏 #undef 取消定义宏 #include 包含文件 #ifdef 其后的宏已定义时激活条件编译块 #ifndef 其后的宏未定义时激活条件编译块 #endif 中止条件编译块 #if 其后表达式非零时激活条件编译块 #else 对应#ifdef, #ifndef, 或#if 指令 #elif #else 和#if的结合 #line 改变当前行号或者文件名 #error 输出一条错误信息 #pragma 为编译程序提供非常规的控制流信息 宏定义 #define指令定义宏，宏定义可分为两类：简单宏定义，带参数宏定义。 简单宏定义有如下一般形式： #define 名字替换文本 它指示预处理器将源文件中所有出现名字记号的地方都替换为替换文本，替换文本可以是任 第九章编译预处理 课题：第九章编译预处理 教学目的: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); } 在所有的预处理指令中，#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中就已经有了，但是考虑到兼容性并没有太多的使用它。 (4)#pragma hdrstop表示预编译头文件到此为止，后面的头文件不进行预编译。BCB可以预编译头文件以加快链接的速度，但如果所有头文件都进行预编译又可能占太多磁盘空间，所以使用这个选项排除一些头文件。 有时单元之间有依赖关系，比如单元A依赖单元B，所以单元B要先于单元A 编译。你可以用#pragma startup指定编译优先级，如果使用了#pragma package(smart_init) ，BCB就会根据优先级的大小先后编译。 (5)#pragma resource "*.dfm"表示把*.dfm文件中的资源加入工程。*.dfm中包括窗体外观的定义。 C51几个预编译指令的用法 标签: 指令用法编译2009-07-31 10:47 预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理。 在C 语言中，并没有任何内在的机制来完成如下一些功能： 在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行响应的转换。预处理过程还会删除程序中的注释和多余的空白字符。 预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令： 指令用途 #空指令，无任何效果 #include 包含一个源代码文件 #define 定义宏 #undef 取消已定义的宏 #if 如果给定条件为真，则编译下面代码 #ifdef 如果宏已经定义，则编译下面代码 #ifndef 如果宏没有定义，则编译下面代码 #elif 如果前面的#if 给定条件不为真，当前条件为真，则编译下面代码 #en dif结束一个#if ......... #e条件编译块 #error 停止编译并显示错误信息 一、文件包含 #include 预处理指令的作用是在指令处展开被包含的文件。包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。标准C编译器至少支 持八重嵌套包含。 预处理过程不检查在转换单元中是否已经包含了某个文件并阻止对它的多次包含。这样就可以在多次包含同一个头文件时，通过给定编译时的条件来达到不同的效果。例如： #define AAA #include "t.c" #undef AAA #include "t.c" 为了避免那些只能包含一次的头文件被多次包含，可以在头文件中用编译时条件来进行控制。例如： #ifndef MY_H #define MY_H #endif 在程序中包含头文件有两种格式： #include 第9章预处理命令 宏定义不是Ｃ语句，所以不能在行尾加分号。如果加了分号则会连分号一起进行臵换。 可以用#undef命令终止宏定义的作用域。 对程序中用“”括起来的内容（即字符串内的字符），即使与宏名相同，也不进行臵换。宏定义只做字符替换，不分配内存空间。 宏名不是变量，不分配存储空间，也不能对其进行赋值。 在宏展开时，预处理程序仅对宏名作简单的字符串替换，不作任何检查。 在进行宏定义时，可以引用已定义的宏名 无参宏定义的一般格式： #define 标识符字符串 将这个标识符（名字）称为“宏名”，在用预编译时将宏名替换成字符串的过程称为“宏展开”。#define是宏定义命令。 带参宏定义的一般格式： #define 宏名(形参表)字符串 带参宏的调用和宏展开： 调用格式：宏名(实参表)； 宏展开(又称为宏替换)的方法：用宏调用提供的实参直接臵换宏定义中相应的形参，非形参字符保持不变。 定义有参宏时，宏名与左圆括号之间不能留有空格。否则，Ｃ编译系统会将空格以后的所有字符均作为替代字符串，而将该宏视为无参宏。 有参宏的展开，只是将实参作为字符串，简单地臵换形参字符串，而不做任何语法检查。 为了避免出错,可以在所有形参外，甚至整个字符串外，均加上一对圆括号。 如: #define S(r) 3.14*(r)*(r) 则：area=S(a+b); 展开后为: area=3.14*(a+b)*(a+b); 调用有参函数时，是先求出实参的值，然后再复制一份给形参。而展开有参宏时，只是将实参简单地臵换形参。函数调用是在程序运行时处理的，为形参分配临时的内存单元；而宏展开则是在编译前进行的，在展开时不分配内存单元，不进行值的传递，也没有“返回值”的概念。调用函数只可得到一个返回值，而用宏可以设法得到几个结果。 在有参函数中，形参都是有类型的，所以要求实参的类型与其一致；而在有参宏中，形参和宏名都没有类型，只是一个简单的符号代表，因此，宏定义时，字符串可以是任何类型的数据。 使用宏次数多时，宏展开后源程序变长，因为每展开一次都是程序增长，而函数调用不会使源程序变长。 宏替换不占用运行时间，只占编译时间。而函数调用则占用运行时间（分配单元、保留现场、值传递、返回）。 在程序中如果有带实参的宏，则按#define命令行中指定的字符串从左到右进行臵换。如果字符串中包含宏中的形参，则将程序语句中相应的实参（可以是常量、变量或表达式）代替形参。如果宏定义中的字符串中的字符不是参数字符，则保留。 国家二级C语言机试（编译预处理和指针）模拟试卷7 (总分：56.00，做题时间：90分钟) 一、选择题(总题数：28，分数：56.00) 1.有以下程序：#include＜stdio．h＞void main() void fun(char*c) {char s[81]；{while(*c) gets(s)；fun(s)；puts(s)； {if(*c＞='a'&&*c＜='z')*c=*c－('a'－'A')； } c++： }} 当执行程序时从键盘上输入Hello Beijing＜回车＞，则程序的输出结果是 （分数：2.00） A.HELLO BEIJING √ B.Hello Beijing C.hello Beijing D.hELLO Beijing 解析：解析：子函数fun的功能是把小写字母转换成大写字母，所以程序的输出结果为选项A)。 2.有以下程序#include＜stdio．h＞void f(int*p，int*q) void f(int*p，int*q)；{ main() p==p+1；*q=*q+1； { int m=1，n=2，*r=&m； } f(r，&n)；printf("％d，％d"，m，n)； }程序运行后的输出结果是 （分数：2.00） A.2，3 B.1，3 √ C.1，4 D.1，2 解析：解析：本题考查函数的调用与指针。fun()函数的作用是：使指针p指向原来所指变量的下一个变量，使q指针指向的值加1。主函数中，指针r指向m，调用fun()函数的结果是，使r指向地址位于m后面的变量，使位丁n的地址上的变量(就是n)的值加1，因此，结果为1，3。 3.有以下程序 #include＜stdio．h＞ 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的地址，因此，两者结果相同，并且两者指针指向的值不能变化。 4.有下列程序：void f(int b[]) {int I；for(i=2；i＜6；i++)b[i]*=2；} main() {int a[10]={1，2，3，4，5，6，7，8，9，10}，i；f(a)；for(i=0；i＜10，i++)printf("％d，"，a[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}。 5.有以下程序 #include＜stdio．h＞ 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 实验十二变量的存储类型与与编译命令（上机练习）1、输入下面的程序并运行，分析为什么会得到此结果。 #include A．11 B．12 C．13 D．15 #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；PRINT1（FUDGF（5）*x）； } 5．以下叙述正确的是（）。 A．用#include包含的头文件的后缀不可以是“.a” B．若一些源程序中包含某个头文件；当该头文件有错时，只需对该头文件进行修改，包含此头文件所有源程序不必重新进行编译 C．宏命令可以看做是一行C语句 D．C编译中的预处理是在编译之前进行的。 6．以下有关宏替换的叙述不正确的是（）。 A．宏替换不占用运行时间 B．宏名无类型 C．宏替换只是字符替换 D．宏名必须用大写字母表示7.宏定义#define G 9.8中的宏名G代替() A．一个单精度实数 B．一个双精度实数C．一个字符串 D．不确定类型的数8.若有宏定义： #define MOD(x,y) x%y 则执行以下程序段的输出为() int z,a=15,b=100; z=MOD(b,a); printf(“%d\n”,z++); A．11 B．10 C．6 D．宏定义不合法 9.以下程序的运行结果是()。 #define DOUBLE(r) r*r main( ) { int y1=1,y2=2,t; t=DOUBLE(y1+y2); printf(“%d\n”,t);} A．11 B．10 C．5 D．9 10.下列程序段的输出结果是（） 编译预处理 1概述： 编译预处理是在源程序正式编译前的处理。预处理名令一般写在程序的最开头，并且以#开头的命令。编译预处理命令不是c语言本身的组成部分，也不属于c语句，不能直接对他们编译。在代码的正式编译之前（编译即指转换成二进制的机器语言），系统先对预处理命令进行处理，然后再由编译程序对处理后的程序进行正常的编译，得到可执行文件。即对一个源程序进行编译时，系统会先引用预处理命令对源程序中的预处理部分进行处理，然后自动进行源程序的编译。 C语言提供3中预处理命令：宏替换文件包含条件编译他们均以#开头，并独占一个书写行，语句结尾不用；作为结束符。 2 宏替换（宏定义） 分为两种： （1）无参数的宏替换 是指用一个指定的标识符（即宏名）来代表程序中的一个字符串。 格式#define 宏名字符串 如#define SIZE 10 SIZE为宏名，此命令执行后，预处理程序对源程序中的所有SIZE的标识符用10替换。 说明： ①宏名一般用大写字符，但不是必须的。 ②字符串可以是常量，表达式，语句或多条语句可以是任何语句如输出语句，赋值语句等等 ③宏定义与变量定义不同，只是做字符的简单替换，不占内存空间，也不赋值 ④结尾不能加；，如果加了；，则；也作为字符串的一部分，一同参与替换。 ⑤宏定义允许嵌套定义，即在宏定义的字符串中可以使用已经定义的宏名。 ⑥宏定义要写在函数之外的，一般写在程序的开头，作用范围是从定义到本文件结束，出来这个文件失去作用了。若要终止其作用，在需要终止前面加#undef 宏名 ⑦若宏名出现在双引号中，则将不会发生宏替换。如printf(“ADD”) ADD是宏，这里不会进行宏替换了 ⑧替换文本不替换用户标识符中的成分宏名ADD不会替换标识符ADDIP中的ADD （2)有参数的宏替换 宏定义中的参数为形式参数，在宏调用中的参数为实际参数。 格式：#define 宏名（形参）字符串 各参数间用,隔开。替换时，不仅要将宏展开，还要将形参替换为实参，但是仅仅是替换而不会去运算得出一个值，这点千万注意。 说明：①注意参数有括号与无括号的区别，这里只是进行直接的替换，不进行其他任何操作。 ②宏替换之后为一个字符串，不是一个值。 ③在带参的宏定义中宏名与（形参）之间不能有空格，否则则被认为是无参宏定义，会将空格后面的字符都当做替换字符串的一部分。如： #define Y （x) x*x K=Y(5); 宏替换为 K=(x) x*x(5) ④这里虽然哟形参与实参但是，与函数调用时不同，这里只是简单的替换，不存在数值传递。形参不占内存，不必进行类型说明。但实参的值是要进行类型说明的。 预编译处理/程序格式命名 第九章c/c++编译预处理 一、文件包含 #include <头文件名称> #include "头文件名称" 第一种形式：用来包含开发环境提供的库头文件，它指示编译预处理器在开发环境设定的搜索路径中查找所需的头文件 第二种形式：用来包含自己编写的头文件，它指示编译预处理器首先在当前工作目录下搜索头文件，如果找不到再到开发环境设定的路径中查找。 内部包含卫哨和外部包含卫哨 在头文件里面使用内部包含卫哨，就是使用一种标志宏，可以放心的在同一个编译单元及其包含的头文件中多次包含同一个头文件而不会造成重复包含。如： #ifndef _STDDEF_H_INCLUDED_ #define _STDDEF_H_INCLUDED_ ...... //头文件的内容 #endif 当包含一个头文件的时候，如果能够始终如一地使用外部包含卫哨，可以显著地提高编译速度，因为当一个头文件被一个源文件反复包含多次时，可以避免多次查找和打开头文件地操作。如： #if !defined(_INCLUDED_STDDEF_H_) #include C语言预处理命令之条件编译(#ifdef,#else,#endif,#if等)
c语言第8章编译预处理及位运算习题答案.doc
编译预处理
C中的预处理命令
预编译#define #ifdef #endif用法
C51几个预编译指令的用法
C#中的预处理指令
多文件结构和编译预处理命令
C语言程序设计教案 第九章 编译预处理
c++预编译命令
C51几个预编译指令的用法
第9章 预处理命令
国家二级C语言机试(编译预处理和指针)模拟试卷7
变量的存储类型与预编译命令
编译预处理
预编译处理及程序格式命名
相关主题
文本预览