【C语言进阶】第七节：程序环境和预处理

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

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

第一种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。

第二种是执行环境，它用于实际执行代码。

2、详解编译+链接

2.1 翻译环境

组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）。

每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序。

链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接到程序中。

2.2 编译分为几个阶段

sum.c

int g_val = 2024;
void print(const char* str)
{
	printf("%s\n", str);
}

test.c

int main()
{
	extern void print(char* str);
	extern int g_val;
	printf("%d\n", g_val);
	print("hello world\n");
	return 0;
}

输出结果：2024  hello world

编译期间的每一步发生了什么呢？

1. 预处理阶段处理所有以 # 开头的预处理指令，如宏定义、文件包含、条件编译等。
2. 编译阶段将预处理后的 C 代码转换为汇编代码。编译器会进行语法和语义检查，生成相关的汇编指令。
3. 汇编阶段将汇编代码转换为机器代码，生成可重定位的目标文件。
4. 链接阶段将一个或多个目标文件和库文件链接在一起，生成最终的可执行文件。

看下面一个练习：

由多个源文件组成的C程序，经过编辑、预处理、编译、链接等阶段会生成最终的可执行程序。下面哪个阶段可以发现被调用的函数未定义？( )

A.预处理

B.编译

C.链接

D.执行

 答案解析：

预处理只会处理#开头的语句，编译阶段只校验语法，链接时才会去找实体，所以是链接时出错的，故选C。

每个步骤的具体操作方式：

预处理：相当于根据预处理指令组装新的C/C++程序。经过预处理，会产生一个没有头文件、宏定义、条件编译指令以及特殊符号的输出文件，这个文件的含义同原本的文件无异，只是内容上有所不同。

编译：将预处理完的文件逐一进行一系列词法分析、语法分析、语义分析及优化后，产生相应的汇编代码文件。编译是针对单个文件编译的，只校验本文件的语法是否有问题，不负责寻找实体。

链接：通过链接器将一个个目标文件（或许还会有库文件）链接在一起生成一个完整的可执行程序。 链接程序的主要工作就是将有关的目标文件彼此相连接，也就是将在一个文件中引用的符号同该符号在另外一个文件中的定义连接起来，使得所有的目标文件成为一个能够被操作系统装入执行的统一整体。在此过程中会发现被调用的函数未被定义。需要注意的是，链接阶段只会链接调用了的函数/全局变量，如果存在一个不存在实体的声明（函数声明、全局变量的外部声明），但没有被调用，依然是可以正常编译执行的。

3、预处理详解

3.1 预定义符号

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

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

例如：

printf("file:%s line:%d\n", __FILE__, __LINE__);

3.2 #define

3.2.1 #define定义标识符

#define MAX 1000
#define reg register//为register这个关键字，创建一个简短的名字

注意：

•  不要在最后加分号，容易导致问题，例如：

#define MAX 1000;

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

• 分号书写：当定义的内容较长时，可以通过反斜杠 \ 进行续行。

3.2.2 #define定义宏

定义宏包含了参数替换，可以用于创建类似于函数的行为。其语法为：

#define name(parament-list) stuff

例如： 

#define SQUARE(x) ((x) * (x))//定义一个求平方的宏

注意：

• 参数列表的左括号必须与紧邻宏名，如果存在任何空白，参数列表将被解释为 stuff 的一部分。
• 为表达式中的操作数加括号，避免在使用宏时因运算符优先级问题导致的意外行为。

3.2.3 #和##

首先我们看这段代码：

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

输出的是hello world

我们发现字符串是有自动连接的特点的。

那么我们就可以写这样的代码：

#define PRINT(FORMAT, VALUE)\
	printf("the value is "FORMAT"\n", VALUE);

int main()
{
	PRINT("%d", 10);
	return 0;
}

FORMAT 用于指定输出的格式，例如 "%d" 表示输出一个整数。

VALUE 是要打印的实际值。

输出的结果为：the value is 10

还有一个技巧就是：使用 #，把一个宏参数变成对应的字符串。

int i = 10;
#define PRINT(FORMAT, VALUE)\
	printf("the value of " #VALUE " is " FORMAT "\n", VALUE);

int main()
{
	PRINT("%d", i+3);
	return 0;
}

代码中的 #VALUE 会预处理为："VALUE"

输出结果为：the value of i+3 is 13

##可以把位于它两边的符号合成一个符号。

#define ADD_TO_SUM(num, value) sum##num += value;

int main()
{
	int sum5 = 0;
	ADD_TO_SUM(5, 10);
	printf("%d\n", sum5);
	return 0;
}

sum##num 会把 sum 和数字 num 连接在一起，形成变量名 sum5。

当调用 ADD_TO_SUM(5, 10); 时，预处理器会将其替换为：sum5 += 10;

输出结果为10。

3.2.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++);
	printf("x=%d y=%d z=%d\n", x, y, z);
	return 0;
}

预处理之后得到的结果为：z = ( (x++) > (y++) ? (x++) : (y++));

输出结果为：x=6 y=10 z=9

3.2.5 宏和函数对比

宏通常被应用于执行简单的运算。

比如在两个数中找出较大的一个。

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

宏和函数的对比：

3.2.6 命名约定

宏名全部大写

函数名不要全部大写

3.3 #undef

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

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

例如：

#define MAX 100
#undef MAX

//此时MAX已不再定义
//printf("%d\n", MAX);//这一行会导致编译错误

#define MAX 200//重新定义 MAX
int main() 
{
    printf("The value of MAX is: %d\n", MAX);//将输出200
    return 0;
}

3.4 条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令。

#define __DEBUG__

int main()
{
    int i = 0;
    int arr[10] = {0};
    for(i=0; i<10; i++)
    {
        arr[i] = i;
        #ifdef __DEBUG__
        printf("%d ", arr[i]); 
        #endif //__DEBUG__
    }
    return 0;
}

常见的条件编译指令：

1.基本条件编译
#if 常量表达式
    //...
#endif
	//常量表达式由预处理器求值。
例如：
#define __DEBUG__ 1
#if __DEBUG__
	//在__DEBUG__为真时才到这里，为0或未定义这段会跳过
#endif
    
2.多个分支的条件编译
#if 常量表达式
 	//...
#elif 常量表达式
 	//...
#else
	//...
#endif
    
3.判断是否被定义
例如：
#define FEATURE_ENABLED

int main()
{
#ifdef FEATURE_ENABLED
    printf("Feature is enabled\n");//输出
#else
    printf("Feature is not enabled\n");
#endif

#ifndef FEATURE_DISABLED
    printf("Feature is not disabled\n");//输出
#endif
    return 0;
}
    
4.嵌套指令
例如：
#define OS_UNIX
#define OPTION1

int main()
{
#if defined(OS_UNIX)
#ifdef OPTION1
    printf("option1\n");//输出
#endif
#ifdef OPTION2
    printf("option2\n");
#endif
#elif defined(OS_MSDOS)
#ifdef OPTION2
    printf("option2\n");
#endif
#endif
    return 0;
}

3.5 文件包含

3.5.1 头文件被包含的方式

• 本地文件包含

#include "filename"

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

• 本地文件包含

#include <filename>

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

3.5.2 嵌套文件包含

如何防止头文件重复包含？

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

或者：

#gragma once