C语言最终讲：预处理详解

结语：这一讲是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语言深度解剖》一书进行学习