1. 预定义符号

C语言设置了一些预定义符号，可以直接使用，预定义福海也是在预处理期间处理的

int main()
{
	printf("%s\n", __FILE__);//当前被编译文件的路径
	printf("%s\n", __DATE__);//文件被编译的日期
	printf("%s\n", __TIME__);//文件被编译的时间
	printf("%d\n", __LINE__);//文件当前的行号
	//printf("%d\n", __STDC__);//说明VS不支持ANSIC

}

2. #define定义常量

基本语法：

#define name stuff

#define M 100
#define STR "hehe"
#define forever for(;;)//死循环
#define CASE break;case
// 如果定义的 stuff过⻓，可以分成⼏⾏写，除了最后⼀⾏外，每⾏的后⾯都加⼀个反斜杠(续⾏符)。 
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
 date:%s\ttime:%s\n" ,\
 __FILE__,__LINE__ , \
 __DATE__,__TIME__ )

int main()
{
	int n = 0;
	switch (n)
	{
	case 1:
		//
	CASE 2:
		//
	CASE 3:
		//
	CASE 4:
	}
	return 0;
}

3. #define定义宏

#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏或者定义宏

下面是宏的声明方式

#define name( parament-list ) stuff

其中的parament-list是一个逗号隔开的符号表，他们可能出现在stuff中

注意：
参数列表的左括号必须与name紧邻，如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分

#define SQU(x) x*x
//转换成
#define SQU(x) (x)*(x)

//本质原因是宏的参数不运算，直接替换到宏的体内
//1.宏的参数中如果有表达式，和宏的内容中的操作符
//因为运算符有优先级的问题，可能导致运算顺序不达到预期
//所以容易产生问题
//2.宏在书写的时候，给参数都带上括号，不要吝啬括号

int main()
{
	int a = 5;
	printf("%d\n", SQU(a));//25
	printf("%d\n", SQU(a+1));//a+1*a+1=11
	
}

上述代码的解析：

#define SQU( x ) x * x

这个宏接收一个参数.如果在上述声明之后，你把SQU(5);置于程序中，预处理器就会用下面这个表达式替换成上面的表达式5 * 5

警告：
这个宏存在一个问题：

int a = 5;
printf ( " %d\n " , SQU(a+1) );

乍一看，可能觉得代码结果会是36，实际上打印了11，那么是为什么呢？
在替换文本时，参数x被替换成a+1，所以这条语句实际上变成了

printf( “%d\n” ,a+1 * a+1);

这样就比较清晰了，由于替换产生的表达式并没有按照预想的次序进行求值
在宏定义上加上括号，这个问题便比较轻松的解决了：

#define SQU(x) (x)*(x)

所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用时由于参数中的操作符或邻近操作符之间不可预料的相互作用

练习

写一个宏，求参数的2倍

#define double(x) 2*(x)
int main()
{
	int a = 5;
	int r = double(a);
	printf("%d\n", r);
	return;
}

4. 带有副作用的宏参数

当宏参数在宏定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现永久性的效果

例如：

x+1;//不带副作用
x++;//带有副作用

int main()
{
	int a = 5;
	int b = 4;
	int m = max(a, b);//5
	int m = max(a++, b++);//6
	//int m = max((a++)>(b++)?(a++):(b++))
	printf("%d\n", m);
	return 0;
}

5. 宏替换的规则

在程序扩展#define定义符号和宏时，需要涉及几个步骤

1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换
2. 替换文本随后被插入到程序原来文本的位置。对于宏，参数名被他们的值所替换
3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程

注意：

1. 宏参数和#define定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归
2. 当预处理器搜素#define定义的符号的时候，字符串常量的内容并不被搜索

6. 宏函数的对比

宏通常被应用于执行简单的运算
比如在；两个数找出较大的一个时，写成下面的宏，更有优势一些

#define MAX(a, b) ((a)>(b)?(a):(b))

那为什么不用函数完成这个任务？

原因有二：

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹
2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整型、长整型、浮点型可以用于>来比较的类型。宏是类型无关的

和函数相比的劣势：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度
2. 宏是没法调试的
3. 宏由于类型无关，也就不够严谨
4. 宏可能会带来运算符优先级的问题，导致程序容易出现错误

宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，函数函数做不到。

#define MALLOC(num, type)\
 (type )malloc(num sizeof(type))
...
//使⽤
MALLOC(10, int);//类型作为参数
//预处理器替换之后：
(int)malloc(10 sizeof(int));

宏和函数的一个对比

属性	#define定义宏	函数
代码长度	每次使用时，宏代码都会被插入到程序中。 除了非常小的宏之外，程序的长度会大幅度增长	函数代码只出现于一个地方；每次使用时，都调用那个地方的同一份
执行速度	更快	更慢
操作符优先级	宏采纳数的求值是在所有周围表达式的上下文环境里，除非加上括号，否则近邻操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多一些括号	函数参数只在函数调用的时候求值结果值传递给函数。表达式的求值可预测的
带有副作用的参数	参数可能被替换到宏体中的多个位置，如果宏的参数被多次计算，带有副作用的参数求值可能会产生不可预料的结果	函数参数只在传参的时候求值是易于控制的
参数类型	宏的参数与类型无关，只要对参数的操作是合法的，它就可以用于适用于任何参数的类型	函数的参数与类型有关，如果参数类型不同，就需要不同的函数
调试	宏是不方便调试的	函数是可以逐语句调试的
递归	宏是不能递归的	函数是可以递归的

7. #和##

#运算符

#运算符将宏的一个参数小欢欢为字符串字面量。它仅允许出现在在参数的宏的替换列表中
#运算符所执行的擦欧洲哦可以理解为**“字符串化”**
当我们又一个变量int a = 10;的时候，我们想打印：the value of a is 10
就可以写

#define PRINT(n) printf(“the value of “#n” is %d” , n);

当我们按照下面的方式调用的时候：
PRINT（a）;//当我们把a替换到宏的体内时，就出现了#a,而#a就是转换为“a”,时一个字符串
代码就会被预处理为：

/printf(“the value of “a” is %d”, a);

#define PRINT(val,format) printf("the value of "#val" is "format"\n",val)

int main()
{
	int a = 10;
	PRINT(a, "%d");
	//printf("the value of a is %d\n", a);

	int b = 20;
	PRINT(b, "%d");
	//printf("the value of b is %d\n", b);

	int f = 4.4f;
	PRINT(f, "%d");
	//printf("the value of f is %d\n", f);

	return 0;
}

##运算符

##可以把位于它两边的符号合成一个符号，它允许宏定义从分离的文本片段创建标识符。##被称为记号粘合
这样的连接必须产生一个合法的标识符。否则其结果就是未定义的
这里我们想象，写一个函数求2个数的较大值的时候，不同的数据类型就得写不同的函数

但是这样写起来态繁杂了，现在我们使用宏定义不同的函数

//使用宏，定义的一个通用的函数模具
#define M_max(type)\
type type##_max(type x, type y)\
{\
	return (x>y?x:y);\
}\

M_max(int)//替换到宏体内后int##_max ⽣成了新的符号 int_max做函数名
//相当于
int int_max(int x, int y)\
{\
return (x > y ? x : y);\
}
M_max(float)//替换到宏体内后float##_max ⽣成了新的符号 float_max做函数名
M_max(double)

8. 命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者
那我们平时的一个习惯是：

宏一般全大写‘
函数名一般不全大写

但是也有例外
offsetof

9. #undef

这条指令用于移除一个宏定义

#undef NAME
如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除

10. 命令行定义

许多C的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程

例如：
当我们根据同一个源文件要编译出一个程序的不同版本的时候，这个特性有点用处（假设某个程序声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大些，我们需要一个数组能够大些）

#include <stdio.h>
int main()
{
 int array [ARRAY_SIZE];
 int i = 0;
 for(i = 0; i< ARRAY_SIZE; i ++)
 {
 array[i] = i;
 }
 for(i = 0; i< ARRAY_SIZE; i ++)
 {
 printf("%d " ,array[i]);
 }
 printf("\n" );
 return 0; }

编译指令

在Linux环境下演示
gcc -D ARRAY_SIZE=10 programe.c

11. 条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们又条件编译指令

比如说：
调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译

#define __DEBUG__
int main()
{
	int i = 0;
	int arr[10] = { 0 };

	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
#ifdef __DEBUG__
		printf("%d\n", arr[i]);//为了观察数组是否赋值成功
#endif

	}
	return 0;
}

常见的条件编译

1.
#if 常量表达式
 //...
#endif
//常量表达式由预处理器求值。 如：#define __DEBUG__ 1
#if __DEBUG__
 //..
#endif

2.多个分⽀的条件编译 
#if 常量表达式
 //...
#elif 常量表达式
 //...
#else
 //...
#endif

3.判断是否被定义 
#if defined(symbol)	//如果被定义了
#ifdef symbol
#if !defined(symbol)	//如果没被定义
#ifndef symbol

4.嵌套指令
 #if defined(OS_UNIX)
 #ifdef OPTION1
 unix_version_option1();
 #endif
 #ifdef OPTION2
 unix_version_option2();
 #endif
#elif defined(OS_MSDOS)
 #ifdef OPTION2
 msdos_version_option2();
 #endif
#endif

int main()
{
#if 1==2
	printf("hehe\n");
#endif
	return 0;
}

#define M 2

int main()
{
#if M==1
	printf("hehe");
#elif M==2
	printf("haha");
#else
	printf("~~~~~");
#endif
	return 0;
}

12. 头文件的包含

头文件的包含方式

#include “filename”

查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件
如果找不到就是提示编译错误

Linux环境的标准头文件的路劲：

/usr/include

VS环境的标准头文件的路径：

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
这是VS2013的默认路劲

注意按照自己的安装路劲去查找

库文件包含

#include <filename.h>

查找文件直接去标准路径下去查找，如果找不到就提示编译错误

这样是不是可以说，对于库文件也可以使用“”的形式包含
答案是可以的，但是这样做查找的效率就低些，当然也不容易区分库文件还是本地文件了

嵌套文件包含

我们已经知道，#include指令可以使另外一个文件被编译。就像它实际出现于#include指令的地方一样

这种替换的方式很简单：预处理器先删除这条指令，并用包含文件的内容替换
一个头人间被包含10次，那就实际被编译10次，如果重复包含，对编译的压力就比较大了

test.c

#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
int main()
{
 
 return 0; }

test.h

void test();
struct Stu
{
 int id;
 char name[20];
};

如果直接这样写，test.c文件中将test.h包含5次，那么test.h文件的内容将会被拷贝5份在test.c中

如果test.h文件比较大，这样预处理后代码会剧增。如果工程比较大，有公共使用的头文件，被大家都能使用，又不做任何处理，那么后果真的不堪设想

如何解决文件重复引入的问题
条件编译

每个头文件开头写：

#ifndef __TEST_H__
#define __TEST_H__
//头⽂件的内容 #endif //__TEST_H__

或者

#pragma once

就可以避免头文件的重复引入

13. 其他预处理指令

#error
#pragma
#line
...
 #pragma pack()在结构体部分介绍。