详细介绍预处理#define和编译链接等有关知识

程序环境和预处理

程序环境

在ANSI C的任何一种实现中，存在两个不同的环境

• 第一种是翻译环境，在这个环境中源代码被转换为可执行的机器指令（即二进制指令）
• 第二种是执行环境，它用于实际执行代码

当一个源文件输出结果时，会经过如图的过程：

翻译环境

翻译=编译（预编译+编译）+汇编+链接

编译需要在编译器上完成，链接需要在链接器上完成

这里简单介绍一下VS2019

VS2019是一个集成开发环境（IDE），其包含编辑+编译+链接+调试，四大功能

编辑则需要编辑器

编译则需要编译器 VS2019中的编译器为cl.exe

链接则需要链接器 VS2019中的链接器为link.exe

调试则需要调试器

VS2019就是将这些器们都放在一起，即为IDE

翻译的大致过程如图：

• 组成一个程序的每个源文件通过编译过程分别转换成目标代码
• 每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序
• 链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接到程序中，即图中的链接库

介绍翻译各阶段的工作

预编译阶段

预编译的操作对象是源文件（即.c文件），是将源文件中，

1. 所用的头文件进行包含
2. 注释的删除
3. #define定义的符号的替换

预编译阶段完成的操作被称为文本操作，尽管进行了这些操作，但预编译阶段的代码仍然是C语言代码

编译阶段

把C语言代码转换成了汇编代码，转换过程中做了这些事情：语法分析、词法分析、语义分析、符号汇总

这里重点说一下符号汇总。编译器会在编译阶段将所有源文件的全局符号给汇总起来（包括：全局变量名、全局函数名、main等）

汇编阶段

1. 把汇编代码转换成二进制代码
2. 形成符号表

在这一阶段会生成图中的目标文件

在windows系统下，生成后缀为.obj的文件；在Linux系统下，生成后缀为.o的文件

链接阶段：

将所有的目标文件链接在一起，在这个过程中会：

1. 合并段表

2. 符号表的合并和重定位

比如我在add.c的文件中定义了一个函数Add，在test.c中外部声明了这个函数。

在汇编阶段，add.c的文件会生成一个符号表（符号表中有Add及其地址），test.c也会生成一个符号表（符号表中有Add和main及其地址）

在链接阶段会将这两个符号表合并和重定位（所谓重定位就是将重复的符号去掉，留下有有效地址的符号）

此外，链接阶段也可以发现被调用的函数未定义

运行环境

程序执行的过程：

1. 程序必须载入内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成
2. 程序的执行便开始。接着便调用main函数
3. 开始执行程序代码。这个时候程序将使用一个运行时堆栈（stack），存储函数的局部变量和返回地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程一直保留他们的值

这里所提到的运行时堆栈即为函数栈帧

4. 终止程序。正常终止main函数；也有可能是意外终止

预处理

预定义符号

以下的这些预定义符号都是语言内置的

__FILE__ //进行编译的源文件
__LINE__ //文件当前的行号
__DATE__ //文件被编译的日期
__TIME__ //文件被编译的时间
__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义

注意这里是 下划线下划线+名称+下划线下划线

前四个符号可以正常使用

注意：其中 __TIME__和__DATE__是代码被编译时的时间和日期，所以一旦程序运行一次后，是不会再改变的

而__STDC__在VS中无法使用，说明VS的编译器并不是完全遵循ANSI C标准的

#define

#define定义标识符

样例

例如：#define MAX 100

假设现在有这样的代码：

#include<stdio.h>
#define MAX 100

int main()
{
  int a=MAX;
  return 0;
}

这是源文件，而在预编译阶段则会将#define定义的符号进行替换，所以预编译时的代码为：

#include<stdio.h>

int main()
{
  int a=100;
  return 0;
}

注意点

注意：在#define语句的最后最好不要加上分号

否则容易出现以下的错误：

#define MAX 1000;

if(condition)
  max = MAX;
else
  max = 0;

此时代码运行就会出错

我们到预编译阶段就会发现错误：

if(condition)
  max = 1000;;
else
  max = 0;

程序报错，我们发现第二行后面有两个“；”，这个代码的意思就变成了if语句下有两句代码：一个是max=1000;，另一个是;即空语句。而在没有加“{}”的情况下，写两句代码显然是错误的

因此，为了防止这样的错误，建议#define语句的最后不要写分号

#define定义宏

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

样例

例如：#define MAX(x,y) (x>y?x:y)

假设有这样一段代码：

#include<stdio.h>
#define MAX(x,y) (x>y?x:y)

int main()
{
    int a=10;
    int b=20;
    int m=MAX(a,b);
    return 0;
}

而在预编译阶段，代码则变为：

#include<stdio.h>

int main()
{
    int a=10;
    int b=20;
    int m=(a>b?a:b);
    return 0;
}

这里就体现了将参数替换到文本中，将x换成a，y换成b

注意点

在定义的宏时候，括号尽量写足，以此来减少因为符号优先级而导致计算顺序发生变化

所以#define MAX(x,y) (x>y?x:y)其实最好写成``#define MAX(x,y) ((x)>(y)?(x):(y))`，这才是最好的写法

#define的替换规则

• 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归

即可以出现如下情况：

#define M 10
#define N 10+M

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

#define M 10

printf("hello M");

那么这里的M是不会被搜索的，也就不会被替换

#和##的作用

首先我们先看这两个代码：

printf("hello world\n");
printf("hello"" world\n");

事实上，这两个语句输出的都是hello world

也就是说，字符串是有自动连接的特点的

#的作用

#可以把一个宏参数变成对应的字符串

我用这样的一个例子来深入理解一下：

int main()
{
    int a=10;
    printf("the value of a is %d\n", a);
    
    float b=2.5;
    printf("the value of b is %lf\n", b);
    
    return 0;
}

当我想要打印这两个语句时，发现这两句代码有许多是重复的，不同的只有名字和打印格式。所以为了简便，我们很自然的想到将这个封装成一个函数，但遗憾的是，我们无法将要打印的格式进行传参，这时候就只能依靠#define定义宏来完成这件事了

所以借助宏，上面代码将变为：

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

int main()
{
    int a=10;
    PRINT(a,"%d");
    
    float b=2.5;
    PRINT(b,"lf");
    
    return 0;
}

由于#的作用，所以a就变成了“a”

注意：format传过去时本身就是一个字符串

在预编译阶段下，代码如下：

int main()
{
    int a=10;
    printf("the value of a is %d\n",a);
    
    float b=2.5;
    printf("the value of b is %lf\n",b);
}

##的作用

##可以把位于它两边的符号合成一个符号，它允许宏定义从分离的文本片段创建标识符

我们通过下面的例子理解一下：

#define CAT(A,B) A##B

int main()
{
    int Class107=100;
    printf("%d\n",CAT(Class,107));
    
    return 0;
}

输出结果：100

就是说##，将其两边的标识符合并为另一个标识符

注意：这样的连接必须产生一个合法的标识符。否则其结果就是未定义的

##几乎用不到

带副作用的宏参数

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

例如：

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

MAX宏可以证明具有副作用的参数所引起的问题

#define MAX(x, y) ( (x) > (y) ? (x) : (y) )

int main()
{
    int a=3;
    int b=4;
    int m=MAX(++a,++b);
    
    printf("m=%d a=%d b=%d\n",m,a,b);
    return 0;
}

输出结果：6 4 6

这里就是如开头所说，带副作用的宏参数引起的问题

宏和函数对比

宏的优点

宏常用于执行简单运算

比如，要找出两个数中的较大数\#define MAX(a, b) ((a)>(b)?(a):(b))

为什么不用函数呢？其因有二：

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多，所以宏比函数在程序的规模和速度方面更胜一筹

使用宏要保证计算的过程足够简单，所用的时间足够短

假设计算很复杂。花费时间很长的话，那么函数的调用和返回所花费的时间相比于计算来说就不值一提了，这时候就是函数更好了

2. 更为重要的是函数的参数必须声明为特定的类型，而宏是类型无关的

   所以函数只能在类型合适的表达式上使用，反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型

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

#define   MALLOC(num, type)   (type *)malloc(num * sizeof(type))

//使用
MALLOC(10, int);//类型作为参数

//预处理器替换之后：
(int *)malloc(10 * sizeof(int));

宏的缺点

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

宏和函数的对比（图）

这里说一下带有副作用的参数这一点：

test(2+3);//函数的参数是在传参之前求值
TEST(2+3);//宏的参数在传参之前不求值，是整体替换过去

命名约定

由于宏和函数的语法是很相似的，所以语言本身没法帮我们区分二者

所以我们从命名上来帮助区分，我们约定：

把宏名全部大写

函数名不要全部大写

#undef

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

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

命令行定义

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

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

条件编译

所谓条件编译，即满足条件则参与编译，不满足条件则不参与编译

条件编译和条件选择语句的区别在于，条件编译的代码如果条件不成立，则会在预处理阶段就将条件不成立的代码直接删掉了

注意，条件编译语句都是写在函数内的

基本的条件编译语句

#if 常量表达式
 //...
#endif
//常量表达式由预处理器求值

如：
#define __DEBUG__ 1
#if __DEBUG__
 //..
#endif

多分支的条件编译语句

#if 常量表达式
 //...
#elif 常量表达式
 //...
#else
 //...
#endif

判断是否被定义

这里有两种写法，关键看有无！

若无！，则定义了就符合条件；若有！，则没定义就符合条件

情形一：没有!

#define MAX 0

//写法一
#if define(MAX)
	printf("haha\n");
#endif

//写法二
#ifdef MAX
	printf("haha\n");
#endif

这个就是如果定义了MAX，则打印haha，否则不打印

这两个写法是完全等价的

情形二：有！

#define MAX 0

//写法一
#if !define(MAX)
	printf("haha\n");
#endif

//写法二
#ifndef MAX
	printf("haha\n");
#endif

这个就是如果没定义了MAX，则打印haha，否则不打印

这两个写法也是完全等价的

嵌套指令

这就和if语句的嵌套一样的

其实这些预处理指令用途十分广泛，比如：

#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

这个条件编译的意思是：如果是UNIX系统则走上面的代码，如果是MSDOS系统则走下面的代码

文件包含

头文件被包含的方式

库文件包含

#include <filename.h>

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

本地文件包含

#include "filename"

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

嵌套文件包含

问题

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

这种替换的方式很简单：预处理器先删除这条指令，并用包含文件的内容替换。如果这样一个源文件被包含10次，那就实际被编译10次，这就会造成代码冗余

例如图示情况：

解决方法

方法：条件编译

方法一：

每个头文件开头写：

#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif   //__TEST__

第一次包含时，__TEST__肯定是未定义的，所以符合条件并定义__TEST__同时拷贝头文件的内容

后面再包含时，由于__TEST__已经定义过了，所以条件编译不再成立

方法二：

每个头文件开头写：

#pragma once

#pragma也是一个预处理指令