预处理是什么

在我们写完C语言程序的时候当我们开始运行程序时，程序会经过预处理，编译，汇编，链接这些过程之后才会生成可执行程序，这里我们讲的是预处理，预处理是编译的第一个阶段，在这个阶段，将对源文件进行文本操作，像删除注释，打开头文件插入头文件的内容，例如这些头文件

# include<stdio.h>
# include<string.h>

除此之外，还有替换#define定义的宏，#define命令可以允许把一个名称指定成任何的所需文本

# define N 5
# define M 3

这里程序运行时将会把代码中M和N出现的地方替换成5或者3 这个就是宏替换

define定义常量

下面我们来讲一下define定义常量的基本语法

# define number 5//把5替换成number
# define stu student//这样把命名简化
# define CSAE break;case//在写case时自动加上break
# define DO_FOREVER for(;;)//更加形象化
# define MALLOC(number,type)\
      (type*)malloc(number*sizeof(type))
//如果要先的定义代码过长可以用\来表示增加一行

有了这些定义可以帮助我们在写代码的时候能减少一些代码量，也可以起到代码有着更好的阅读性的作用。
还有在定义的时候要不要加;号？
我们来看看下面代码

# define number 5;
# include<stdio.h>
int main()
{
    
int a = number;//替换之后变成int a = 5;;
return 0;
}

如果在定义的时候加了分号，在下面使用的时候就会有两个分号，编译器就会报错，程序无法运行，所以根据我们平时的代码习惯最好不要加;号

define定义宏

#define 机制包括了⼀个规定，允许把参数替换到⽂本中，这种实现通常称为宏（macro）或定义宏（define macro）。下⾯是宏的申明⽅式：

#define name( parament-list ) stuff

其中的 parament-list 是⼀个由逗号隔开的符号表，它们可能出现在stuff中。
注意

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

这段话通俗来说就是 parament-list 就像我们平时写函数里面的参数，而stuff就是我们函数里面的内容，但实质上宏函数和我们平常写的函数还是有所不同的，这里方便理解可以理解成这样。
举例

# define ADD(x) (x+x)

这个宏接收一个参数x，在运行程序后会讲把源程序里面的ADD(x)部分替换成 x + x,x的值是多少这个宏就计算两个相同的数相加是多少，我们在看看下面的代码

# define fun(x+1) (x * x)

假设我们这里x传5想想这个宏的的值是多少？按照我们通常的思维来看这个算出来的值是36，但如果我们运行这个宏，就会发现这个值不是我们想的那样，实际上的值是11，这是为什么呢？我们不妨来看看他是怎么替换的

# define fun(x+1) (x+1 * x + 1)

这就是他替换的过程，是原封不动的把x 替换成x+1，按照优先级来计算的结果就是11，怎么才能解决这个问题呢，很简单，打上括号就行了.

# define fun(x+1) ((x) + (x))

这样就保证了运算的顺序，实现了我们想要的结果

所以说说在写宏函数的时候，我们应该细心一点，用括号把运算优先级给弄清楚，防止出现像这种情况，防止出现歧义或者一些不可预料的情况

同时我们也要注意像前置++和后置++在宏函数中的使用

y+1;//不带副作用y还是原来的值
y++;//带有副作用,y在使用之后自增1

这种是非常危险的，假如我们在比较x和y两个数谁大的时候如果在代码中使用了前置++和后置++就会产生歧义，像这样

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
x = 5;
y = 8;
z = MAX(x++, y++);
printf("x=%d y=%d z=%d\n", x, y, z);

这里通过预处理得到

z = ( (x++) > (y++) ? (x++) : (y++))

首先x是5，y是8，先是5和8比较大小，完了之后x变成6y变成9,9比6大返回y的值，然后y自增变成10，最后打印的结果是z = 9,x = 6,y = 10

宏替换的规则

宏替换的规则
在程序中扩展#define定义符号和宏时，需要涉及⼏个步骤。

1. 在调⽤宏时，⾸先对参数进⾏检查，看看是否包含任何由#define定义的符号。如果是，它们⾸先
   被替换。
2. 替换⽂本随后被插⼊到程序中原来⽂本的位置。对于宏，参数名被他们的值所替换。
3. 最后，再次对结果⽂件进⾏扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上
   述处理过程。
   注意：
4. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
5. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

宏函数和函数的对比

和函数相⽐宏的劣势：

1. 每次使⽤宏的时候，⼀份宏定义的代码将插⼊到程序中。除⾮宏⽐较短，否则可能⼤幅度增加程序
   的⻓度。
2. 宏是没法调试的。
3. 宏由于类型⽆关，也就不够严谨。
4. 宏可能会带来运算符优先级的问题，导致程容易出现错。
   宏有时候可以做函数做不到的事情。⽐如：宏的参数可以出现类型，但是函数做不到。
   和函数相⽐宏的优势：
   宏通常被应⽤于执⾏简单的运算。
   ⽐如在两个数中找出较⼤的⼀个时，写成下⾯的宏，更有优势⼀些。

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

那为什么不⽤函数来完成这个任务？ 原因有⼆：

1. ⽤于调⽤函数和从函数返回的代码可能⽐实际执⾏这个⼩型计算⼯作所需要的时间更多。所以宏⽐ 函数在程序的规模和速度⽅⾯更胜⼀筹。
2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使⽤。反之 这个宏怎可以适⽤于整形、⻓整型、浮点型等可以⽤于 > 来⽐较的类型。宏的参数是类型⽆关的。

我们看看下面代码，我们如果想要开辟一个float，或者int类型的动态内存，一般是这样写的

int*ptr = (int*)malloc(n*sizeof(int));
float*ptr = (float*)malloc(n*sizeof(float));

这样就比较麻烦，那有什么办法把他能不能写成一个函数呢直接传类型和想要的大小就可以了?
这里就可以用到宏函数了，他的参数就可以是类型，但函数不得行。

#include <stdio.h>
#include<stdlib.h>
# define MALLOC(number,type) (type*)malloc(number*(sizeof(type)))
int main()
{
    
	int* ptr = MALLOC(5, int);//替换之后变成int *ptr = (int*)malloc(5*sizeof(int));
	for (int i = 0; i < 5; i++)
	{
    
		ptr[i] = i;
	}
	for (int i = 0; i < 5; i++)
	{
    
		printf("%d ", ptr[i]);
	}
	return 0;
}

这样就会显得比较方便，也实现了我们想要的功能。

#和##

#运算符
#运算符将宏的⼀个参数转换为字符串字⾯量。它仅允许出现在带参数的宏的替换列表中。
#运算符所执⾏的操作可以理解为”字符串化“。
这段话有点抽象，我们可以写一个代码来感受一下

# define  PRINT(a) printf("the value of "#a " is %d", a);
int main()
{
    
	int a = 5;
	PRINT(a);
	return 0;
}

通俗来说就是就是把a这个字符原封不动的搬过去而不是a所代表的值
PRINT(a);//当我们把a替换到宏的体内时，就出现了#a，⽽#a就是转换为"a"，时⼀个字符串
代码就会被预处理为：

printf("the value of ""a" " is %d", a);

##运算符

可以把位于它两边的符号合成⼀个符号，它允许宏定义从分离的⽂本⽚段创建标识符。 ## 被称为记号粘合这样的连接必须产⽣⼀个合法的标识符。否则其结果就是未定义的。

这⾥我们想想，写⼀个函数求2个数的较⼤值的时候，不同的数据类型就得写不同的函数。

int int_max(int x, int y)
{
    
 return x>y?x:y;
 }
 float float_max(float x, float y)
 {
    
  return x>y?x:y;
  }

这样就会比较复杂，我们可以写一个宏函数看看

#define COMPARE(type)    \
		type type##_max(type x, type y) \
		{
         \
			return x>y?x:y;\
		}
//定义函数
COMPARE(int);//int_max
COMPARE(float);//float_max
int main()
{
    
	int r1 = int_max(3, 10);
	printf("%d\n", r1);

	float r2 = float_max(3.12f, 16.5f);
	printf("%.2f\n", r2);

	return 0;
}

#undef

这是一个移除宏定义的指令

# define MAX 5
int main()
{
    
 #undef MAX	
	int a = MAX;
	printf("%d", a);
	return 0;
}

条件编译

在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃是很⽅便的。因为我们有条
件编译指令。如果我们有些代码不要了，删了的话又不值得，这时候就可以用条件编译

# define DEBUG
int main()
{
    
	int a = 9;
#ifdef DEBUG
	printf("%d", a);
#endif
	return 0;
}

这里我们就用到了条件编译，首先定义了一个debug 来判断a有没有成功打印 下面用了一个#ifdef DEBUG 这里表示如果定义了DEBUG就执行下面的语句**#endif和#ifdef连用**
常见的条件编译，用法有点类似于if else 语句

#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

头文件的包含

本地文件的包含

# include"test.h"

这种写法一般是我们自己写的头文件，在编译器中有一种查找策略
查找策略：先在源⽂件所在⽬录下查找，如果该头⽂件未找到，编译器就像查找库函数头⽂件⼀样在
标准位置查找头⽂件。
如果找不到就提⽰编译错误。
库文件的包含
这个就是C语言标准库里面的文件

查找头⽂件直接去标准路径下去查找，如果找不到就提⽰编译错误。

我们想一想如果标准库的头文件像我们自己写的头文件的方式去写可行吗？答案是可行的

# include"stdio,h"

但这种方式查找效率会底低下当然这样也不容易区分是库⽂件还是本地⽂件了。

嵌套文件包含

我们已经知道， #include 指令可以使另外⼀个⽂件被编译。就像它实际出现于 #include 指令的
地⽅⼀样。
这种替换的⽅式很简单：预处理器先删除这条指令，并⽤包含⽂件的内容替换。
⼀个头⽂件被包含10次，那就实际被编译10次，如果重复包含，对编译的压⼒就⽐较⼤。
那怎么防止这种情况出现，我们可以用这个命令

#pragma once

或者

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

这样就不会重复调用头文件了
完。
如果有什么错误欢迎指正！