C语言最终讲：预处理详解
- 1.预定义符号
- 2.#define定义常量
- 3.#define定义宏
- 4.带有副作用的宏参数
- 5.宏替换的规则
- 6.宏和函数的对比
- 6.1宏的优势
- 6.1.1\符号
- 6.2宏的劣势
- 7.#和##
- 7.1#运算符
- 7.2##运算符
- 8.命名约定
- 9.#undef
- 10.命令行定义
- 11.条件编译
- 12.头文件的包含
- 12.1本地文件包含
- 12.2库文件包含
- 12.3嵌套文件包含
- 13.其他预处理指令
结语：这一讲是C语言基础知识的最后一讲了，后续将会学习数据结构相关的知识，坚持不易，希望各位都能坚持在自己所干的事情上，我们共勉
这一讲讲的是预处理相关的内容，上一讲虽然我们已经了解了一些关于#define相关的知识，这一讲我们讲详细阐述它的作用和缺陷
1.预定义符号
C语言中有着一些预定义符号，可以直接使用，是在预处理阶段进行处理的：
__FILE__ //进⾏编译的源⽂件
__LINE__ //⽂件当前的⾏号
__DATE__ //⽂件被编译的⽇期
__TIME__ //⽂件被编译的时间
__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义
它们的使用方法为：
int main()
{
printf("%s\n", __FILE__);//打印当前文件所在的位置
printf("%d\n", __LINE__);//打印行号
printf("%s\n", __DATE__);//打印日期
printf("%s\n", __TIME__);//打印时间
//printf("%d\n", __STDC__);//err,表明VS并不完全遵循ANSI C标准
return 0;
}
运行结果如下：
2.#define定义常量
我们知道，define定义的常量是直接替换的，所以有着下面的几处用法：
#define TEST 20 //方法1，直接定义常量
#define I int//方法2：可以为关键字替换成一个更简便的名字
#define CASE break;case//方法3：这是一种很“奇葩”的用法，建议还是别用了
int main()
{
//使用起来也很方便，方法1：
int a = TEST;//直接使用即可
//方法2：
I b = 20;
printf("%d\n", b);
//方法3：
int input = 1;
scanf("%d", &input);
switch (input)
{
case 1:
CASE 2 ://这样后面就不用加break了
CASE 3 :
break;
}
return 0;
}
对于加；问题，解答如下：
#define ROW 20;//假设#define定义时加上了;
int main()
{
int a = ROW;//这是a就会被替换成int a = 20;;这是后面就会有两个;，特殊情况下会出现错误
//总结：加上;可能会出现错误，不加;肯定不会出现错误，所以还是不要加上;
return 0;
}
3.#define定义宏
定义方式：
#define name( parament-list ) stuff
name为宏名称
parament-list是由逗号隔开的符号表，可能出现在stuff中
stuff可以是一个计算方式，也可以是一个指令等等
//需要注意的是，符号表的左括号必须要和name紧密相连，否则括号里的内容也会被当成是stuff中的一部分
使用实例：
#define MUL(x) x*x//定义了一个宏，实现x的平方
int main()
{
int a = 5;
int b = MUL(a);
printf("b = %d\n", b);
//结果为25
return 0;
}
看起来使用起来很好用，但是我们也要注意符号的优先级问题，如下：
#define ADD(x) x+x
int main()
{
int a = 5;
int b = ADD(a) * ADD(a);
printf("%d\n", b);
//我们可能会误以为结果为10 * 10，这不就是100吗，但是并非如此
//b会被替换成int b = 5+ 5*5 +5，根据符号优先级问题，结果为35
return 0;
}
知道错误就要改正，所以改正方法如下：
#define ADD(x) ((x)+(x)) //在x上加一个括号，因为x为表达式，如果传入5+5，也要被括起来
//总体上再加上一个括号，是为了将它们算成一个整体
int main()
{
int a = 5;
int b = ADD(a) * ADD(a);
printf("%d\n", b);
//这样才能计算出一个整体的值，此时结果为100
return 0;
}
所以，对于宏的定义，我们不能吝惜括号
4.带有副作用的宏参数
什么是带有副作用呢，其实就是表达式求值会改变原来的参数的值，如下：
x + 1;//不带副作⽤
x++;//带有副作⽤
为了验证此写法的危害性，我们举例来说明：
#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
int main()
{
int x = 5;
int y = 8;
int z = MAX(x++, y++);
//这里会被替换成（（x++）>（y++） ？ （x++）：（y++））
//先看问号左边，后置++，先使用后++，5>8为假，所以看的是y++的值，还是先使用后++，但是要注意的是
//由于++，此时y的值已经变成了9，所以z被赋值为9，y再++，值位10
//而x只++了一次，因为第二次只对y进行了++，所以x的值为6
printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？
//所以输出的结果应该为6 10 9
return 0;
}
5.宏替换的规则
1.在调用宏时，首先看参数中是否包含由#define定义的符号，如果有，它们首先被替换：
#define R 2
#define RR R+2
//其中RR中包含了一个常量的定义R，所以R先被替换成2，再计算RR
2.替换文本随后会被插入到原来文本所在的位置
3.最后还会对文件进行扫描，看是否仍然存在#define定义的符号，如果有，继续进行上面的两个步骤
对于宏，需要注意的是，它并不能出现递归
6.宏和函数的对比
上面我们了解了宏，那么既然宏这么好用，那我们是不是就能够将宏代替为函数使用呢，肯定是不能的，下面我们来分析宏相较于函数的利与弊
6.1宏的优势
1.对于简单的任务，宏有着天然的优势：
#define MAX(a, b) ((a)>(b)?(a):(b))
1.首先，宏的参数是类型无关的，也就是说，宏参数能够接受任意类型的值，在特定条件下是很好用的
2.其次，宏在使用过程中也是一个简单的替换，函数不同，函数在使用前后会产生空间的创建和销毁，使用效率较慢
2.相较于函数，宏有着函数不能够实现的情况：
//如果我们要使用函数进行空间的开辟：
int* Mal(int a, int size)
{
//我们首先会将返回值和参数确定，也就是说，它们的类型都是固定的，用于整形开辟的函数就不能用于浮点型类型的开辟
return (int*)malloc(a * sizeof(int));
}
//但是当我们使用宏时：
#define MAL(num, type) \
(type*)malloc(num * sizeof(type))
int main()
{
//使用函数开辟空间
int* pa = Mal(10, sizeof(int));//假设我们要开辟10个整形的空间
//使用宏开辟空间
int* pb = MAL(10, int);
//1.我们可以将int直接作为参数传入
//2.此时宏的使用包含的情况更多，更好用
return 0;
}
6.1.1\符号
上面我们使用了一个\符号，我们看看这是怎么个事：
#define MAL(num, type) \
(type*)malloc(num * sizeof(type))
//这个宏定义中使用了\符号，它是一个换行符，当宏里的内容过多时，就可以在后边加上一个\符号进行换行
//但是要注意的是，\后边什么也不能有，包括空格
//可以理解为:一个\抵消了一个\n，所以后边不能跟任何东西
6.2宏的劣势
1.每次使用宏时，一份宏代码就会被插入到程序中，如果宏很长的话，会大幅增加程序的长度
2.宏在预处理阶段就被替换，不能够被调试
3.宏由于类型无关，所以也容易出现问题
4.宏可能造成运算符优先级的问题
对于宏和函数的一个对比，我们可以看图：
图不是很好，大家对付着看
7.#和##
7.1#运算符
#所实现的操作被称为“字符串化”，作用是将宏的一个参数转换成字符串变量：
#define PRINT(n) printf("The value of " #n " is %d", n);
int main()
{
int a = 10;
PRINT(a);
//此时会打印出：The value of a is 10
//预处理阶段，代码会被替换成：printf("the value of ""a" " is %d", a);
//也就是说，#n就表示"n",对于printf，多个""会被合并成一个
return 0;
}
7.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 MAX(type) \
type type##_max(type x, type y)\
{ \
return x > y ? x : y; \
}
MAX(int);//这时我们可以依靠宏来创建一个函数，函数名为int_max
int main()
{
//使用方法也比较简单：
int ret1 = int_max(2, 3);//我们直接使用创建好的函数即可
printf("%d\n", ret1);
return 0;
}
8.命名约定
在命名宏和函数时，有着一个不成文的约定：
1.把宏名全部大写
2.函数名不要全部大写
9.#undef
用于移除一个宏定义，使用方法如下：
#define A 20
int main()
{
int a = A;
printf("%d\n", a);//20
#undef A
int b = A;//err
return 0;
}
10.命令行定义
在不同的场景下，我们定义的数组长度需求可能不同，所以许多C的编译器提供了一种命令行定义的能力，允许在命令行中，也就是使用前对一些变量进行赋值
例子：
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
这里表示给ARRAY_SIZE赋值为10，然后再执行程序
11.条件编译
对于一些为了调试而使用的代码，删除了可惜，保留了又费事，所以我们可以通过条件编译来选择性编译
常见的条件编译指令：
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
总结：
1.#if和 #endif是一体的，它们两个必须同时使用
2.#if和 #elif就相当于if else
3.#if defined(symbol)表示如果定义了symbol，也可以写成：#ifdef symbol
4.#if !defined(symbol)表示如果没有定义symbol，也可以写成：#ifndef symbol
它的原理为：
//使用原理为：
//当条件为真时，保留代码
//条件为假时，删除代码
int main()
{
#if 1
printf("haha\n");//条件为真，保留代码
#elif 0
printf("hehe\n");//条件为假，删除代码
#endif
return 0;
}
//所以上面的代码在预处理之后就变成了：
int main()
{
printf("haha\n");//条件为真，保留代码
return 0;
}
12.头文件的包含
头文件有两种包含方式：本地文件包含和库文件包含，它们的包含方式是什么呢，我们来看：
12.1本地文件包含
#include "filename"
使用“”来包含
查找策略：
1.现在源文件目录下查找，也就是这个路径：
2.如果没有找到，在库函数头文件中进行查找
3.如果找不到，提示编译错误
Linux环境下标准头文件的路径：
/usr/include
VS环境下（现在VS环境下头文件的路径应该会有差异，这里只当成一个代表）：
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是VS2013的默认路径
12.2库文件包含
直接去标准路径下查找，如果没有找到就提示编译错误
那么我们就要问了，是不是库文件的包含也可以使用""呢，原理上来说可以，但是缺点也很明显：
1.效率低
2.这样就不能够分辨出哪个是包含的是标准库文件，哪个是包含本地文件
12.3嵌套文件包含
当我们使用#include包含多个头文件时，会发生什么呢：
在预处理阶段，竟然会有5个头文件被写入了.c文件中，因为头文件的包含其实就是将头文件的内容写入.c文件中，情况如下：
struct Stu
{
int id;
char name[20];
};
struct Stu
{
int id;
char name[20];
};
struct Stu
{
int id;
char name[20];
};
struct Stu
{
int id;
char name[20];
};
struct Stu
{
int id;
char name[20];
};
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
int main()
{
return 0;
}
为了避免这种情况，所以我们用到了：条件编译，方法如下:
//头文件的改进如下：
//方法1：条件编译
#ifndef __TEST_H__
#define __TEST_H__//也就是说，如果没有__TEST_H__的话，定义一个__TEST_H__，这样后续就有了__TEST_H__，就不会再包含这个头文件了
struct Stu
{
int id;
char name[20];
};
#endif
//方法2：
#pragma once
//这是一个预处理指令，用于告诉编译器该头文件之应该被包含一次，通常推荐放在头文件开头
13.其他预处理指令
#error
#pragma
#line
...
不做介绍，⾃⼰去了解
可以参考《C语言深度解剖》一书进行学习
