编译和链接

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

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

第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。
第2种是执行环境，它用于实际执行代码。

翻译环境

翻译环境一般需要两个工作量就是编译和链接。

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

编译

编译对于vs2022来说，是由cl.exe完成的。编译又有三个阶段，很难给大家演示出来，便只说出来了解一下即可。分为，预编译（预处理）、编译、汇编。
预处理会把test.c文件生成一个test.i文件完成了主要三个功能：

1.注释的替换，替换成大空格，在test.i文件中不会显示注释。
2.头文件的包含。把头文件变成具体的代码引入。
3.define的替换。

编译，会把test.i文件具体实现为汇编代码也就是一个test.s文件，做到了例如：

词法分析、语法分析、语义分析、符号分析。

最后汇编会把test.i文件实现为test.o（test.obj）文件，生成了符号表。

链接

链接主要就是链接目标文件和链接库生成可执行的二进制程序。
具体做到了：

符号表的生成、符号表的合并和重定位。

执行环境

程序执行的过程：

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

预处理详解

预定义符号

主要有：

FILE //进行编译的源文件
LINE //文件当前的行号
DATE //文件被编译的日期
TIME //文件被编译的时间
STDC //如果编译器遵循ANSI C，其值为1，否则未定义

用代码实现来看一下具体作用：

#include
int main()
{
	printf("进行编译的源文件：%s\n", __FILE__);
	printf("文件当前的行号：%d\n", __LINE__);
	printf("文件被编译的日期：%s\n", __DATE__);
	printf("文件被编译的时间：%s\n", __TIME__);
	return 0;
}

可以看一下和我电脑右下方的时间是一样的。

#define

这个定义标识符我们经常用到，那么提一个问题在使用完要不要加一个分号呢？
答案是不。我们来看一下为什么：

#define MAX 1000;
#define MAX 1000

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

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

这里会出现语法错误。如果使用的是第一个那么会有两个分号，第二个则是没有语法问题。

#define 定义宏

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

下面是宏的申明方式：

#define name( parament-list ) stuff

其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。

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

宏在使用的时候最好每个参数都加一个（），至于为什么我们直接上代码看原因。

#define SQE(x) x*x
int main()
{
	int a = 5;
	printf("a+1的平方是：%d", SQE(a + 1));
	return 0;
}

这样发生的原因就是因为宏只会替换过去，这个时候而因为符号优先级可能会导致意外的错误。
为了尽量避免这样的问题发生，我们可以把每个参数带上（）。

#define SQE(x) （x）*（x）
int main()
{
	int a = 5;
	printf("a+1的平方是：%d", SQE(a + 1));
	return 0;
}

这样可以一定程度的避免因为符号优先级而导致的错误。
提示：

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

#define 替换规则

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

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

注意：

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

#和##

我们先来看这样一段代码：

#define PRINT(FORMAT, VALUE) printf("the value is "FORMAT"\n", VALUE);
int main()
{
	PRINT("%d", 10);
	return 0;
}

这里只有当字符串作为宏参数的时候才可以把字符串放在字符串中。

另外一个技巧是：
使用 # ，把一个宏参数变成对应的字符串

#define PRINT(FORMAT, VALUE) printf("the value of " #VALUE "is "FORMAT "\n", VALUE);
int main()
{
	int i = 10;
	PRINT("%d", i + 3);
	return 0;
}

了解了# 之后我们来了解一下## 的作用：

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

#define ADD_TO_SUM(num, value) sum##num += value;
int main() {
    int sum5 = 0;
    ADD_TO_SUM(5, 10);
    printf("sum5: %d\n", sum5);
    return 0;
}

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

宏和函数对比

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

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

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

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

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

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

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

int main()
{
	MALLOC(10, int);//类型作为参数
	//预处理器替换之后：
	(int*)malloc(10 * sizeof(int));
	return 0;
}

宏和函数的一个对比：

命令行定义

许多C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。
例如：当我们根据同一个源文件要编译出不同的一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大写，我们需要一个数组能够大写。）

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

条件编译

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

调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

常见的条件编译指令：

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

文件包含

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

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

嵌套文件包含

如果出现这样的场景：

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

我们想要解决这个问题，也很简单：

1.每个头文件的开头写：
#ifndef TEST_H
#define TEST_H //头文件的内容
#endif //TEST_H
2.#pragma once

今天的分享就到此位置了，各位看客老爷万福金安！