C语言程序环境和预处理Pt.1 - 预处理指令|预处理操作符

电脑所能识别的语言为二进制指令，而我们所写的C语言代码是文本信息。为了能使计算机识别并执行C语言代码，就需要翻译环境，使C语言代码翻译为二进制的指令。

1.按下编译按钮的幕后 - 程序的翻译环境

从C语言源代码到计算机可识别的二进制文件，每当我们按下编译按钮时，在编译器背后究竟悄悄地发生了什么？

下图是这背后的大概流程：

从图中的各个流程具体来说，翻译环境包含以下两大各阶段，共四个步骤：

1.编译：

---

1. 预处理（Preprocessing）：在编译之前，源代码会经过预处理器处理。预处理器指令如#include和#define会在此阶段展开，及将包含头文件到目标文件和将define的符号进行替换，并且会删除注释等不必要的内容。

2. 编译（Compilation）：在编译阶段，预处理后的源代码会被编译器翻译成汇编语言。汇编语言是与特定硬件架构相关的低级代码。
   这个阶段包括语法分析，词法分析，语义分析，符号汇总。它们确保语法的正确性并对代码做出优化，提高程序运行效率。

3. 汇编（Assembly）：汇编器将汇编语言转换成机器语言，即由二进制指令组成的程序。此形成符号表，得到到目标文件。

---

2.链接：

---

1. 链接（Linking）：在链接阶段，编译器将各个目标文件中的代码和数据段合并成一个可执行文件。这就是合并段表。段表包含了关于每个段（例如代码段、数据段）的信息，如起始地址、大小等。它们在这一阶段被整合到一个统一的表格中，以确保最终生成的可执行文件正确地加载和执行各个模块的代码和数据。
   
   在解析重复符号后，编译器会将这些符号按照一定的规则合并成一个符号表。这个过程涉及到符号解析、地址重定位等操作，确保最终生成的可执行文件中每个符号都有唯一的地址。最后，编译器将合并后的符号表与其他段（如代码段、数据段等）一起生成最终的可执行文件。

---

2.预处理详解

2.1预定义符号

__FILE__      //进行编译的源文件

__LINE__     //文件当前的行号

__DATE__    //文件被编译的日期

__TIME__    //文件被编译的时间

__STDC__    //如果编译器遵循ANSI C，其值为1，否则未定义

 我们可以在代码中直接引用它们来获得一些相关信息，比如：

printf("%s", __FILE__);
printf("%d", __LINE__);

2.2 #define 定义标识符

#define 是C语言中的预处理指令。通过#define ，可以为一个标识符定义一个常量值、一个字符串或者一段代码片段等。

通过使#define，可以使程序更具可读性、可维护性，并且可以减少代码中的重复部分，提高代码的复用性,并且，还可以用于简化代码（如下面给出的例子）。但要注意，宏定义并不会进行类型检查，而且可能会引入一些副作用，因此在使用时需要谨慎。

#include<stdio.h>
#define CASE break;case

int main()
{
	int a = 1;
	switch (a) 
	{
	case 1:
	CASE 2:
	CASE 3:
	}

	return 0;
}

还要注意，#define后面不要加分号 ';' !这种行为可能会导致if else语句被截断，else找不到对应的if语句从而报错。比如:

#define X 100;

int main()
{
    int a = 1;
    if(a > 0)
    {
        a = X;
    }
    else
    {
        a = -X;
    }

    return 0;

}

 这样的代码在经过预处理替换后，得到的文本代码是：

#define X 100;

int main()
{
    int a = 1;
    if(a > 0)
    {
        a = 100;；
    }
    else
    {
        a = -100;;
    }

    return 0;

}

可以看到，a = 100 后两个分号一个作为本行代码的结束，另一个分号就只能成为if语句的结束标志了。

2.3 #define 定义宏

宏是C语言中强大的功能之一，合理运用可以使代码简化，美观。宏的参数列表几乎可以是任何C语言支持的数据类型，比如字符串，指针甚至结构体。

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

int main()
{
	int* p = MALLOC(126, int);

	free(p);

	return 0;
}

比如在这段代码中，我们定义了一个叫MALLOC的宏，它能接收数据类型type，这是函数调用绝对做不到的，这样的宏让我们可以简化一些繁琐的的代码，使代码简洁美观。

当然，宏配合一些操作符的使用还能使宏实现更强大的功能，下面展开来详细说说。

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

int main()
{
	int a = -1;
	int b = 1;
	printf("max is :%d", MAX(a, b));

	return 0;
}

这里定义了一个宏MAX，用于比较两个值的大小并返回较大的值。在程序中可以像函数一样调用MAX宏。

注意： 参数列表的左括号必须与宏名紧邻。 如果两者之间有任何空白存在，参数列表就会被解释为宏的定义的一部分；

又由于#define允许把参数替换到文本中，所以宏定义中我们都需要给参数加上括号，以处理传来的参数是一个表达式，且表达式中的运算符的优先级没有宏定义中的运算符优先级高的情况。如

#define SQUARE(x) x*x

如果我们仅传入一个整数，宏当然能正确的给出结果，可是当传入'x+2'时，运算的优先级就会发生错乱

x + 2 * x + 2

2.4 宏替换规则

在程序中扩展#define定义符号和宏时，需要涉及几个步骤。

1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。

2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值替换。

3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

PS：宏不能实现递归，字符串中的定义标识符不会被替换。

2.5 #和##  - 宏的两个专属操作符

# 用于将参数转换为字符串。当它在宏定义中使用时，它可以将宏参数转换为字符串。可以简单的理解为给参数加上一个""。

#define PRINT(n) printf("the value of "#n" is %d\n", n)
int main()
{
	int a = 10;

	PRINT(a);

	return 0;
}

在这段代码中，#n被替换为字符串n，即"n"，由于printf函数能自动将字符串连接起来，宏替换后将"n"放入printf函数中就可以正常实现打印功能了。

为了处理各种格式的正常打印，我们同样可以用宏替换来实现，例如：

#define PRINT(n, format) printf("the value of "#n" is "format"\n", n)
int main()
{
	float a = 10.3;

	PRINT(a, "%f");

	return 0;
}

---

 ## 用于连接两个参数。当它在宏定义中使用时，它可以将两个参数连接在一起。

#define symbol_cat(x,y) x##y
int main()
{
	int ab = 1;
	printf("%d", symbol_cat(a, b));

	return 0;
}

2.5 几个带副作用的宏参数

先理解什么使副作用？

就和生活中一样，比如感冒了喝了感冒灵，虽然能缓解感冒症状，但会使人产生睡意，对白天的工作学习造成影响。

C语言中的副作用也类似，就是指在实现了代码目的的同时造成了一些想要的结果，这就是副作用，下面通过一段代码来理解：

void print(int* p)
{
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", *(p++));
	}
}

int main()
{
	int num[5] = { 1,2,3,4,5 };

	print(num);

	return 0;
}

在这段代码中，在实现打印功能时，指针p发生了移动，在打印完成后，它不再指向数组的开头而是指向了数组的末尾，这不是我们想要的，我们就称这是一个副作用。 

---

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。 比如：

#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
	int a = 1;
	int b = 2;
	int c = MAX(a++, b++);
	//int c = ((a++) > (b++) ? (a++) : (b++));

	printf("a:%d b:%d c:%d", a, b, c);

	return 0;
}

在这段代码中，b自增了两次， 产生了副作用。

所以，在传宏参数时，要避免传入可能产生副作用的参数，以免引发问题。

2.6 宏与函数的对比

（1）宏通常比函数调用更快。因为宏展开是简单的文本替换，在编译时就已经完成了。而函数由于需要在运行时进行调用，包括函数入栈、返回地址保存等操作，相对而言会稍微慢一些。所以宏比函数在程序的规模和速度方面更胜一筹。

举一个例子：

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

int max(int x, int y)
{
	if (x > y)
	{
		return x;
	}
	return y;
}
int main()
{
	int a = 1;
	int b = 2;
	int c = MAX(a, b);
	int d = max(a, b);
	

	printf("a:%d b:%d c:%d d:%d", a, b, c, d);

	return 0;
}

这个例子中分别通过宏和函数来实现了求两个数的最大值。我们通过反汇编代码来观察两种方式的执行复杂度：

​​

（宏MAX的反汇编代码） 

---

 （函数max的反汇编代码） 

---

由此可以看出，函数相较于宏在执行时有更多的准备工作，包括函数入栈、返回地址保存等操作（详见函数栈帧） 

（2）宏没有类型检查，函数有类型检查： 宏在展开时只是简单的文本替换，不进行类型检查，因此可能导致一些潜在的错误。而函数在编译时会进行类型检查，可以帮助捕获一些类型错误。 

（3）宏展开可能会导致代码膨胀，而函数调用则不会： 使用宏可能会导致代码的体积增大，因为宏展开是文本替换，会将宏的内容完全复制到每个调用点。而函数调用只需要在代码中保存一份函数的定义，多次调用时只需要保存函数地址，不会增加代码的体积。

（4） 宏不能调试，而函数可以。宏名称在调试器中不会被识别，因此在调试时无法像函数调用那样单步跟踪或设置断点来查看宏的执行过程。

 3. 黑框框后面发生的事 - 程序的运行环境

1. 加载(Lading)：程序必须先载入内存中，并未程序分配内存空间。这个过程由操作系统来完成，只有在独立的环境中，程序的载入必须由手动安排。
    
2. 执行(Execution)：程序开始执行，接着便调用main函数，执行相应指令。
    
3. 运行时(Runtime)：程序将使用一个运行时栈(stack)，储存函数的局部变量和返回值。程序同时也可以使用静态(stack)内存，储存于静态内存中的变量在程序的整个执行过程中都会被保留。
    
4. 终止(Termination)：终止main函数（可能是正常结束也有可能是异常退出），系统收回分配给程序的资源。