#define MAX 1000
#define reg register ? ? ? ? ?//为 register这个关键字，创建一个简短的名字
#define do_forever for(;;) ? ? //用更形象的符号来替换一种实现
#define CASE break;case ? ? ? ?//在写case语句的时候自动把 break写上。
// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
 ? ? ? ? ? ? ? ? ? ? ? ? ?date:%s\ttime:%s\n" ,\
 ? ? ? ? ? ? ? ? ? ? ? ? ?__FILE__,__LINE__ , ? ? ? \
 ? ? ? ? ? ? ? ? ? ? ? ? ?__DATE__,__TIME__ )

//#define 定义标识符常量
#define YEAR 2022
#define MONTH 10
#define DAY 15
int main()
{
	printf("今天是%d年%d月%d号\n", YEAR, MONTH, DAY);
	return 0;
}

#define YEAR 2022;

编译器将 YEAR 认为是 2022；??运行阶段自然过不了。

2.2.2 #define 定义宏

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

SQUARE( 5 );

5 * 5

//#define 定义宏
#define MUL(x,y) x * y	//宏定义乘法，有瑕疵
int main()
{
	printf("%d\n", MUL(1 + 2, 3 + 4));
	return 0;
}

	printf("%d\n", 1 + 2 * 3 + 4);    //直接替换后的样子

这样就比较清晰了，由替换产生的表达式并没有按照预想的次序进行求值。

在宏定义上加上两个括号，这个问题便轻松的解决了：

#define MUL(x,y) ((x) * (y))	

#define DOUBLE(x) (x) + (x)

int a = 5;
printf("%d\n" ,10 * DOUBLE(a));

printf ("%d\n",10 * (5) + (5));

#define DOUBLE( x) ? ( ( x ) + ( x ) )

2.2.3、#define 替换规则

来简单总结一下 #define 的替换规则

1.当宏在进行替换时，会对其中的参数进行检查，看是否有 #define 定义的符号，如果有的话，先优先替换参数
2.替换文本会被插入到程序中原来文本的位置；对于宏，参数名被他们的值所替换
3.最后，再对结果文件进行扫描，看看是否还有 #define 定义的符号，如果有的话，就重复上述步骤。

注意：

1. 宏的参数和 #define 定义中可以出现其他 #define 定义的符号，也就是说 #define 可以嵌套使用，但要合法。对于宏，不能使用递归。

举例：

#define ADD(x,y) ((ADD(x, y)), y)	//定义宏时，不允许出现递归！

这条代码在运行时会报错： 第二个ADD未定义。

2. 当预处理器搜索 #define 定义的符号的时候，字符串常量的内容并不会被搜索。

2.2.4、# 与 ##

? 这是两个比较奇葩的预编译指令，在实际中很少用，但是真实存在的。

#

? 这个东西比较有意思，就是在宏定义中，把某个参数变成对应的字符串，再配合上?" "?号，就能? ? 插入到后面的字符串中，比如下面这个例子，实现了全数据类型的打印

char* p = "hello ""bit\n";
printf("hello"" bit\n");
printf("%s", p);

#define PRINT(FORMAT, VALUE)\
 printf("the value is "FORMAT"\n", VALUE);
...
PRINT("%d", 10);

int i = 10;
#define PRINT(FORMAT, VALUE)\
 printf("the value of " #VALUE "is "FORMAT "\n", VALUE);
...
PRINT("%d", i+3);//产生了什么效果

## 的作用

#define ADD_TO_SUM(num, value) \
 sum##num += value;
...
ADD_TO_SUM(5, 10);//作用是：给sum5增加10.

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

#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=6 y=10 z=9

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

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

#define MAX 100
#define ADD(x,y) (x + y)
int main()
{
#undef MAX	//取消定义的标识符 MAX
	printf("%d\n", MAX);
#undef ADD	//取消定义的宏 ADD
	printf("%d\n", ADD(2, 3));
	return 0;
}

3.2 命令行定义

许多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 中输入指令： gcc -D ARR_SIZE=10 test.c ? ? ? ?//假设文件为 test.c

此时程序中的数组大小就变为了10，显然命令行定义的方式能让程序更加灵活，环境适配性更强

结果： 1 2 3 4 5 6 7 8 9 10

这些都在?Linux 上看的更加清楚，这里不过多介绍。

int main()
{
#if 1 > 2
	printf("hello ");	//条件不成立，此条语句不参与编译
#endif
	printf("world\n");
	return 0;
}

注意：有?#if?就要有?#endif?，二者互为彼此存在的必要条件

3.3.2 多分支条件编译：

int main()
{
#if 1>2
	printf("1\n");
#elif 4>3
	printf("2\n");    //只有这条语句参与编译
#else
	printf("3\n");
#endif
	return 0;
}

这两个案例在 Linux 环境下更容易看出区别，这里不演示。

3.3.3 当然也还可以使用 #define __DEBUG__

#include <stdio.h>
#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 //__DEBUG__
    }
    return 0;
}

3.3.4 判断是否定义过宏

? 我们可以定义宏、取消宏，还可以判断宏是否已定义

语法：

#if defined( ) ? #endif
//这个是判断宏有没有定义过，如果定义了，就执行后续语句

#if !defined( ) ? #endif
//这个是上面的反面，逻辑取反嘛，如果没定义，就执行后续语句

下面这俩是上面判断语句的另一种写法(个人比较推荐下面的写法，不需要加 ( ) 号)

#ifdef ? #endif
//判断是否定义过，如果定义过，执行后续语句

#ifndef ? #endif
//判断是否没有定义过，如果没有定义，执行后续语句

#define ADD(x, y) ((x) + (y))
int main()
{
//判断是否定义过
#if defined(ADD)
	printf("Yes\n");    //这个宏是已经定义了的
#endif
 
//判断是否没定义
#ifndef SUB
	printf("Yes\n");    //这个宏没定义
#endif
	return 0;
}

3.3.5?嵌套指令

//#define OS_UNIX
#define OS_MSDOS
int main()
{
#if defined(OS_UNIX)
#ifdef UNIX_1
	printf("Welcome to UNIX_1\n");
#endif
#ifndef UNIX_2
#define UNIX_2
	printf("Increase UNIX_2\n");
#endif
#elif defined(OS_MSDOS)
	printf("Welcome to Windows\n");
#else
	printf("The system does not exist");
#endif
	return 0;
}

结果：?Welcom to Windows

这段代码中包含了单分支、多分支、判断定义的知识 ，可以嵌套使用，灵活强大

? 库函数头文件在包含时，一般使用 < > 引出库文件名，被< >引出的头文件，编译器会直接去标准路径下寻找，只要没写错，那一般都能找到。" " 引头文件时，虽然要查找两次，但最终也会找到标准路径下，那么能否使用 " " 引库函数头文件呢？

? 答案是不推荐，如果使用 " " 引库函数头文件的话，可以正常打开，但会拖慢运行速度，毕竟要查找两次。同时我们在使用时，就不能一眼辨别出，哪些是自定义头文件，哪些是库函数头文件了。

#include<stdio.h>	//库函数头文件的包含风格
 
#include"Add.h"	//自定义头文件的包含风格

避免多次展开同一头文件
? 头文件在被成功调用后，在预编译阶段会被展开，光是 stdio.h 这个头文件就被展开了一万多行代码，如果不做特殊处理，然后多包含几次头文件，那光是在预编译阶段就会出现很多很多行代码了，并且这些代码还是重复的，为此要对头文件做一些特殊处理，避免其被多次展开。

本章作为c语言进阶最后一个篇章，希望把这里全部看完能够有些提升，虽然本人写的不好，但大体的内容都有提到，有些地方我也有些不懂，我没有进行过深究，有很多地方不敢断言。

写的不好的地方希望大家多多包涵，错误和不足的地方仅仅代表我个人的愚见，也希望大多多指出，我会及时进行修改。