函数与编译预处理
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> 带参数的宏在展开时，只作简单的字符和参数的替换，不进⾏任何计算操作。
江苏省计算机二级考试(vc)备考提纲(主要为基础知识) (1)
江苏省计算机二级考试备考提纲第一章Visual C++程序设计入门1>定义标识符规则：第一个字符只能是英文字母或下画线，后面可跟字母，数字，下画线；不能是C++语言的关键字。
2>键盘上除去3个字符：@，￥，其余的可显示字符在程序代码中均能使用。
3>编写程序的注意事项：/*和*/为多行注释，//为单行注释，从标识起至本行结束：程序一般包含输入输出编译预处理命令；C++的程序有且只有一个主函数main;对于C++编译器而言，一条语句可以写成若干行，一行内也可以写若干条语句，：而且它严格区分大小写字母。
4>运算符；1.求模/余运算符%，要求操作数必须都是整形数，若不是整型数必须将操作数强制转化成整型再进行求余运算，否则将出现编译错误，如（int）5.2%3=2; 2.若操作数中有负值，求余原则为：先取绝对值求余，余数取与被除数相同的符号，如-10%3=-1,10%-3=1. 3。
而除法运算符/和*，若两个操作数都是整型，则结果也是整型，若有一个是实型，则结果是实型。
4。
注意，如a=4,b=3,c=2,求a>b>c的值，因为原式=(a>b)>c,a>b值为1，则原式相当于1>c,所以最终结果是0。
5。
自增、减运算符的操作数不能是常量或表达式，如2++，（x+1）++都是不合法的，再如，2*a++等价于2*（a++）. 6.条件运算符“？：”是C++中唯一的三目运算符，条件表达式的一般格式为：逻辑表达式1？表达式2：表达式3.，1为真执行2，为假执行3，注意：条件表达式的功能相当于条件语句，但一般不能取代if语句；表达式1,2,3类型可不同，此时条件表达式的值取较高的类型，如a>b?2:5.5,a<b时，值为5.5，a>b时，值为2.0，而不是2。
注意：逗号运算符计算方法：按先后顺序依次计算各个表达式的值，最后一个表达式的值作为整个逗号表达式的值。
第7章 函数与预处理命令
例如：求两个数的最大值。 int max(int x,int y) { int z; 没有形式参数 z = x > y ? x : y; 为无参函数 return( z ); }
龙诚数码：
9
形参也可以这样定义 int max(x,y) int x,y; { int z; z = x > y ? x : y; return( z ); }
龙诚数码：
【例7.1】求一个整数的立方。
int cube (int x) /* 函数定义 */ { return (x * x * x); } main( ) 程序的执行总是 { int f, a; 从main函数开始 printf("\nEnter an integer number："); scanf("%d", &a); 函数调用 f = cube (a); printf("%d * %d * %d = %d\n", a, a, a, f); 程序运行情况如下： } Enter an integer number：2 2*2*2=8
a=9,b=5
14
龙诚数码：
2.函数的类型与函数的返回值
15
【例7.6】输出两个数中的大数。 ⑴ 函数的类型 max(int x,int y) 说明： { int z; ①函数的类型 z=x>y?x:y; 决定了函数返 return (z); /* 返回z的值 */ 回值的类型。 } 若省略函数的 main( ) 类型，系统默 { int a,b,c; 认其为int型。 scanf("%d,%d",&a,&b); ②无返回值的 c=max(a,b); 函数应将其类 printf("max is %d\n",c); 型定义为void } （空）类型。
预编译处理
预编译处理【学习目标】◇理解编译预处理的概念。
◇了解宏定义的概念，掌握简单宏定义和带参数的宏定义的格式和使用方法。
◇了解文件包含的概念，掌握文件包含的格式和使用方法。
能在程序中合理使用#include预处理指令◇了解条件编译的概念，掌握条件编译的三种格式及其使用方法。
能在程序中合理使用#define, #if, #ifndef, #else, #undef, #elif等指令。
【重点和难点】重点：编译预处理的概念，简单的宏定义与文件包含指令的用法。
难点：带参宏定义，条件编译指令，会用条件指令解决文件的重复包含问题。
【学习方法指导】本章的内容比较简单，严格说来，它也不算是C++语言的组成部分。
但是，一般说来，任何程序都离不开预编译指令。
特别是文件包含指令和条件编译指令，应把它们搞清楚。
虽然可以用宏定义的方法定义常数，但推荐使用const语句定义常量。
在编程中，如果我们能恰当地运用条件编译，就可以提高程序运行的效率。
【知识点】宏定义；宏替换；简单的宏定义；带参数的宏定义；文件包含；条件编译第一节宏定义我们用C++进行编程的时候，可以在源程序中包括一些编译命令，以告诉编译器对源程序如何进行编译。
这些命令包括：宏定义、文件包含和条件编译，由于这些命令是在程序编译的时候被执行的，也就是说，在源程序编译以前，先处理这些编译命令，所以，我们也把它们称之为编译预处理，本章将对这方面的内容加以介绍。
实际上，编译预处理命令不能算是C++语言的一部分，但它扩展了C++程序设计的能力，合理地使用编译预处理功能，可以使得编写的程序便于阅读、修改、移植和调试。
预处理命令共同的语法规则如下：◇所有的预处理命令在程序中都是以"#"来引导如"#include "stdio.h""。
◇每一条预处理命令必须单独占用一行，如"#include "stdio.h" #include <stdlib.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)再与源程序合并说明：⑴宏名一般用大写表示，以便与变量名区分。
函数与预编译
4.1.3 函数的调用
函数调用：
所谓函数调用，就是使程序转去执行函数体。 在C++中，除了主函数外，其他任何函数都不能单独作 为程序运行。任何函数功能的实现都是通过被主函数直接或 间接调用进行的。
无参函数的调用格式： 函数名( ) 有参函数的调用格式： 函数名(实际参数表)
说明：
数据类型指函数返回值类型，可以是任一种数据类型, 默认为返回整型值（但新标准要求写明，不用默认方式）。 没有返回值应将返回值类型定义为void。
函数名采用合法标识符表示。 对无参函数，参数括号中的void通常省略，但括号不 能省略。 函数体由一系列语句组成。函数体可以为空，称为空 函数。
4.1.2 函数的定义
参数传递：
函数调用首先要进行参数传递，参数传递的方向是由实 参传递给形参。
传递过程是，先计算实参表达式的值，再将该值传递给 对应的形参变量。一般情况下，实参和形参的个数和排列顺 序应一一对应，并且对应参数应类型匹配（赋值兼容）,即 实参的类型可以转化为形参类型。而对应参数的参数名则不 要求相同。
传值调用和引用调用：
假如不模块化
读多少行的程序能让你不头疼？ main()当中能放多少行程序？ 假如 cout()函数由10行代码替换， 那么你见过的程序会成什么样子？
如果所有代码都在main()当中，团队怎么合作？
•如果代码都在一个文件中，怎么团队合作？
模块化思想
• 模块各司其职
– 每个模块只负责一件事情，它可以更专心 – 便于进行单个模块的设计、开发、调试、测试和维护
4.1 函数的定义与调用 4.2 函数的参数传递,
编译预处理的名词解释
编译预处理的名词解释编译预处理（Compiler preprocessor）是计算机科学中一个重要概念，它是编译器的前处理步骤，用于在源代码被编译前对其进行一系列的转换和操作。
编译预处理器是编译过程中的一个组件，它处理源代码中的预处理指令，对代码进行一些宏展开、条件编译等操作，然后再将处理后的代码提交给编译器进行编译。
一、编译预处理的定义和作用编译预处理是指在编译过程中对源代码进行处理的一系列操作。
预处理器会通过扫描源代码中的特殊指令，执行相应的操作，并将结果替换回源代码中。
预处理器可以实现代码的复用、条件编译、宏定义等功能，大大提高了代码的灵活性和可维护性。
编译预处理器最常用的功能之一是宏展开（Macro expansion）。
宏是一段预定义的代码片段，在代码中使用宏可以简化重复的代码，提高代码的可读性和维护性。
预处理器会将所有使用宏的地方替换为宏的定义内容，以此实现代码的复用。
二、条件编译条件编译（Conditional Compilation）是编译预处理中的一项重要功能。
通过条件编译，我们可以根据不同的条件选择性地编译源代码中的一部分。
这对于不同平台、不同版本的代码兼容性是非常有用的。
条件编译使用预处理指令#if、#ifdef、#ifndef、#elif、#else和#endif来实现。
我们可以根据条件表达式的结果来选择编译不同的代码块，从而实现特定条件下的代码执行。
三、头文件包含头文件包含（Header File Inclusion）是编译预处理中的另一个重要功能。
头文件包含用于将一个源文件中的代码引入到另一个源文件中。
这样，我们可以在不同的源文件中共享函数、常量、宏等定义，提高代码的复用性。
头文件被放置在使用它的源文件中，通常使用#include指令来进行包含。
头文件包含具有层次结构，可以通过嵌套的方式来引入多个头文件。
四、预定义宏预定义宏（Predefined Macros）是编译预处理器提供的一些内置宏，在编译过程中可供我们使用。
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语言 编译
c语言编译C语言是一种通用的高级编程语言，由美国计算机科学家丹尼斯·里奇于1972年在贝尔实验室开发。
C语言具有简洁、高效、可移植等特点，被广泛应用于系统软件、嵌入式软件、游戏开发、科学计算等领域。
C语言的编译过程是将源代码转换为可执行文件的过程，下文将详细介绍C语言的编译过程。
一、C语言的编译过程C语言的编译过程包括预处理、编译、汇编和链接四个阶段。
下面分别介绍这四个阶段的作用和实现方式。
1. 预处理预处理阶段是在编译之前进行的，其作用是将源代码中的预处理指令替换为实际的代码。
预处理指令以#号开头，包括#include、#define、#ifdef、#ifndef等指令。
预处理器将这些指令替换为实际的代码，生成一个新的源文件。
预处理后的源文件通常以.i作为扩展名。
2. 编译编译阶段是将预处理后的源代码转换为汇编代码的过程。
编译器将C语言源代码转换为一种称为中间代码的形式，中间代码是一种类似汇编语言的低级语言。
中间代码具有平台无关性，可以在不同的平台上进行优化和执行。
编译后的结果通常以.s作为扩展名。
3. 汇编汇编阶段是将编译生成的汇编代码转换为机器代码的过程。
汇编器将汇编代码转换为可执行的机器代码，并生成一个目标文件。
目标文件包括可执行代码、数据段、符号表等信息。
目标文件通常以.o 或.obj作为扩展名。
4. 链接链接阶段是将多个目标文件合并为一个可执行文件的过程。
链接器将目标文件中的符号和地址进行解析，生成一个可执行文件。
可执行文件包括操作系统可以直接执行的代码和数据，通常以.exe、.dll 或.so作为扩展名。
二、C语言编译器C语言编译器是将C语言源代码转换为可执行文件的工具，包括预处理器、编译器、汇编器和链接器四个部分。
C语言编译器可以在不同的平台上运行，生成可在目标平台上运行的可执行文件。
下面分别介绍常用的C语言编译器。
1. GCCGCC（GNU Compiler Collection）是一款开源的C语言编译器，由GNU组织开发。
c语言编译的正确过程
c语言编译的正确过程以C语言编译的正确过程C语言是一种广泛应用于软件开发领域的高级编程语言，它具有语法简洁、执行效率高等特点，因此备受程序员的喜爱。
编译是将C 语言源代码转换为可执行文件的过程，本文将详细介绍C语言编译的正确过程。
1. 预处理在编译过程开始之前，C语言编译器会首先进行预处理。
预处理器会对源代码进行扫描，解析并处理以"#"开头的预处理指令，如宏定义、条件编译等。
预处理的主要目的是对源代码进行预处理，将所有预处理指令替换为实际代码。
2. 词法分析词法分析是编译器的下一个阶段。
在这个阶段，编译器会将源代码分解为一个个的词法单元，如关键字、标识符、运算符、常量等。
编译器会根据C语言的语法规则对每个词法单元进行解析和分类。
3. 语法分析语法分析是编译器的关键阶段之一。
在这个阶段，编译器会根据C 语言的语法规则，对词法单元进行语法分析，构建语法树。
语法树是一种树状结构，用于表示源代码的语法结构，便于后续的语义分析和代码生成。
4. 语义分析语义分析是编译器的另一个关键阶段。
在这个阶段，编译器会对语法树进行分析，检查语义错误和类型匹配等问题。
如果发现错误，编译器会生成相应的错误信息。
同时，编译器还会进行符号表的构建，用于记录变量、函数等符号的信息。
5. 代码生成代码生成是编译器的最后一个阶段。
在这个阶段，编译器会根据语义分析的结果，将语法树转换为目标平台的机器代码。
代码生成过程中，编译器会进行优化，以提高程序的执行效率。
优化包括常量折叠、循环展开、指令调度等技术。
6. 链接链接是将编译生成的目标文件与库文件进行合并，生成可执行文件的过程。
链接器会对目标文件进行符号解析和重定位，将各个模块的目标代码链接在一起，生成最终的可执行文件。
链接过程还包括对库文件的搜索和加载。
7. 运行编译生成可执行文件后，就可以运行程序了。
在运行过程中，操作系统会加载可执行文件到内存中，并按照指令进行执行。
C语言 函数 预处理
例6-1 文件包含预处理语句的使用
mymath.h的内容如下： # define ADD(x,y) (x+y) # define MUL(x,y) ((x)*(y)) # define PI 3.1415926 # define G 2.718 test.c内容如下： # include “mymath.h” main ( ) { int a=6,b=9; printf(“a+b=%d\n”,ADD(a,b)); printf(“a*b=%d\n”,MUL(a,b)); }
（5）使用宏次数多时，宏展开后源程序长，因为每 展开一次都使程序增长；而函数调用不使程序变长。 （6）宏替换不占用运行时间，而函数调用则占用运 6 行时间（分配内存单元、保护现场、值传递、执行 函数、返回函数值等）。
6．3 条件编译 ．
在很多情况下，为了增强程序的可移植 性，C语言源程序中包含了各种版本的程序段， 但在某种情况下，只希望对一部分内容进行 编译，即为其指定编译的条件，此时称为条 件编译。
例6-3 带参数的宏定义 #define POWER(x) ((x)*(x)) main() { int y; scanf(“%d”,&y); printf(“y=%d, y*y=%d\n”,y, POWER(y)); }
从上述例题中可以看出，带参数的宏定义与函 数的使用非常相似，但二者是不同的。两者的区别 有如下几点： （1）函数调用时先求出实参的值，然后代入形参。 而带参数的宏定义只是进行简单的字符替换。 （2）函数调用是在程序运行时处理的，并分配临时 的内存单元。而宏展开则是在编译预处理时进行的， 在展开时并不分配内存单元，不进行值的传递，也 没有“返回值”。
第6章 编译预处理 章
C&&C++编译过程
C/C++编译过程C/C++编译过程主要分为4个过程1) 编译预处理2) 编译、优化阶段3) 汇编过程4) 链接程序一、编译预处理（1）宏定义指令，如#define Name TokenString，#undef等。
对于前一个伪指令，预编译所要做的是将程序中的所有Name用TokenString替换，但作为字符串常量的Name则不被替换。
对于后者，则将取消对某个宏的定义，使以后该串的出现不再被替换。
（2）条件编译指令，如#ifdef，#ifndef，#else，#elif，#endif等。
这些伪指令的引入使得程序员可以通过定义不同的宏来决定编译程序对哪些代码进行处理。
预编译程序将根据有关的文件，将那些不必要的代码过滤掉（3）头文件包含指令，如#include "FileName"或者#include <FileName>等。
在头文件中一般用伪指令#define定义了大量的宏（最常见的是字符常量），同时包含有各种外部符号的声明。
包含到c源程序中的头文件可以是系统提供的，这些头文件一般被放在/usr/include目录下。
在程序中#include它们要使用尖括号（< >）。
另外开发人员也可以定义自己的头文件，这些文件一般与c源程序放在同一目录下，此时在#include中要用双引号（""）。
（4）特殊符号，预编译程序可以识别一些特殊的符号。
例如在源程序中出现的#line标识将被解释为当前行号（十进制数），上面程序实现了对宏line的运用（5）预处理模块预处理工作由#pragma命令完成，#Pragma命令将设定编译器的状态或者是指示编译器完成一些特定的动作。
#pragma指令对每个编译器给出了一个方法,在保持与C和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、预处理——精选推荐
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语⾔的⼀个重要功能，由预处理程序完成。
HUST函数与程序结构_编译预处理实验
函数与程序结构，编译预处理2.4 函数与程序结构实验(一) 实验目的（1）熟悉和掌握函数的定义、声明；函数调用与参数传递方法；以及函数返回值类型的定义和返回值使用。
（2）熟悉和掌握不同存储类型变量的使用。
（3）熟悉多文件编译技术。
(二) 实验内容及要求1．源程序改错下面是计算s=1!+2!+3!+…+n!的源程序，在这个源程序中存在若干语法和逻辑错误。
要求在计算机上对这个例子程序进行调试修改，使之能够正确完成指定任务。
改正后代码如下（1）#include<stdio.h>long sum_fac(int n){static long f=1,s=0;f*=n;s+=f;return s;}void main(void){int k,n;printf("please input n:\n");scanf("%d",&n);for(k=1;k<=n;k++)printf("k=%d\tthe sum is %ld\n",k,sum_fac(k));}代码运行结果：（2）#include<stdio.h>long double sum_fac(int n){long double s=0;int i;long double fac=1;for(i=1;i<=n;i++)fac*=i,s+=(1.0/fac);return s;}void main(void){int k,n;printf("please input n:\n");scanf("%d",&n);for(k=1;k<=n;k++)printf("k=%d\tthe sum is %lf\n",k,sum_fac(k));}运行结果如下：3．跟踪调试下面是计算fabonacci数列前n项和的源程序，现要求单步执行该程序，并观察p,i,sum,n值,即：（1）刚执行完scanf("%d",&k);语句时，p,i值是多少？（2）从fabonacci函数返回后,光条停留在哪个语句上？（3）进入fabonacci函数时，watch窗口显示的是什么？（4）当i=3时，从调用fabonacci函数到返回，n值如何变化？源程序：void main(void){int i,k;long sum=0,*p=∑scanf("%d",&k);for(i=1;i<=k;i++){sum+=fabonacci(i);printf("i=%d\tthe sum is %ld\n",i,*p);}}long fabonacci(int n){if(n==1 || n==2)return 1;elsereturn fabonacci(n-1)+fabonacci(n-2);}（1）（2）4．程序设计编写并上机调试运行能实现以下功能的程序。
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)。
函数的定义及调用、递归调用、 变量的作用域。
上一页
下一页
4.1模块化程序设计与函数
在设计较复杂的程序时，我们一般采用的方法是： 把问题分成几个部分，每部分又可分成更细的若干小 部分，逐步细化，直至分解成很容易求解的小问题。 这样的话，原来问题的解就可以用这些小问题来表示。
把复杂任务细分成多个问题的过程，就叫程序的 模块化。模块化程序设计是靠设计函数和调用函数实 现的。
嵌套和递归 变量的作用域
上一页
下一页
函数举例
• #include <conio.h>
main()
{ int a,b,m;
/*说明变量*/
int max(int a,int b); ",&a,&b); /*调用库函数scanf*/
m=max(a,b);
/*调用字定义函数max*/
第四章 函数与编译预处理
4.1 模块化程序设计与函数 4.2 函数的定义与调用 4.3 函数的递归调用 4.4 变量作用域与存储方式 4.5 编译预处理 4.6 函数设计举例
教学目的和基本要求：
要求学生了解模块化程序设计的思 想，掌握函数的定义及调用，理解 变量的作用域与存储方式的概念， 理解编译预处理的概念。
上一页
下一页
模块与函数
C语言程序由基本语句和函数组成，每个函数可完成相对独立的 任务，依一定的规则调用这些函数，就组成了解决某个特定问题的 程序。
任务、模块与函数的关系:
任务
模块
模块
模块
函数 函数 函数 函数
上一页
下一页
函数
函数
看这样一个问题：求[200,1000]的双胞胎数的对数。双胞胎数：两素 数差为2称为双胞胎数。
t = t * x; return t; }
}
求1!+2!+3!+…+10!
算法 i =1; s=0; 当 i <= 10 s=s+ i! 定义求 i! 的函数
上一页
下一页
求1!+2!+3!+…+10! 程序
void main() { long mm( int ); /*自定义求阶乘函数应先声明 */
调用printf函数时， 必须include<stdio.h>
上一页
下一页
自定义函数
可以把完成一个任务的过程写成函数。
int A_to_a(int capital) {int small; if (capital>=‘A’ && capital<=‘Z’)
small= capital – (‘A’-’a’); return small; }
下一页
C语言程序处理过程全部都是以函数形式出 现，最简单的程序至少也有一个main函 数。函数必须先定义和声明后才能调用。
上一页
下一页
标准库函数
C语言有丰富的库函数，这些函数的说明在 不同的头文件(*.h)中。
想要调用标准的库函数，就必须include。
#include<stdio.h> main() {printf(“%d”,1024*768); }
上一下页面我们详细介绍函数调用下的一格页式和语法规定。
4.2 函数的定义与调用
在C语言中,函数（Function）是一个处理过程，可以进 行数值运算、信息处理、控制决策，即一段程序的 工作放在函数中进行，函数结束时可以携带或不带 处理结果。
库函数(标准函数)：系统提供 自定义函数：用户自己写
上一页
这是我们上一章结束的一道练习题，下面的左边是我们当时编的程序。
main( )
我们注意到，程序中用 筐住的部分
{ int a,b,n=0,I; for(a=200;a<=998;a++) { for(I=2;I<a;I++) if(a%I==0) break;
是完成了相同的功能，即判断一个数(a 或b)是否是素数。我们可以考虑用一个 独立的函数来完成判断素数的功能，在
if(a>b) y=a; else y=b;
上一页
下一页
自定义函数的声明
自定义函数在调用前应先声明。使系统知道将要用到某个 函数及它的类型，以便处理。函数声明应与该函数定义时 给出的函数类型与名字、形参的个数、类型、次序相一致。
#include “stdio.h”
void main()
{float x,y;
for(a=200;a<=998;a++) {if(f(a)==1) { b=a+2;
for(I=2;I<x;I++) if(x%I==0) break;
}
if(f(b)==1) n++;
if(x==I) return 1;
} } printf(“\n%d”,n);
else return 0; }
}
int i; long s=0; for (i =1; i <=10; i ++)
s+= mm(i ); /*调用求阶乘函数,求I的阶乘 */ printf(“\n%ld”,s);
int n;
float power (float x, int n);
scanf("%f,%d", &x, &n);
y = power(x, n);
上一pr页intf(“%8.2f”,y );
下一页
float power( float x, int n) { int i;
float t=1; for(i=1; i<=n; i++)
if(a==i)
主函数中调用此函数即可。如下：
{ b=a+2;
for(I=2;I<b;I++) if(b%I==0) break;
main( ) { int a,b,n=0;
int f(int x)
if(b==i) n++;
int f(int x);
{ int I;
} } printf(“\n%d”,n);
返回值类型名 函数名
参数说明和参数列表 定义局部变量
返回值
另的最注如外调好意果请用只不不注函使要需意数用与返这时局已回样输部有则的入变库可判参量函r断数e，数tu，的这r重n如格样0名;写式将成要方‘与便之A调’<相试ca同。pital<‘Z’是不行
上一页
下一页
“函数”的主要知识点
函数的定义 函数的参数和返回值 函数的调用
printf("max=%d\n",m)); /*调用库函数printf*/
getch();
/*调用库函数getch*/
}
上一页
下一页
函数举例
int max(int a,int b) /*定义函数max*/ { int y; y=(a>b)? a:b; /*条件表达式 */ return y; }