1.编译预处理
• 编译是指把高级语言编写的源程序翻译成计算机可识别的二进制程序（目标程序）的过程，它由编译程序完成。
• 编译预处理是指在编译之前所作的处理工作，它由编译预处理程序完成
在对一个源程序进行编译时，系统将自动调用预处理程序对源程序中的预处理部分作处理，处理完毕后自动编译源程序
2.宏定义
- 宏：Ｃ语言源程序中允许用一个标识符来表示一个字符串
- 宏名：被定义为宏的标识符
- 宏展开：在编译预处理时，对程序中所有出现的宏名，都用宏定义中的字符串替换
- 宏定义由宏定义命令完成
- 宏展开由预处理程序自动完成
- 宏分为：不带参数的宏和带参数的宏
3.不带参数的宏定义
不带参数的宏，其宏名后不带参数
**#**define 标识符 字符串
#define PI 3.1415926
"标识符"是为所定义的宏名
"字符串"为宏名将要被替换的字符串，可以是常量字符串、表达式字符串、格式字符串等
宏定义
常量宏定义
cpp
//【例9. 1】常量的宏定义。
#include <stdio.h>
#define PI 3.1415926
void main()
{ float r,l,s,v;
printf("Input radius: ");
scanf("%f",&r);
l=2.0*PI*r; //宏展开为 l=2.0*3.1415926*r;
s=PI*r*r; //宏展开为 s=3.1415926*r*r;
v=4.0/3*PI*r*r*r; //宏展开为 v=4.0/3*3.1415926*r*r*r;
printf("l=%.4f\ns=%.4f\nv=%.4f\n",l,s,v);
} 表达式的宏定义
cpp
//【例9. 2】表达式的宏定义。
#include <stdio.h>
#define M (y*y+3*y)
void main()
{ int s,y;
printf("Input a number: ");
scanf("%d",&y);
s=3*M+4*M+5*M; //宏展开为 s=3*(y*y+3*y)+4*(y*y+3*y)+5*(y*y+3*y);
printf("s=%d\n",s);
}函数名和格式字符串的宏定义
cpp
//【例9. 3】函数名和格式字符串的宏定义。
#include <stdio.h>
#define P printf
#define F "%4d\t%.2f\n"
void main()
{ int a=3, c=5, e=11;
float b=4.6, d=7.9, f=22.08;
P(F,a,b); //宏展开为 printf("%4d\t%.2f\n",a,b);
P(F,c,d); //宏展开为 printf("%4d\t%.2f\n",c,d);
P(F,e,f); //宏展开为 printf("%4d\t%.2f\n",e,f);
}宏
说明：
（ 1 ）宏不是变量，不能存数据，也没有数据类型
（ 2 ）宏定义与变量定义不同，它只作字符串替换，不分配内存空间
（ 3 ）宏名习惯上用大写字母表示，以便与变量名相区别，但也允许用小写字母
（ 4 ）宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串替换宏名，这只是一种简单的源程序代码的替换。
• 字符串中可以包含任何字符，预处理程序不作任何正确性检查。只有在编译已经预处理后的源程序时才能发现
define PI 3.l4l5926
把数字"1"写成了小写字母"l"
（ 5 ） 宏定义不是语句或说明，在行末不必加分号 ，如加上分号则连分号也一起替换
#define PI 3.1415926;
......
area=PI*r*r;
......
宏展开后为： area=3.1415926;*r*r;
（6）在源程序中用双引号引起来的字符串内，与宏名相同的字符不进行替换
cpp
//【例9. 4】双引号中与宏名相同的字符不作替换。
#include <stdio.h>
#define PI 3.1415926
void main()
{ printf("PI\n"); //不进行宏展开
printf("%f\n",PI); //进行宏展开
}（ 7 ）宏定义允许嵌套，在宏定义的字符串中可以使用已经定义的宏名
#define PI 3.1415926
#define S PI*r*r // PI 是已定义的宏名
语句： printf("%f",S);
宏展开后为： printf("%f",3.1415926*r*r);
（8）宏定义必须写在函数之外，其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用# undef命令。
cpp
//【例9. 5】使用# undef结束宏的作用域。
#include <stdio.h>
#define PI 3.1415926
void main()
{ float r=2,area;
area=PI*r*r;
//宏展开为area=3.1415926*r*r;
printf("area=%f",area);
}
#undef PI
f1()
{ float r=2,area;
area=PI*r*r;
//PI不能被宏展开，此处语法报错，PI没有定义
printf("area=%f",area);
}带参数的宏定义
Ｃ语言允许宏带参数。
宏定义中的参数称为形式参数，在程序中使用宏的语句中的参数称为实际参数。
在预编译时，带参数的宏不但要进行宏展开，而且要用实参去替换形参。
#define 宏名 ( 形参表 ) 字符串
在源程序中使用带参数的宏的一般形式为 :
宏名 ( 实参表 ) ；
cpp
//【例9. 6】带参数的宏定义。
#include <stdio.h>
#define MAX(a,b) (a>b)?a:b
void main()
{ int x,y,max;
printf("Input two numbers:");
scanf("%d,%d",&x,&y);
max=MAX(x,y); //宏展开为 max=(x>y)?x:y;
printf("max=%d\n",max);
}（ 1 ）宏名和形参表外的括号之间不能加空格。否则将空格以后的字符都作为替代字符串的一部分。
例如 :
宏定义" #define MAX(a,b) (a>b)?a:b"
改写为：
#define MAX (a,b) (a>b)?a:b
语句： max=MAX(x,y);
宏展开后为：max=(a,b) (a>b)?a:b(x,y); 是错误的。
（2）宏定义中的形参是标识符，语句中的实参可以是表达式
cpp
【例9. 7】语句中的实参为表达式。
#include <stdio.h>
#define SQ(y) (y)*(y)
void main()
{ int a,sq;
printf("Input a number: ");
scanf("%d",&a);
sq=SQ(a+1); //宏展开为 sq=(a+1)*(a+1);
printf("sq=%d\n",sq);
}（3）在宏定义中，形参通常要用括号括起来以避免出错。
宏定义：
#define SQ(y) (y)*(y)
中(y)*(y)表达式的y都用括号括起来，因此结果是正确的
如果去掉括号，定义形式如下：
#define SQ(y) y*y
语句： sq=SQ(a+1);
宏展开后为：sq=a+1*a+1;
• 有时即使在参数两边加括号还是不够的
按以下形式定义：
#define SQ(y) (y)*(y)
语句：sq=1.0/SQ(a+1);
宏展开后为：
sq=1.0/(a+1)*(a+1); //先算除法，再算乘法
要想先算乘法后算除法，应该在宏定义中的整个字符串外加括号，按如下形式定义：
#define SQ(y) ((y)*(y))
带参数的宏和函数的区别
带参数的宏和带参数的函数的区别：
（ 1 ）函数调用时，将值传给形参。带参数的宏展开时只是完整的实参表达式字符替代形参。
（ 2 ）函数调用在程序运行时进行。宏展开在编译前进行。
（ 3 ）函数中的形参和实参都要定义类型。宏的形参无需定义类型，它们都只是一串字符。
（ 4 ）调用函数只可得到一个返回值，而宏可以设法得到几个结果。
cpp
//【例9. 8】通过宏展开得到若干结果。
#include <stdio.h>
#define SSSV(L,W,H,SA,SB,SC,VV) SA=L*W;SB=L*H;SC=W*H;VV=W*L*H;
void main()
{ int l=3,w=4,h=5,sa,sb,sc,vv;
SSSV(l,w,h,sa,sb,sc,vv); //宏展开后为sa=l*w;sb=l*h;sc=w*h;vv=w*l*h;
printf("sa=%d\nsb=%d\nsc=%d\nvv=%d\n",sa,sb,sc,vv);
} 调用函数只可得到一个返回值，而宏可以设法得到几个结果。
文件包含
• 文件包含是指一个源文件中可以包含另一个源文件，即把另一个源文件插入到该文件中
文件包含命令的一般形式为：
#include "文件名"
或
#include <文件名>
• 文件包含命令的功能是把文件名所指定的文件插入到该命令行位置并取代该命令行，从而把指定的文件与当前的源程序文件连成一个源文件
• #include"file2.c"
cpp
//【例9. 9】文件包含命令的使用。
（1）文件file1.c内容如下：
#include <stdio.h>
#include "file2.c"
void main()
{ int a,b,c;
printf("Input two numbers: ");
scanf("%d,%d",&a,&b);
c=max(a,b);
printf("max=%d\n",c);
}
cpp
//（2）文件file2.c内容如下：
int max(int x,int y)
{ int z;
if(x>y) z=x;
else z=y;
return(z);
}（ 1 ）文件头部的被包含文件，常以" .h" 为后缀。也可用" .c" 或" .cpp" 为后缀，也可无后缀。
（ 2 ）一个 #include 命令只能指定一个被包含文件
（ 3 ）文件包含允许嵌套，即在一个被包含的文件中又可以包含另一个文件
（ 4 ）包含命令中的文件名可以用双引号括起来，也可以用尖括号括起来
#include <stdio.h>
#include "file2.h "
① 使用尖括号时，系统直接在存放 C 库函数头文件的系统目录中寻找，这称为标准方式。
②使用双引号时，系统先在用户当前目录（即源文件所在目录）中寻找，若找不到，再按标准方式查找（即按尖括号的方式查找）
条件编译
条件编译：有时希望程序中一部分语句只在满足一定条件时才进行编译，不满足条件时不进行编译，或编译另一部分语句
利用条件编译，可以减少程序的输入，方便程序的调试，增强程序的可移植性
条件编译-形式一
#ifdef 标识符
程序段1
#else
程序段2
#endif
#ifdef 标识符
程序段
#endif
功能是：如果所指定标识符在之前已被 #define命令定义过，则在编译时编译程序段1；否则编译程序段2。
【例9. 10】给定半径r，求圆的面积s。要求设置条件编译：若π值已定义，则直接计算面积；若π值未定义，则定义π值后再计算面积。
#include <stdio.h>
void main()
{ float r,s;
printf("Input radius: ");
scanf("%f",&r);
#ifdef PI //条件编译
s=PI*r*r; //程序段1
#else
#define PI 3.1415926 //程序段2
s=PI*r*r;
#endif
printf("s=%f\n",s);
}
（1）程序中在条件编译前未定义π值（即PI），所以编译程序段2
（2）若程序开头加入宏定义"#define PI 3.1415926"，则编译程序段1
条件编译-形式二
#ifndef 标识符
程序段1
#else
程序段2
#endif
功能是：如果标识符之前未被#define命令定义过，则对程序段1进行编译，否则对程序段2进行编译
【例9. 11】按形式二修改【例9. 10】的程序。
#include <stdio.h>
void main()
{ float r,s;
printf("Input radius: ");
scanf("%f",&r);
#ifndef PI //条件编译
#define PI 3.1415926 //程序段1
s=PI*r*r;
#else
s=PI*r*r; //程序段2
#endif
printf("s=%f\n",s);
}
（1）程序中在条件编译前未定义π值（即PI），所以编译程序段1
（2）若在程序的开头加入宏定义"#define PI 3.1415926"，则编译程序段2
条件编译-形式三
#if 表达式
程序段1
#else
程序段2
#endif
功能是：若表达式的值为真（非0），则编译程序段1，否则编译程序段2
【例9. 12】设置条件编译。求圆的面积或正方形的面积。
cpp
#include <stdio.h>
#define PI 3.1415926
#define R 1
void main()
{ float c,s;
printf ("Input a number: ");
scanf("%f",&c);
#if R //条件编译
s=PI*c*c; //程序段1
printf("Area of circle is : %f\n",s);
#else
s=c*c; //程序段2
printf("Area of square is : %f\n",s);
#endif
}程序宏定义中，定义R为1，因此在条件编译时，表达式R的值为真，故编译程序段1，求圆的面积
说明
（ 1 ）三种形式的条件编译必须严格按照形式说明中的格式书写，每条条件编译命令必须单独成行
#if R s=PI*c*c; // 出错
将程序段" s=PI*c*c;" 与条件编译命令" #if R" 写在同一行，是不正确的
（ 2 ）形式一和形式二中的标识符，若在条件编译之前被 #define 命令定义过，不管被定义为何值，甚至不定义任何值，只要被定义过，都会编译相应的程序段
#ifdef COMPUTER_A
#define INTEGER_SIZE 16
#else
#define INTEGER_SIZE 32
#endif
（ 3 ）形式三与形式一和形式二不同，" #if" 后为表达式，不是标识符，所以不存在定义过还是未定义过的问题。只要该表达式的值为真（非 0 ），就编译程序段 1 ，否则编译程序段 2 。
（ 4 ）条件编译命令允许嵌套使用
• 在条件编译中也可以使用语句： #elif 它代表 else if
