C语言进阶之程序环境和预处理

1. 程序的翻译环境和执行环境

在ANSI C的任何一种实现中，存在两个不同的环境。
第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。
第2种是执行环境，它用于实际执行代码。

翻译程序是一种系统程序，它将计算机编程语言编写的程序翻译成另外一种计算机语言的一般来说等价的程序，主要包括编译程序和解释程序，汇编程序也被认为是翻译程序。

翻译是先用转换程序将高一机器上的程序整体的转换成在低一级机器上可运行的等效程序，然后再在低一级机器上实现的技术。

解释是在低一级机器上用他的一串语句或指令来仿真高一级机器上的一条语句或指令的功能，通过对高一级程序中的每条语句或指令逐条解释来实现的技术。

程序的最初形式称为源程序或者源代码，翻译后的形式被称为目标程序或者目标代码。

大多数翻译程序是将高级语言编写的程序翻译为机器语言形式的可执行程序。但是也有些翻译程序将源程序翻译成其他高级语言或者字节码等中间形式。

2. 详解编译+链接

2.1 翻译环境

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

2.2 编译的几个阶段

在Linux环境下我们可以很好的观察这几个阶段

①预处理(进行宏替换)
预处理功能主要包括宏定义,文件包含,条件编译,去注释等。
预处理指令是以#号开头的代码行。
实例: gcc -E test.c -o test.i
选项“-E”,该选项的作用是让 gcc 在预处理结束后停止编译过程。
选项“-o”是指目标文件,“.i”文件为已经过预处理的C原始程序。
test.c文件

我们可以看到编译后总共有851行，其中包括了头文件的展开复制， 替换了宏定义,直接输出条件编译。

②编译（生成汇编）
在这个阶段中,gcc 首先要检查代码的规范性、是否有语法错误等,以确定代码的实际要做的工作,在检查
无误后,gcc 把代码翻译成汇编语言。
用户可以使用“-S”选项来进行查看,该选项只进行编译而不进行汇编,生成汇编代码。
实例: gcc -S test.i -o test.s

③汇编（生成机器可识别代码）
汇编阶段是把编译阶段生成的“.s”文件转成目标文件
读者在此可使用选项“-c”就可看到汇编代码已转化为“.o”的二进制目标代码了
实例: gcc -c test.s -o test.o


二进制查看工具od test.o

④链接（生成可执行文件或库文件）
在成功编译之后,就进入了链接阶段。
实例: gcc test.o -o test

编译四个阶段总结
预处理（Preprocessing）：
预处理是编译过程的第一步。在这个阶段，预处理器会处理源代码中的预处理指令，例如宏定义、条件编译指令和包含其他文件的指令。预处理器会根据这些指令对源代码进行修改或扩展，生成一个被称为预处理后的源代码文件。预处理后的文件通常具有更大的体积，并且已经包含了其他文件的内容。

编译（Compilation）：
编译阶段是将预处理后的源代码转换为汇编代码的过程。编译器会对预处理后的源代码进行词法分析、语法分析和语义分析，并生成相应的中间表示，例如抽象语法树（AST）。接下来，编译器会根据中间表示生成与目标平台相关的汇编代码。这些汇编代码是与机器指令相关的低级表示，但仍然是相对可读的。

编译又通常包括四个主要阶段：词法分析、语法分析、语义分析和代码生成

词法分析（Lexical Analysis）：
在词法分析阶段，编译器会读取源代码并将其分解为一个个的词法单元，例如标识符、关键字、运算符和常量。这些词法单元将被用作后续阶段的输入。词法分析器会忽略空格和注释，并根据预定义的词法规则生成词法单元流。

语法分析（Syntax Analysis）：
在语法分析阶段，编译器使用词法分析阶段生成的词法单元流构建出源代码的语法结构。它会根据语法规则检查词法单元流的有效性，并生成抽象语法树（Abstract Syntax Tree，AST）作为中间表示。语法分析器通常使用上下文无关文法和解析算法（如LL（1）或LR（1））来完成这个阶段。

语义分析（Semantic Analysis）：
在语义分析阶段，编译器会对语法分析阶段生成的抽象语法树进行进一步的分析，以验证源代码的语义正确性。这包括类型检查、作用域分析、符号表的构建等任务。编译器会根据语言的语义规则检查变量的声明和使用是否正确，函数的调用是否匹配等。如果发现语义错误，编译器会生成相应的错误信息。

代码生成（Code Generation）：
在代码生成阶段，编译器将经过语义分析的抽象语法树转换为目标机器代码或者其他形式的可执行代码。这个阶段包括分配寄存器、指令选择、优化等步骤。编译器会生成与目标平台相关的代码，并进行一系列的优化以提高生成代码的效率和性能。

汇编（Assembly）：
汇编阶段是将汇编代码转换为机器代码的过程。汇编器会读取编译器生成的汇编代码，并将其转换为与目标处理器或计算机体系结构相关的机器代码。在这个阶段，符号和地址引用也会被解析和修正。汇编生成的机器代码是二进制形式的，直接可供计算机执行。

链接（Linking）：
链接阶段是将多个目标文件和库文件组合成一个可执行文件或库文件的过程。在编译过程中，源代码可能会被拆分为多个编译单元，每个编译单元生成一个目标文件。链接器会将这些目标文件及其依赖的库文件合并在一起，并解决符号引用和地址重定位等问题。最终，链接器会生成可执行文件或库文件，其中包含了完整的可执行代码和数据。

这四个阶段一般按顺序执行，每个阶段的输出作为下一个阶段的输入。它们共同完成了将源代码转换为可执行代码的过程。不同的编译器和构建系统可能会有不同的实现和工具，但这些阶段的基本原理在大多数编译过程中都是适用的。

2.3 运行环境

程序执行的过程：

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

3. 预处理详解

3.1 预定义符号

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

举个例子：

 #include <stdio.h>

 int main()
 {
    
    
 	printf("%s\n", __FILE__);
 	printf("%d\n", __LINE__);
 	printf("%s\n", __DATE__);
 	printf("%s\n", __TIME__);

 	return 0;
 }

因为__STDC__在vs编译器未遵循ANSI C，未定义，遂不做演示。

3.2 #define

3.2.1 #define 定义标识符

#define 是C和C++语言中的预处理指令，用于定义标识符（常量、宏等）。它允许你为一个标识符赋予一个特定的值或字符串，并在源代码中使用该标识符来代替其值。

使用 #define 的语法如下：

#define 标识符 值

其中，标识符 是你希望定义的名称，而 值 是你希望为该标识符赋予的值或字符串。

一旦使用 #define 定义了一个标识符，编译器会在预处理阶段将所有出现该标识符的地方替换为相应的值。这个过程被称为宏展开。

以下是一些示例：

#define PI 3.14159
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MESSAGE "Hello, World!"

double radius = 5.0;
double circumference = 2 * PI * radius;

int max_value = MAX(10, 20);

printf("%s\n", MESSAGE);

在上面的示例中，#define PI 3.14159 定义了一个常量 PI，#define MAX(a, b) ((a) > (b) ? (a) : (b)) 定义了一个带参数的宏 MAX，#define MESSAGE “Hello, World!” 定义了一个字符串常量 MESSAGE。

在编译过程中，预处理器会将所有出现的 PI 替换为 3.14159，MAX(10, 20) 替换为 (10) > (20) ? (10) : (20)，MESSAGE 替换为 “Hello, World!”。

这样，circumference 的计算将变为 2 * 3.14159 * radius，max_value 的赋值将变为 int max_value = (10) > (20) ? (10) : (20)，printf(“%s\n”, MESSAGE) 将变为 printf(“%s\n”, “Hello, World!”)。

通过 #define 定义标识符，可以在源代码中使用更简洁和易于理解的方式来表达常量、宏和字符串，提高了代码的可读性和可维护性。

还有以下例子：

#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 MAX 1000;
#define MAX 1000

建议不要加上 ; ,这样容易导致问题。
比如下面的场景：

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

3.2.2 #define 定义宏

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

下面是宏的申明方式：
#define name( parament-list ) stuff
其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。

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

#define SQUARE( x ) x * x

这个宏接收一个参数x .
如果在上述声明之后，你把SQUARE( 5 );置于程序中，预处理器就会用下面这个表达式替换前面的表达式5 * 5

警告：
这个宏存在一个问题;

观察下面的代码段：

int a = 5;
printf("%d\n" ,SQUARE( a + 1) );

乍一看，你可能觉得这段代码将打印36这个值。
事实上，它将打印11.
为什么？

替换文本时，参数x被替换成a + 1,所以这条语句实际上变成了：
printf (“%d\n”,a + 1 * a + 1 );

这样就比较清晰了，由替换产生的表达式并没有按照预想的次序进行求值。
在宏定义上加上两个括号，这个问题便轻松的解决了：

#define SQUARE(x) (x) * (x)

这样预处理之后就产生了预期的效果：

printf ("%d\n",(a + 1) * (a + 1) );

这里还有一个宏定义：

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

定义中我们使用了括号，想避免之前的问题，但是这个宏可能会出现新的错误。

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

这将打印什么值呢？

注意：
看上去，好像打印100，但事实上打印的是55.
我们发现替换之后

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

乘法运算先于宏定义的加法，所以出现了55这个问题，的解决办法是在宏定义表达式两边加上一对括号就可以了。

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

提示：

所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。

3.2.3 #define 替换规则

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

1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。
2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

注意：

1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

3.2.4 #和##

如何把参数插入到字符串中？
首先我们看看这样的代码：

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

这里输出的是不是hello bit ？答案是确定的：是。
我们发现字符串是有自动连接的特点的，那我们是不是可以写这样的代码？

#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);//产生了什么效果？

代码中的 #VALUE 会预处理器处理为："VALUE"
最终的输出的结果应该是：

the value of i+3 is 13

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

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

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

3.2.5 带副作用的宏参数

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

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

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

#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

3.2.6 宏和函数对比

宏通常被应用于执行简单的运算。
比如在两个数中找出较大的一个。

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

那为什么不用函数来完成这个任务？
原因有二：

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。
   所以宏比函数在程序的规模和速度方面更胜一筹。
2. 更为重要的是函数的参数必须声明为特定的类型。
   所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。
   宏是类型无关的。

宏的缺点：当然和函数相比宏也有劣势的地方：

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

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

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

宏和函数的对比

属性	#define定义宏	函数
代码长度	每次使用时，宏代码都会被插入到程序中。除了非常小的宏之外，程序的长度会大幅度增长	函数代码只出现于一个地方；每次使用这个函数时，都调用那个地方的同一份代码
执行速度	更快	存在函数的调用和返回的额外开销，所以相对慢一些
操作符优先级	宏参数的求值是在所有周围表达式的上下文环境里，除非加上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多些括号。	函数参数只在函数调用的时候求值一次，它的结果值传递给函数。表达式的求值结果更容易预测。
带有副作用的参数	参数可能被替换到宏体中的多个位置，所以带有副作用的参数求值可能会产生不可预料的结果。	函数参数只在传参的时候求一次，结果更容易控制。
参数类型	宏的参数与类型无关，只要对参数的操作是合法的，它就可以使用于任何参数类型。	函数的参数是与类型有关的，如果参数的类型不同，就需要不同的函数，即使他们执行的任务是相同的。
调试	宏是不方便调试的	函数是可以逐语句调试的
递归	宏是不能递归的	函数是可以递归的

3.2.7 命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。
那我们平时的一个习惯是：
把宏名全部大写
函数名不要全部大写

3.3 #undef

#undef 是C和C++语言中的预处理指令，用于取消（或撤销）之前使用 #define 定义的标识符。当你使用 #undef 取消一个标识符后，该标识符将不再具有任何定义，即在后续代码中使用该标识符将不会有任何替换或展开。

#undef 的语法如下：

#undef 标识符

其中，标识符 是你希望取消定义的名称。

以下是一个示例：

#define PI 3.14159

double radius = 5.0;
double circumference = 2 * PI * radius;

#undef PI

double area = PI * radius * radius;  // 在取消定义后使用PI，将不会有任何替换或展开

在上面的示例中，首先使用 #define PI 3.14159 定义了一个常量 PI。然后，通过 2 * PI * radius 计算了 circumference。接着使用 #undef PI 取消了 PI 的定义。最后，在取消定义后尝试使用 PI 来计算 area，但由于 PI 已经被取消定义，所以在这里 PI 将不会被替换，而直接保留为字符串 “PI”。

使用 #undef 可以在需要的时候取消已定义的标识符，以避免其继续影响后续代码的展开或替换。这对于在特定代码段中重新定义标识符或避免冲突非常有用。

3.4 命令行定义

许多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 ARRAY_SIZE=10 programe.c

3.5 条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令。
比如说：
调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

#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;
}

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

3.6 文件包含

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

预处理器先删除这条指令，并用包含文件的内容替换。
这样一个源文件被包含10次，那就实际被编译10次。

3.6.1 头文件被包含的方式：

本地文件包含#include "filename"

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

Linux环境的标准头文件的路径：/usr/include

VS2022环境的标准头文件的路径：C:\...\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.35.32215\include

注意按照自己的安装路径去找。

库文件包含#include <filename.h>

查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。
这样是不是可以说，对于库文件也可以使用 “” 的形式包含？
答案是肯定的，可以。
但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。

3.6.2 嵌套文件包含

comm.h和comm.c是公共模块。
test1.h和test1.c使用了公共模块。
test2.h和test2.c使用了公共模块。
test.h和test.c使用了test1模块和test2模块。
这样最终程序中就会出现两份comm.h的内容。这样就造成了文件内容的重复。

那么如何解决这个问题？
答案：条件编译。
每个头文件的开头写：

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

或者：

#pragma once

就可以避免头文件的重复引入。

4. 预处理指令总结和扩展

C语言中的预处理指令主要用于在编译之前对源代码进行预处理操作，例如条件编译、宏定义、文件包含等。下面详细解释每个预处理指令的作用和用法：

1. #define：
   用于定义标识符（常量、宏等）。可以使用 #define 来为一个标识符赋予一个特定的值或字符串，并在源代码中使用该标识符来代替其值。

2. #include：
   用于将指定的文件内容包含到当前文件中。可以使用 #include 来包含头文件，以便在当前文件中使用被包含文件中的声明和定义。

3. #ifdef、#ifndef、#else 和 #endif：
   用于条件编译，根据条件选择性地包含或排除代码块。#ifdef 和 #ifndef 分别检查标识符是否已经定义或未定义，#else 用于提供另一个条件分支，#endif 表示条件编译的结束。

4. #if、#elif 和 #endif：
   用于更复杂的条件编译，可以进行多个条件的嵌套判断。#if 用于开始条件判断，#elif 用于提供另一个条件分支，#endif 表示条件编译的结束。

5. #error：
   用于产生一个编译错误，并显示指定的错误信息。可以使用 #error 在预处理过程中生成错误消息，以便中止编译并显示自定义的错误信息。

6. #pragma：
   用于向编译器发出特定的指示或控制命令。#pragma 可以用于设置编译器的选项、控制警告和优化等。

7. #undef：
   用于取消之前使用 #define 定义的标识符。通过 #undef 取消定义的标识符将不再具有任何定义，后续代码中使用该标识符将不会有任何替换或展开。

8. #line：
   用于修改编译器生成的行号和文件名信息。可以使用 #line 修改当前的行号和文件名，对于调试和错误跟踪非常有用。

这些预处理指令在编译过程中由预处理器处理，可以对代码进行灵活的处理和配置。它们可以在编译之前修改源代码的结构和内容，以满足特定的需求和条件。使用预处理指令可以在一定程度上增加代码的可读性、可维护性和可移植性。

总结

有兴趣的小伙伴可以关注作者，如果觉得内容不错，请给个一键三连吧，蟹蟹你哟！！！
制作不易，如有不正之处敬请指出
感谢大家的来访，UU们的观看是我坚持下去的动力
在时间的催化剂下，让我们彼此都成为更优秀的人吧！！!