编译预处理
程序编译的四个步骤
程序编译的四个步骤程序编译通常涉及以下四个步骤：预处理、编译、汇编和链接。
1.预处理预处理是编译过程的第一步，它主要负责对源代码进行一些预处理操作。
预处理器工具通常被称为预处理程序，它会根据源代码文件中的预处理指令来修改源代码。
预处理指令位于源代码文件的开头，以“#”字符开头。
预处理指令主要包括宏定义、条件编译和包含文件等。
在预处理阶段，预处理器会执行以下操作：-展开宏定义：将代码中的宏定义替换为相应的代码片段。
-处理条件编译：根据条件编译指令的结果，决定是否包含或排除一些代码。
-处理包含文件：将文件中的包含文件指令替换为实际的文件内容。
预处理后的源代码通常会生成一个中间文件，供下一步编译使用。
2.编译编译是程序编译过程的第二个阶段。
在编译阶段，编译器将预处理生成的中间文件翻译成汇编语言。
编译器会按照源代码的语法规则，将源代码转换为汇编语言指令，生成目标文件（也称为汇编代码文件）。
编译器在编译过程中执行以下操作：-词法分析：将源代码分割为多个词法单元，如关键字、标识符和运算符等。
-语法分析：根据语言的语法规则，分析词法单元的组合，生成语法树。
-语义分析：检查语法树的语义正确性，进行类型检查等。
-优化：对生成的中间代码进行各种优化，以提高程序执行效率。
编译器输出的目标文件通常是汇编语言形式的代码，以便下一步汇编使用。
3.汇编汇编是编译过程的第三个阶段，它将编译器生成的汇编代码翻译成目标机器码。
汇编器（或称为汇编程序）将汇编代码中的指令和操作数翻译为目标机器指令的二进制表示。
汇编器在汇编过程中执行以下操作：-识别和解析汇编指令：将汇编代码中的汇编指令和操作数分割解析。
-确定存储器地址：根据符号的引用和定义，计算并分配存储器地址。
-生成目标机器指令：将汇编指令和操作数翻译为目标机器指令的二进制表示。
汇编器的输出是一个或多个目标文件，每个目标文件都包含可在目标机器上执行的二进制指令。
4.链接链接是编译的最后一个阶段，它将多个目标文件和库文件组合在一起，生成最终的可执行文件。
c程序的四个基本操作过程
c程序的四个基本操作过程
C程序的四个基本操作过程通常指的是预处理（Preprocessing）、编译（Compilation）、汇编（Assembly）和链接（Linking）。
这是源代码转化为可执行程序的过程中的四个主要步骤。
1. **预处理**：这一步处理源代码中的预处理指令，比如#include 指令，它会把包含的文件内容插入到程序中。
此外，预处理器还会处理条件编译指令，如#ifdef和#endif，以决定哪些代码段是否应该编译。
2. **编译**：编译器将预处理后的代码转化为汇编语言。
这个阶段会检查语法错误，并生成与源代码对应的汇编代码。
3. **汇编**：汇编器将编译器生成的汇编代码转化为目标文件（通常是.o文件）。
这个阶段会将汇编代码转化为机器语言，但还没有进行链接。
4. **链接**：链接器将所有的目标文件和库文件合并成一个可执行文件。
这个过程包括解决符号引用（例如函数调用），确保所有的依赖关系都得到满足。
以上就是C程序的四个基本操作过程。
在编写和运行C程序时，理解这些步骤是非常重要的，因为它们决定了程序的构建方式和运行效果。
第10章 预处理过程
20
考虑圆括号对宏的影响： #define squ (x) x*x #define sqa (x) (x)* x #define sq (x) ((x)* (x)) //这个宏实现求表达式平方的功能 int k=squ(1+2)/squ(2+1); //宏展开为： int k=1+2*1+2/2+1*2+1; //相当于 int k=7; int m=sqa(1+2)/sqa(2+1); //宏展开为： int m=(1+2)*1+2/(2+1)*2+1; // 相当于 int m=4; int n=sq(1+2)/sq(2+1); // 展开为： int n=((1+2)*(1+2))/((2+1)*(2+1)); // 相当于 int n=1;
9
[例] #define引入CALLBACK作为占位符，标识符 CALLBACK处理为一个空白。
#include< iostream.h> #define CALLBACK CALLBACK void f (char* s) { cout<<s<<endl; } void main () //表示f当作回调函数, { void ( *pf )( char* )=&f; ( *pf ) ("CALLBACK funct"); //输出: CALLBACK funct } //在字符串中的宏名CALLBACK不被替换
4
续行符\即反斜杠\之后紧跟换行符(硬回车)结束的行 与下一行合并为单独的一行，这要求反斜杠\与换行符之间 没有空格即反斜杠\之后紧跟换行符(硬回车)，标记为\， 不能写为\ 。 硬回车实际上是不可见的。可以用续行符\来处理一 行容纳不下的宏替换指令。 例如： #define LONGTEXT abc*d[ i ] \ +b[ i ]/c[ j ]- d[ k ] 合并为内在的逻辑行： #define LONGTEXT abc*d[i]+b[i]/c[j]-d[k] 预处理指令可以分布在源程序的任何位置，但应与程序 源代码控制流程分隔开来。非空的源程序结束于前面没有反 斜杠的换行符。
编译预处理
编译预处理1概述：编译预处理是在源程序正式编译前的处理。
预处理名令一般写在程序的最开头，并且以#开头的命令。
编译预处理命令不是c语言本身的组成部分，也不属于c语句，不能直接对他们编译。
在代码的正式编译之前（编译即指转换成二进制的机器语言），系统先对预处理命令进行处理，然后再由编译程序对处理后的程序进行正常的编译，得到可执行文件。
即对一个源程序进行编译时，系统会先引用预处理命令对源程序中的预处理部分进行处理，然后自动进行源程序的编译。
C语言提供3中预处理命令：宏替换文件包含条件编译他们均以#开头，并独占一个书写行，语句结尾不用；作为结束符。
2 宏替换（宏定义）分为两种：（1）无参数的宏替换是指用一个指定的标识符（即宏名）来代表程序中的一个字符串。
格式#define 宏名字符串如#define SIZE 10SIZE为宏名，此命令执行后，预处理程序对源程序中的所有SIZE的标识符用10替换。
说明：①宏名一般用大写字符，但不是必须的。
②字符串可以是常量，表达式，语句或多条语句可以是任何语句如输出语句，赋值语句等等③宏定义与变量定义不同，只是做字符的简单替换，不占内存空间，也不赋值④结尾不能加；，如果加了；，则；也作为字符串的一部分，一同参与替换。
⑤宏定义允许嵌套定义，即在宏定义的字符串中可以使用已经定义的宏名。
⑥宏定义要写在函数之外的，一般写在程序的开头，作用范围是从定义到本文件结束，出来这个文件失去作用了。
若要终止其作用，在需要终止前面加#undef 宏名⑦若宏名出现在双引号中，则将不会发生宏替换。
如printf(“ADD”) ADD是宏，这里不会进行宏替换了⑧替换文本不替换用户标识符中的成分宏名ADD不会替换标识符ADDIP中的ADD（2)有参数的宏替换宏定义中的参数为形式参数，在宏调用中的参数为实际参数。
格式：#define 宏名（形参）字符串各参数间用,隔开。
替换时，不仅要将宏展开，还要将形参替换为实参，但是仅仅是替换而不会去运算得出一个值，这点千万注意。
预编译处理
预编译处理【学习目标】◇理解编译预处理的概念。
◇了解宏定义的概念，掌握简单宏定义和带参数的宏定义的格式和使用方法。
◇了解文件包含的概念，掌握文件包含的格式和使用方法。
能在程序中合理使用#include预处理指令◇了解条件编译的概念，掌握条件编译的三种格式及其使用方法。
能在程序中合理使用#define, #if, #ifndef, #else, #undef, #elif等指令。
【重点和难点】重点：编译预处理的概念，简单的宏定义与文件包含指令的用法。
难点：带参宏定义，条件编译指令，会用条件指令解决文件的重复包含问题。
【学习方法指导】本章的内容比较简单，严格说来，它也不算是C++语言的组成部分。
但是，一般说来，任何程序都离不开预编译指令。
特别是文件包含指令和条件编译指令，应把它们搞清楚。
虽然可以用宏定义的方法定义常数，但推荐使用const语句定义常量。
在编程中，如果我们能恰当地运用条件编译，就可以提高程序运行的效率。
【知识点】宏定义；宏替换；简单的宏定义；带参数的宏定义；文件包含；条件编译第一节宏定义我们用C++进行编程的时候，可以在源程序中包括一些编译命令，以告诉编译器对源程序如何进行编译。
这些命令包括：宏定义、文件包含和条件编译，由于这些命令是在程序编译的时候被执行的，也就是说，在源程序编译以前，先处理这些编译命令，所以，我们也把它们称之为编译预处理，本章将对这方面的内容加以介绍。
实际上，编译预处理命令不能算是C++语言的一部分，但它扩展了C++程序设计的能力，合理地使用编译预处理功能，可以使得编写的程序便于阅读、修改、移植和调试。
预处理命令共同的语法规则如下：◇所有的预处理命令在程序中都是以"#"来引导如"#include "stdio.h""。
◇每一条预处理命令必须单独占用一行，如"#include "stdio.h" #include <stdlib.h>" 是不允许的。
程序编译的四个阶段
程序编译的四个阶段
四个阶段分别是： 预处理，编译，组装，链接
1. 预处理将头⽂件展开，将宏定义替换，⽣成符号⽂件.S
2. 编译则包含了词法检查，语法检查，权限检查, 代码优化
3. 组装：将编译后的代码组装成机器码，形成位置⽆关的⽬标⽂件 .o
4. 链接将多个位置⽆关的⽬标⽂件合并成可执⾏⽂件
可见组装才是平台相关的，之前的操作都与平台⽆关，换句话说是编译前端和编译后端
具体有个例⼦
⼀个类的成员变量修改了访问控制符，在另外⼀个⽂件被引⽤，是否必须编译修改的⽂件才能链接成功？答案是不需要
例如我们有 abc.hpp abc.cpp 定义了⼀个class
class a {
public:
int a = 0;
};
在main.cpp 中有引⽤
int main(){
a a;
std::cout << a.a;
}
这样是可以编译成功
# ⽣成main.o abc.o
g++ -c main.cpp abc.cpp
# 链接
g++ -o main main.o abc.o
# 成功
然后修改public为private 重新编译abc
g++ -c abc.cpp
# 重新链接
g++ -o main main.o abc.o
#成功！且可以执⾏
但是重新编译main.cpp
g++ -c main.cpp
#失败，提⽰⽆法访问private成员
可见，访问权限是在编译期检查的，编译成⽬标⽂件后，就不会去检查了
总结
编译成⽬标⽂件或者库⽂件后，不会再去检查权限位了，运⾏时照样可以访问。
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
第八章编译预处理
《C语言程序设计》 数组
文件包含示例： aaa.c文件
#include “bbb.c”
bbb.c文件 int max(int x,int y) பைடு நூலகம் if(x>y) return x; else return y; }
输出结果: 0 1 1 0
《C语言程序设计》 数组
8.2 文件包含
文件包含是指一个文件可以把其它文件的内容包 含进来，其一般格式为： 首先在当前目 格式1: #include “文件名” 录中查找被包 含的文件，找 格式2: #include <文件名> 不到时再按系 统指定的标准 仅在系统指定的标准目录 目录中查找。 中查找被包含的文件。
#ifdef 标识符 程序段1 [#else 程序段2] #endif #ifndef 标识符 程序段1 [#else 程序段2] #endif #if 表达式 程序段1 [#else 程序段2] #endif
#undef 标识符
[例8.5] 条件编译
《C语言程序设计》 数组
第八章作业
8.1 下列程序意在打印出22、32和42。请根据程序的 运行结果分析该程序是否正确。请把宏改写为函数， 再进行分析。 #define SQR(a) ((a)*(a)) main() { int i,x=2; for(i=1;i<=3;i++) printf(“%d “,SQR(x++)); } 8.2 分别用宏和函数完成，从两个数中找出最大数。
C语言文件的编译到执行的四个阶段
C语言文件的编译到执行的四个阶段C语言程序的编译到执行过程可以分为四个主要阶段：预处理、编译、汇编和链接。
1.预处理：在这个阶段，编译器会执行预处理指令，将源代码中的宏定义、条件编译和包含其他文件等操作进行处理。
预处理器会根据源代码中的宏定义替换相应的标识符，并去除注释。
预处理器还会将包含的其他文件插入到主文件中，并递归处理这些文件。
处理后的代码被称为预处理后的代码。
2.编译：在这个阶段，编译器将预处理后的代码转换成汇编代码。
汇编代码是一种低级的代码，使用符号来表示机器指令。
编译器会对源代码进行词法分析、语法分析和语义分析，生成相应的中间代码。
中间代码是一种与特定硬件无关的代码表示形式，便于后续阶段的处理。
3.汇编：在这个阶段，汇编器将中间代码转化为机器可以执行的指令。
汇编器会将汇编代码翻译成二进制形式的机器指令，并生成一个目标文件。
目标文件包含了机器指令的二进制表示以及相关的符号信息。
4.链接：在C语言中，程序通常由多个源文件组成，每个源文件都经过了预处理、编译和汇编阶段得到目标文件。
链接器的作用就是将这些目标文件合并成一个可执行文件。
链接器会解析目标文件中的符号引用，找到其对应的定义并进行连接。
链接器还会处理库文件，将使用到的函数和变量的定义从库文件中提取出来并添加到目标文件中。
最终，链接器生成一个可以直接执行的可执行文件。
以上是C语言程序从编译到执行的四个阶段。
每个阶段都有特定的任务，并负责不同层次的代码转换和处理。
通过这四个阶段，C语言程序可以从源代码转换为机器能够执行的指令，并最终被计算机执行。
第7章-编译预处理
一、判断题1. 宏替换时先求出实参表达式的值，然后带入形参运算求值。
答案：F2. 宏替换不存在类型问题，它的参数也是无类型的。
答案：T3. 在C++语言标准库头文件中包含了许多系统函数的原型声明，因此只要程序中使用了这些函数，则应包含这些头文件。
答案：T4. H头文件只能由编译系统提供。
答案：F5. #include命令可以包含一个含有函数定义的C++语言源程序文件。
答案：T6. 用#include包含的头文件的后缀必须是.h。
答案：F7. #include “C:\\USER\\F1.H”是正确的包含命令，表示文件F1.H存放在C盘的USER 目录下。
答案：F8. #include <…>命令中的文件名是不能包括路径的。
答案：F9. 可以使用条件编译命令来选择某部分程序是否被编译。
答案：T10.在软件开发中，常用条件编译命令来形成程序的调试或正式版本。
答案：T二、选择题1. 以下叙述中错误的是（）。
A．预处理命令行都必须以#开始B. 在程序中凡是以#开始的语句都是预处理命令行C. C++程序在执行过程中对预处理命令行进行处理D. 预处理命令行可以出现在C++程序中任意一行上答案：C2. 以下有关宏替换的叙述中错误的是（）。
A．宏替换不占用运行时间B. 宏名无类型C. 宏替换只是字符替换D. 宏名必须用大写字母表示答案：D3. 在编译指令中，宏定义使用（）指令。
A．#includeB. #defineC. #ifD. #else答案：B4. 社#define P(x) x/x，执行语句cout<<P(3*5);后的输出结果是（）。
A．1B. 0C. 25D. 15答案：C5. 若有宏定义#define MOD(x,y) x%y，下面程序段的结果是（）。
int z,a=15;float b=100;z=MOD(b,a);cout << z++;A．11B. 10C. 6D. 语法错误答案：D6. 在任何情况下计算平方都不会引起二义性的宏定义是（）。
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代替。
编译预处理习题与答案
第九章编译预处理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+xmain(){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 <stdio.h>#define FUDGE(y) 2.84+y#define PR(a) printf(“%d”,(int)(a))#define PRINT1(a) PR(a); putchar(‘\n’)main(){int x=2;PRINT1(FUDGE(5)*x);}A）11 B）12 C）13 D）15【题9.7】以下有关宏替换的叙述不正确的是。
A）宏替换不占用运行时间B）宏名无类型C）宏替换只是字符替换D）宏名必须用大写字母表示【题9.8】C语言的编译系统对宏命令的处理是。
程序编译的四个步骤
程序编译的四个步骤程序的编译过程通常分为四个步骤：预处理、编译、汇编和链接。
第一步：预处理（Preprocessing）预处理是编译过程的第一个步骤。
在这一步骤中，预处理器将对源代码进行处理，以便于后续的编译。
预处理器通常会执行以下任务：1.去除注释：将源代码中的注释（单行、多行注释）删除，以便于后续的处理。
2.展开宏定义：替换源代码中的宏定义，在源代码中使用宏定义的地方，将其替换为宏定义的内容。
3.处理条件编译指令：根据条件编译指令的条件，决定哪些代码需要编译，哪些代码需要忽略。
4.处理头文件包含指令：将头文件包含指令替换为头文件的内容，以确保源代码中可以使用头文件中定义的函数、变量等。
编译是预处理之后的一步，编译器将对预处理后的文件进行处理。
编译器通常会执行以下任务：1. 词法分析（Lexical Analysis）：将源代码分解成一个个的词素，如关键字、标识符、运算符等，并生成相应的记号。
2. 语法分析（Syntax Analysis）：根据词法分析生成的记号，将其按照一定的文法规则进行组织，构建抽象语法树。
3. 语义分析（Semantic Analysis）：对抽象语法树进行分析，检查程序是否存在语义错误，如类型不匹配、未定义的变量等。
4. 代码生成（Code Generation）：根据语义分析的结果，将抽象语法树转化为目标机器的汇编代码。
第三步：汇编（Assembly）汇编是编译过程的第三步，将编译器生成的汇编代码转化为机器码。
汇编器（Assembler）会执行以下任务：1.识别指令和操作数：根据汇编代码的语法规则，识别出每个指令以及对应的操作数。
2.生成机器码：将汇编指令和操作数翻译成机器码表示形式。
3.符号解析：解析并处理所有的符号引用，如函数、变量等的引用。
第四步：链接（Linking）链接是编译过程的最后一步，将编译器生成的目标代码和其他库文件进行合并。
1.解析外部符号引用：将目标代码中引用的外部符号（函数、变量等）与其他目标代码或库文件中的定义进行匹配。
C语言课件—编译预处理
#include <stdio.h> #define sqr(x) ((x)*(x))
#include "powers.h" #define cube(x) ((x)*(x)*(x))
void main() { int n调;试方法
#define quad(x) ((x)*(x)*(x)*(x))
print1f.("n编u辑mpboerw\teersx.ph2,保\t e存xp3\t exp4\n");
❖宏体及各形参外一般应加括号（）
例 #define POWER(x) x*x
x=4; y=6;
z=POWER(x+y); 宏展开：z=x+y*x+y; 一般写成： #define POWER(x) 宏展开： z=((x+y)*(x+y));
((x)*(x))
Macro Definition
例. 带参数的宏与函数实现同样功能
第七章 编译预处理
概述 宏定义 文件包含 条件编译
Next chapter
Introduction
作用：编译程序的一部分，将特殊命令扩展到程 序中,生成扩展C源程序
种类
❖宏定义 #define ❖文件包含 #include ❖条件编译 #if--#else--#endif
格式：
❖“#”开头 ❖占单独书写行 ❖语句尾不加分号; ❖定义位置任意，决定其作用域
print2f.("-将---p\to-w---e\tr-s--.h--文\t-件---存--\n放"到); 某一目录下
for(n3=. 1;编n<辑=fMmAaXin;.nc，++将) powers.h包含进来
程序编译的四个步骤
程序编译的四个步骤程序编译是将源代码翻译成目标代码的过程，目标代码是可以被机器直接执行的二进制代码。
程序编译的过程通常分为四个步骤：预处理、编译、汇编和链接。
1.预处理。
在编译过程中，首先进行的是预处理。
预处理器负责处理源代码中的宏定义和条件编译指令，将宏展开，去掉注释，扩展头文件，还可以通过条件编译指令控制编译过程中的流程。
预处理器通常将预处理后的代码输出为一个中间文件或者内存缓冲区。
2.编译。
编译器则会将经过预处理后的代码翻译成汇编代码，汇编代码通常以汇编语言的格式来描述程序的逻辑，这种格式相对于机器代码更容易理解和调试，但是仍然不够高层次，需要转换为机器码才能被计算机执行。
在编译的过程中，编译器还会进行语法分析和语义分析，检查代码是否符合语法规范，处理类型、函数、变量等定义，确保语义正确，将汇编代码输出为一个中间文件或者内存缓冲区。
3.汇编。
将编译器生成的汇编代码转换为可执行目标代码的过程称为汇编。
在汇编中，汇编器会将汇编代码转换为机器码，进行符号解析（将符号转换为地址）、指令重定位（修改代码的位置）、修补机器码和生成目标代码的重要操作，生成目标代码文件。
4.链接。
在程序编译的最后一个步骤是链接：将生成的目标代码文件与其它代码文件以及必要的库文件链接在一起生成可执行的程序。
链接的过程主要完成符号解析、重定位、生成可执行文件的一些信息等工作。
通过链接可以实现单独编译的目的，即将多个编译完成的目标文件链接在一起形成可执行程序。
链接器会将目标文件中的代码和库文件中的代码整合在一起，更新函数、变量的引用信息，生成可执行的二进制文件。
综合来看，程序编译的四个步骤是预处理、编译、汇编和链接。
预处理和编译是将源代码转换为汇编代码过程中的基本步骤，汇编和链接则是将汇编代码变为可执行代码的两个关键步骤。
不同的编译器或链接器也可能有其它的扩展和优化，但总体上遵循这四个步骤的基本流程。
C语言程序设计第10章 编译预处理简明教程PPT课件
（2）定义一个宏名字之后，可以在其他宏定义中使用它。 如： #define ONE 1 #define TWO ONE+1 #define THREE ONE+TWO
计算机科学与技术学院—— C语言程序设计
10.2 #define
例10-1 宏定义及其使用 #define MESSAGE “You are right!\n”
计算机科学与技术学院—— C语言程序设计
第十章 编译预处理 内容提要
C预处理程序 #define
#include
条件编译指令
#undef
计算机科学与技术学院—— C语言程序设计
10.3 #include
10.3 #include
程序中的#include指令要求编译程序读入另一个源文件。被读入 文件的名字必须由双引号（”）或一对尖括号(<>)包围。如： #include”stdio.h” 或 #include<stdio.h> 都令编译程序读入并编译用于I/O函数处理的包含文件stdio.h。
计算机科学与技术学院—— C语言程序设计
10.3 #include
说明： （1）包含文件中还可以包含其它文件，称为嵌套包含（nested includes）。允许的最大嵌套深度随编译程序而变。 （2）用尖括号包围头文件时，搜索头文件时按编译程序的预先定 义进行，一般只搜索某些专门放置包含头文件的特殊目录。当头 文件用双引号包围时，搜索按编译程序实现时的规定进行，一般 指搜索当前目录，如未发现头文件，则再按尖括号包围时的办法 重新搜索。
10.2 #define
（4）#define指令还有一个重要功能：宏名字可以有变元。每当遇 到宏名字时，与之有关的变元都由程序中的实际变元替换。如上 例中的#define ABS(a) (a)<0?-(a):(a)。但要注意，#define ABS(a) (a)<0?-(a):(a)中变元a两边的括号是不能少的，否则， 会产生非预期结果。如： #define ABS(a) a<0?-a:a printf（”abs of (10-20):%d\n”,ABS(10-20)）; ABS(10-20)替换为：10-20<0?-10-20:10-20，则输出结果为-30。
c语言程序编译的流程
c语言程序编译的流程C语言是一种高级编程语言，它是一种通用的编程语言，可以用于开发各种类型的应用程序。
C语言程序编译的流程是指将C语言源代码转换为可执行文件的过程。
本文将详细介绍C语言程序编译的流程。
C语言程序编译的流程可以分为以下几个步骤：1. 预处理预处理是C语言程序编译的第一步。
在这个步骤中，编译器会对源代码进行一些预处理操作，例如宏替换、头文件包含等。
预处理器会将源代码中的宏定义替换为宏定义中的内容，并将头文件中的内容插入到源代码中。
预处理后的代码称为预处理文件。
2. 编译编译是C语言程序编译的第二步。
在这个步骤中，编译器会将预处理文件转换为汇编代码。
汇编代码是一种低级语言，它是机器语言的一种表现形式。
编译器会将C语言代码转换为汇编代码，这个过程称为编译。
3. 汇编汇编是C语言程序编译的第三步。
在这个步骤中，汇编器会将汇编代码转换为机器语言代码。
机器语言是计算机可以直接执行的语言，它是由0和1组成的二进制代码。
汇编器会将汇编代码转换为机器语言代码，这个过程称为汇编。
4. 链接链接是C语言程序编译的最后一步。
在这个步骤中，链接器会将机器语言代码和库文件链接在一起，生成可执行文件。
库文件是一些预编译的代码，它们可以被多个程序共享。
链接器会将程序中使用到的库文件链接到程序中，生成可执行文件。
以上就是C语言程序编译的流程。
下面我们将详细介绍每个步骤的具体内容。
1. 预处理预处理是C语言程序编译的第一步。
在这个步骤中，编译器会对源代码进行一些预处理操作，例如宏替换、头文件包含等。
预处理器会将源代码中的宏定义替换为宏定义中的内容，并将头文件中的内容插入到源代码中。
预处理后的代码称为预处理文件。
预处理器的工作原理是将源代码中的宏定义和头文件包含替换为实际的代码。
例如，下面是一个简单的宏定义：#define PI 3.1415926在预处理阶段，预处理器会将源代码中的所有PI替换为3.1415926。
这样，程序中所有使用到PI的地方都会被替换为3.1415926。
编译预处理的三种形式
编译预处理的三种形式编译预处理是指在编译阶段之前对源程序进行的一些处理，以便于编译器更好地理解和转换源程序。
这些处理包括宏定义、条件编译和文件包含等。
本文将分别介绍这三种形式的编译预处理。
一、宏定义宏定义是指用一个标识符来代表一段代码，然后在程序中使用该标识符来表示该段代码。
宏定义的语法如下：#define 标识符替换文本其中，标识符是一个由字母、数字和下划线组成的字符串，替换文本可以是任意合法的C语言代码。
1.简单宏定义简单宏定义是指只有一个替换文本的宏定义。
例如：#define PI 3.1415926这个宏定义将标识符PI替换为3.1415926。
在程序中使用该宏时，编译器会将所有的PI替换为3.1415926。
2.带参数的宏定义带参数的宏定义是指可以接受参数的宏定义。
例如：#define MAX(a, b) ((a) > (b) ? (a) : (b))这个宏定义可以接受两个参数a和b，并返回其中较大的值。
在程序中使用该宏时，需要传递两个参数，并且要用括号将每个参数括起来，以避免优先级问题。
3.带可变参数的宏定义带可变参数的宏定义是指可以接受可变数量参数的宏定义。
例如：#define PRINTF(format, ...) printf(format, ##__VA_ARGS__)这个宏定义可以接受一个格式化字符串和可变数量的参数，并将其传递给printf函数。
在程序中使用该宏时，需要传递至少一个参数，格式化字符串中使用%来表示要输出的数据类型，可变参数用逗号分隔。
二、条件编译条件编译是指根据不同的条件选择性地编译某些代码。
条件编译通常用于实现跨平台或调试功能。
1.#ifdef和#ifndef#ifdef和#ifndef分别表示“如果定义了某个宏”和“如果未定义某个宏”。
例如：#ifdef DEBUGprintf("debug mode\n");#endif这段代码只有在DEBUG宏已经被定义时才会被编译。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
文件包含
文件包含是指一个源文件可以将另外一个源文件的全部内 容包含进来，即将另一个C语言的源程序文件嵌入正在进
#include <文件名>
#include “文件名”
其中“文件名”指被嵌入的源程序文件中的文件名，必须 用尖括号或双引号括起来。通过使用不同的括号使查找嵌
（2） 文件file.c #include “stdio.h” #include “pformat.h” main( ) {
int a,b,c,d; char string[ ]=“STUDENT”; a=1;b=2;c=3;d=4; PR(D1,a); PR(D2,a,b); PR(D3,a,b,c); PR(D4,a,b,c,d); PR(S,string); }
注意在编译时，这两个文件不是用link命令实现联接，而是作为一个源程序 进行编译，并得到一个相应的目标文件（.obj）。因此被包含的文件应该是 源文件。
使用#include语句要注意以下几点：
（1）一个#include语句只能指定一个被包含文件， 若包含n个则需n个#include语句。
（2）若#include语句指定的文件内容发生变化，则 应该对包含此文件的所有源文件重新编译处理。
常用技巧
1，防止一个头文件被重复包含 #ifndef COMDEF_H #define COMDEF_H //头文件内容 #endif
2，得到指定地址上的一个字节或字 #define MEM_B( x ) ( *( (byte *) (x) ) ) #define MEM_W( x ) ( *( (word *) (x)出现用双引号括起来的字符串中的字 符，若与宏名同名，不进行替换。例如第（5）点 的例子中printf函数内有两个S字符，一个在双引 号内的S不被替换，而另一个在双引号外的S将被
替换。
带参数的宏定义
带参数的宏定义不仅要进行字符串的替换，而且
#define <宏名>(<参数表>)<带参数的替换序列>
3，求最大值和最小值
#define MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )
#define MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )
4，得到一个field在结构体(struct)中的偏移量 #define FPOS( type, field ) \ ( (dword) &(( type *) 0)-> field ) 例如： #define FPOS(type,field) ( (dword) &(( type *) 0)-> field ) typedef unsigned long dword; typedef struct student {
对使用带参数的宏定义需要说明几点
（1）对用宏定义定义的字符序列中的参数要用圆括号括起 来，而且最好把整个字符串也用括号括起来，以保证在任 何替换情况下都把宏定义作为一个整体，并且可以有一个 合理的计算顺序，否则宏展开后，可能会出现意想不到的
#define S(r) 3.14159* r* r …
area=S(a+b);
（3）使用宏定义可以减少程序中重复书写字符串 的工作量，提高程序的可移植性。例如，定义数
#define arr_size 100 int array[arr_size];
这时数组的大小为100，若改变数组大小，则： #define arr_size 200
（4）宏定义命令一般写在文件开头、函数之前，作为文 件的一部分，宏名的有效范围为宏定义之后到本源文件结 束。如果要强制终止宏定义的作用域，可以使用#undef命
编译预处理
编译预处理
了解条件编译的使用方法。
C语言的编译系统分为编译预处理和正式编译，这是C 语 言的一大特点，其中编译预处理是它和其他高级语言的一 个重要区别。编译C语言程序时，编译系统中首先是编译 预处理模块根据预处理命令对源程序进行适当的处理，然 后才是对源程序的正式编译：对加工过的C源程序进行语
注意#if预处理语句中的表达式是在编译阶段计算值的，因
而此处的表达式不能是变量，必须是常量或用#define定 义的标识符。
4. #undef
其作用：将已定义的标识符变为未定义的。例如：
#undef DEBUG #ifdef DEBUG 为假（0）， #ifndef DEBUG 为真（非0）。
预处理命令均以符号“#”开头，并且一行只能写一条预处 理命令，结束时不能使用语句结束符，若预处理命令太长， 可以使用续行标志“＼”后续写在下一行，一般将预处理
宏定义
C
不带参数的宏定义
不带参数的宏定义通常用来定义符号常量， 即用一指定的宏名（即标识符）来代表一
#define<宏名> <替换序列>
PI的有效范围
#define PI 3.14159 {
…… } #undef PI … …
main( )
PI的有效范围
fly1( )
（5）进行宏定义时可以引用已定义的宏名，宏展开是层
#define PI 3.14159 #define R 4.0 #define L 2* PI* R #define S PI* R* R main( ) { printf(“L=%f＼nS=%f＼n”,L,S); } 经过宏展开后，printf函数中的输出项L、S L -- 2* 3.14159* 4.0 S -- 3.14159* 4.0* 4.0 printf函数被展开成: printf((“L=%f＼nS=%f＼n”,2* 3.14159* 4.0, 3.14159* 4.0*
宏展开过程：程序中若有带实参的宏，则按
#define指定的替换序列从左至右进行替换。若宏 定义中包含有形参，则用程序中相应的实参替换 形参，其中实参可以是常量、变量或表达式；
从键盘输入两个数，输出较小的数。
#include “stdio.h” #define MIN(a,b) ((a)<(b)?(a):(b)) main() { int x,y; printf (“输入两个数”); scanf (“%d,%d ”,&x,&y); printf (“MIN=%d”,MIN(x,y)); } 以上程序执行时，用序列((x)<(y)?(x):(y))来替换MIN(x,y)。
其作用：若标识符没有定义，程序段1参加编译，否则程 序段2参加编译，其中#else
#ifndef
程序段1
#endif
#ifndefDEBUG
printf(“x=%d,y=%d＼n”,x,y);
#endif
若DEBUG没有定义，则在程序运行时输出 x,y的值；若用#define定义了DEBUG，则 此处的printf
printf(“count=%d”,count);
}
对于宏定义的使用，作以下几点说明：
（1）预处理模块只是用宏名作简单的替换，不作语法检查，
（2）没有特殊的需要，一般在预处理语句的行末不必加分 号， #define ESC 0x1B; …… while((c=getch( ))!=ESC) …… 经过宏展开后，while while((c=getch( ))!=0x1B;)
（3）文件包含命令可以嵌套使用，即一个被包含的 文件中可以再使用#include语句包含另一个文件， 而在该文件中还可以再包含其它文件，通常允许 嵌套10
条件编译
C语言的编译预处理程序还提供了条件编译能力，使得可 以对源程序的一部分内容进行编译，即不同的编译条件产
1. #ifdef 程序段1
#else 程序段2
其中宏名常用大写字母表示，宏名与替换序列 （即字符序列）之间用空格符分隔。在程序中， 经编译预处理后，就进行宏展开，凡是宏名出现 的地方被替换为它所对应的替换序列。
从键盘连续输入字符，统计其中的小写字母的个数，直到 按ESC
#include “stdio.h”
#define ESC 0x1B
图表示了“文件包含”的含意，原来的源程序文 件mypro.c和用文件包含命令嵌入的源程序文件 file1.c在逻辑上被看成同一文件，经过编译以后生 成一个目标文件mypro.obj
file1.c： 被嵌入的文 件
mypro.c：
源程序文件
编译
#include “file1.c”
mypro.obj： 目标文件
mul= S(x,y)
mul=(a,b)a* b(x,y)
（3）把函数和带参数的宏要区分开，虽然它们有相似
区别
函数
类
型
带参数的宏
先计算出实参表达式的值， 不计算实参表达式的值，直接用
是否计算实参的值
然后代替形参
实参进行简单的替换
何时进行处理、分 配内存单元
类型要求
调用情况
在程序运行时进行值的处理、 编译时进行宏展开，不分配内存
#endif 其作用：若标识符已经被定义过（一般用#define命令定 义），那么程序段1参加编译，否则程序段2参加编译，其 中#else
#ifdef 程序段1
#endif
#ifdef DEBUG printf(“x=%d,y=%d＼n”,x,y); #endif 若DEBUG #define DEBUG 则在程序运行时输出x,y的值，以便调试时用于分析；若
area=3.14159* a+b* a+b; 显然是由于在进行宏定义时，对r没有加括号造成与设计的原
area=3.14159* (a+b) * (a+b);