????????前言：本期我们将深度剖析一个程序究竟是如何运行起来的，在学校里关于这一部分，老师可能只会讲：源文件经过编译链接处理生成可执行文件 这样一句话代过。但实际上，里面的学问可大了，涉及不少底层的东西，同时有些专业会开“编译原理”这门课，非常容易把人“劝退”，因此本期作为C语言的一部分并不会过于深度的详解，但也远比你之前对此的了解更高更深。当你能够对这部分有所熟知时，你就能站在一个更高的视角来看待问题。
目录
1 程序的翻译环境和执行环境
在ANSI C的任何一种实现中，存在两个不同的环境：
- 翻译环境，在这个环境中源代码被转换为可执行的机器指令
- 执行环境，它用于实际执行代码
2 详解翻译＋链接
????????在我们写好代码以后，无论是在调试窗口还是在.exe文件打开都能直接观察到代码效果，现在我们就是要研究它是怎么来的。
2.1 翻译环境（test.c ->?test.exe）
- 组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）
- 每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序
- 链接器同时也会引入标准C函数库中任何被该程序所用到的函数
- 而且它可以搜索程序员个人的程序库，将其需要的函数也链接到程序中
2.2 编译的三个阶段
???????由于?Visual Studio 这些编译器是一个集成开发环境，所以不方便展示各个部分的详细内容。但是在以后学习 Linux 的过程中，我们回过头来是一定可以观察的。这里我们用文字阐述。
预编译：
????????1.完成了头文件的包含 #include? ，?例如，#include <stdio.h>这句代码会被替换成stdio.h这个头文件中的全部代码，并写入到 .i 文件当中。
????????2.#define 定义的符号和宏的替换，并将替换的文本写入到 .i 文件当中。
????????3.注释的删除。
综上：预编译产生的 .i 文件里面写的 C 语言代码，是包括头文件的所有 C 语言代码。
编译：把C语言代码转换为汇编代码，这些汇编代码存放在 .s 文件中。
????????1.词法分析： 词法分析的任务是对由字符组成的单词进行处理，从左至右逐个字符地对源程序进行扫描，产生一个个的单词符号，把作为字符串的源程序改造成为单词符号串的中间程序。
????????2.语法分析： 编译程序的语法分析器以单词符号作为输入，分析单词符号串是否形成符合语法规则的语法单位，如表达式、赋值、循环等，最后看是否构成一个符合要求的程序，按该语言使用的语法规则分析检查每条语句是否有正确的逻辑结构，程序是最终的一个语法单位。
????????3.语义分析： 语义分析是编译过程的一个逻辑阶段， 语义分析的任务是对结构上正确的源程序进行上下文有关性质的审查，进行类型审查。语义分析是审查源程序有无语义错误，为代码生成阶段收集类型信息。
????????4.符文汇总： 在这个环节中，会将每个源文件的全局范围的变量符号进行汇总.
汇编：把汇编代码转换成机器指令（二进制指令），这些指令会被放在 .obj 文件当中(Linux 环境下为 .o 文件)，在 Linux 环境下可观察这些二进制指令。
????????1.生成符号表 （一般都是全局变量）
链接：
????????1.合并段表。 其实，汇编结束后所生成的obj文件内部会被划分为几个段，在链接过程中就会把每个obj文件对应的段通过某种规则合并起来，最后形成可执行程序（.exe为后缀）。
????????2.符号表的合并和重定位。 在链接期间会将每个源文件的符号表进行合并，若不同源文件的符号表中出现了相同的符号，则取合法的地址为合并后的地址（重定位）。
注：符号表并非无意义。例如，当要调用某一函数时，编译器会在符号表中查找该符号，若有，则调用成功，否则调用失败。
? ? ? ?如果有条件，我们可以在gcc上查看编译期间的每一步都发生了什么。我们创建一个test.c的文件
#include <stdio.h> int main() { int i = 0; for(i=0; i<10; i++) { printf("%d ", i); } return 0; }1.预处理 选项 gcc -E test.c -o test.i
???预处理完成之后就停下来，预处理之后产生的结果都放在test.i文件中。头文件的包含、#define定义符、注释的删除都是在预处理阶段完成的。
2. 编译 选项 gcc -S test.c
? ? 编译完成之后就停下来，结果保存在test.s中。编译阶段将C语言代码转换成汇编代码。
3. 汇编 gcc -c test.c
? ? 汇编完成之后就停下来，结果保存在test.o中。该阶段把汇编代码转化成了二进制指令。注：Linux环境下的可执行程序也是elf格式。
提一个小问题？发现被调用的函数没有定义是在哪个阶段呢？
? ? ? ? 答案是：链接。
2.3 运行环境（执行环境）
1.程序首先载入内存中。 在有操作系统的环境中，该操作一般由操作系统来完成。在独立的环境中，程序的载入可以由手工完成，也可以通过可执行代码置入只读内存来完成。
2.程序的执行开始。 接着便调用main函数。
3.开始执行程序代码。 这个时候程序将使用一个运行时堆栈(stack)，存储函数的局部变量和返回地址。程序同时也可以使用静态(static)内存，存储于静态内存中的变量在程序的整个执行过程一直保留它们的值。关于这一块，以后有机会开个新坑讲讲函数栈帧的创建和销毁。
4.终止程序。 正常终止main函数，也可能是以外终止。
附：好书推荐：《程序员的自我修养》
3 预处理（预编译）详解
3.1 预定义符号
__FILE__ //进行编译的源文件
__LINE__ //文件当前的行号
__DATE__ //文件被编译的日期
__TIME__ //文件被编译的时间
__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义
//演示
printf("file:%s line:%d date:%s time:%s\n", __FILE__, __LINE__, __DATE__ , __TIME__);
应用场景：日志文件
3.2 #define
3.2.1 #define 定义标识符
#define MAX 100
#define register reg//为 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定义标识符实际上是一种替换，加了分号，会连同分号一同替换过去，在一些情况下容易出错。
3.2.2 #define 定义宏
#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义宏（define macro）
#define name( parament-list ) stuff //宏的声明方式其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中：
- 参数列表的左括号必须与name紧邻
- 如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分
用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用：
//错误写法：
#define SQUARE(x) x * x
printf ("%d\n",(3 + 1) * (3 + 1) ); //答案是7
//正确写法：
#define SQUARE(x) (x) * (x) //不要吝啬括号
printf ("%d\n",(3 + 1) * (3 + 1) ); //答案是16
//如果这样呢？
#define DOUBLE(x) (x) + (x)
printf("%d\n" ,10 * DOUBLE(5)); //答案是10*5+5=55
//正确写法
#define DOUBLE(x) ((x) + (x))
printf("%d\n" ,10 * DOUBLE(5)); //答案是100
3.2.3?#define 的替换规则
在程序中扩展#define定义符号和宏时，需要涉及几个步骤：
- 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换
- 替换文本随后被插入到程序中原来文本的位置
- 对于宏，参数名被他们的值所替换
- 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号
- 如果是，就重复上述处理过程
注意：
- 宏参数和#define 定义中可以出现其他#define定义的符号
- 但是对于宏，不能出现递归
- 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索
3.2.4 #和##
因为字符串是有自动连接的特点，如：
char* p = "hello ""world\n";
printf("%s", p);
printf("hello"," world\n"); 打印后为"hello world"
可以使用 # ，把一个宏参数变成对应的字符串：
int i = 10;
#define PRINT(FORMAT, VALUE)\
printf("the value of " #VALUE "is "FORMAT "\n", VALUE);
//the value of i+3 is 13
PRINT("%d", i+3);
?如果我们想实现下图这样的效果，也就是传进去一个值（X），就可以打印为the value of X is %d（%d为对应的值），依靠函数可行吗？
void print(int n)
{
printf("the value of n %d\n", n);
}
int main()
{
int a = 10;
print(a);
printf("the value of a is %d\n", a);
int b = 20;
print(b);
printf("the value of b is %d\n", b);
return 0;
}这样是不可行的，这时候宏就要登场了。
#?的作用：把一个宏参数变成对应的字符串
#define PRINT(N) printf("the value of "#N" is %d\n", N)
int main()
{
int a = 10;
PRINT(a);
int b = 20;
PRINT(b);
return 0;
}
#define PRINT(N, FORMAT) printf("the value of "#N" is "FORMAT"\n", N)
int main()
{
int a = 10;
PRINT(a, "%d");
float f = 3.14f;
PRINT(f, "%lf");
return 0;
}?
##?的作用：把位于它两边的符号合成一个符号。 它允许宏定义从分离的文本片段创建标识符。但是这样的连接必须产生一个合法的标识符。否则其结果是未定义的。
#define CAT(Class,Num) Class##Num
int main()
{
int Class106 = 100;
printf("%d\n", CAT(Class, 106));
//printf("%d\n", Class106);
return 0;
}
3.2.5?带副作用的宏参数
在介绍带副作用的宏参数之前，我们先看看带有副作用是什么意思。
int a = 10;
int b = a + 1; //无副作用
int c = a++; //有副作用（a的值也变了）int main()
{
int a = 5;
int b = 4;
int c = MAX(a++, b++);
printf("a=%d b=%d c=%d\n", a,b,c); //结果如何？
return 0;
}
分析：以上c的代码相当于：int c = ((a++) > (b++) ? (a++) : (b++));
综上：当我们使用宏的时候，应该避免传入带有副作用的宏参数。
3.2.6 宏和函数对比
宏：
#define MAX(x, y) ((x)>(y)?(x):(y))
int main()
{
int a = 0;
int b = 20;
int c = 0;
c = MAX(a, b);
return 0;
}函数：
int Max(int x, int y)
{
return x > y ? x : y;
}
int main()
{
int a = 0;
int b = 20;
int c = 0;
c = Max(a, b);
return 0;
}观察以上代码，你觉得用函数好使，还是用宏好使呢？
实际上，像这种简单的实现功能用宏肯定是更好的，原因有下：
1.用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。
?
2.更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。但是宏可以适用于整形、长整型、浮点型等可以用于来比较的类型。宏是类型无关的。
而且，宏有时候可以做到函数做不到的事情。例如，宏的参数可以出现类型，但是函数却不可以。
我们使用malloc函数开辟内存空间时，可能会觉得代码太多。
int main()
{
int* p1 = (int*)malloc(10 * sizeof(int));
if (p1 == NULL)
{
printf("p1开辟失败\n");
return 1;
}
free(p1);
p1 = NULL;
return 0;
}
这时我们可以实现一个宏，使我们用malloc开辟空间时，只用传入开辟的类型和该类型的元素个数即可。
#define MALLOC(num,type) (type*)malloc(num*sizeof(type))
int main()
{
int* p2 = MALLOC(10, int);
if (p2 == NULL)
{
printf("p2开辟失败\n");
return 1;
}
free(p2);
p2 = NULL;
return 0;
}
?当然和函数相比，宏也有劣势的地方：
- 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
- 宏是没法调试的。
- 宏由于类型无关，也就不够严谨。
- 宏可能会带来运算符优先级的问题，导致程序容易出现错。
宏和函数的具体对比：
| #define定义宏 | 函数 | |
|---|---|---|
| 代码长度 | 每次使用时，宏代码都会被插入到程序中除了非常小的宏之外，程序的长度会大幅度增长 | 函数代码只出现于一个地方；每次使用这个函数时，都调用那个地方的同一份代码 |
| 执行速度 | 更快 | 存在函数的调用和返回的额外开销，所以相对慢一些 |
| 操作符优先级 | 宏参数的求值是在所有周围表达式的上下文环境里，除非加上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多些括号 | 函数参数只在函数调用的时候求值一次，它的结果值传递给函数。表达式的求值结果更容易预测 |
| 带有副作用的参数 | 参数可能被替换到宏体中的多个位置，所以带有副作用的参数求值可能会产生不可预料的结果 | 函数参数只在传参的时候求值一次，结果更容易控制 |
| 参数类型 | 宏的参数与类型无关，只要对参数的操作是合法的，它就可以使用于任何参数类型 | 函数的参数是与类型有关的，如果参数的类型不同，就需要不同的函数，即使他们执行的任务是不同的 |
| 调试 | 宏是不方便调试的 | 函数是可以逐语句调试的 |
| 递归 | 宏是不能递归的 | 函数是可以递归的 |
3.2.7 命名约定
- 把宏名全部大写
- 函数名不要全部大写
3.3 #undef
这条指令用于移除一个宏定义
#define M 100
int main()
{
printf("%d\n", M);
#undef M //移除宏定义
printf("%d\n", M);//无法打印
return 0;
}3.4 命令行定义
????????许多C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。 例如：当我们根据同一个源文件要编译出不同的一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是如果另外一个机器内存大一些，就需要一个大一些的数组。
//linux 环境演示
int main()
{
int arr [SZ];
int i = 0;
for(i = 0; i< SZ; i ++)
{
arr[i] = i;
}
for(i = 0; i< SZ; i ++)
{
printf("%d " ,arr[i]);
}
printf("\n" );
return 0;
}
?可以看到报错了，原因是SZ未定义。输入指令 -D SZ=10? ，即可正常编译
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; }????????运行上面代码，可以正常打印值。此时如果把? #define __DEBUG__? 注释掉，那么 printf("%d\n", arr[i]); 就不会参与编译。
常见的条件编译指令
1.
#if 常量表达式 //常量表达式为真就执行语句，为假则不执行
//...
#endif
//常量表达式由预处理器求值，如：
#define __DEBUG__ 1
#if __DEBUG__
//..
#endif
2.多个分支的条件编译 和 if else一样
#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 指令可以使另外一个文件被编译，替换方式：
- 预处理器先删除这条指令，并用包含文件的内容替换
- 一个源文件被包含10次，那就实际被编译10次
3.6.1?头文件被包含的方式
库文件包含：
#include <filename.h>查找策略：
- 先在源文件所在目录下查找
- 如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件
- 如果找不到就提示编译错误
本地文件包含：
#include “filename”查找策略：
- 查找头文件直接去标准路径下去查找
- 如果找不到就提示编译错误
????????对于库文件也可以使用 “” 的形式包含，但是这样做查找的效率就低些，也不容易区分是库文件还是本地文件了。
Linux环境的标准头文件的路径：
/usr/include
VS环境的标准头文件的路径：
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
3.6.2?嵌套文件包含?
- comm.h和comm.c是公共模块
- test1.h和test1.c使用了公共模块
- test2.h和test2.c使用了公共模块
- test.h和test.c使用了test1模块和test2模块
这样最终程序中就会出现两份comm.h的内容，这样就造成了文件内容的重复。
解决方法：
#include <stdio.h>
#include <stdio.h>
#include <stdio.h> //如果出现头文件被包含多次的情况，会严重造成代码冗余
//解决方法 1
#ifndef __TEST_H__
#define __TEST_H__
int Add(int x, int y);
#endif
//解决方法 2（推荐）
#pragma once //让头文件只包含一次（古董编译器不支持 eg：vc6.0）4 其他预处理指令
????????除了文章中所提到的还有一些其他的预处理指令，比如#error, #line等等，都有者自己不同的作用。
5 面试题
写一个宏，计算结构体中某变量相对于首地址的偏移，并给出说明
考察：offsetof宏的实现
offsetof (type,member) 头文件：#include<stddef.h> 功能介绍：结构体中某变量相对于首地址的偏移。 参数介绍：type类型，member成员名
struct S
{
char c1;
int i;
char c2;
};
int main()
{
struct S s = {0};
printf("%d\n", offsetof(struct S, c1));
printf("%d\n", offsetof(struct S, i));
printf("%d\n", offsetof(struct S, c2));
return 0;
}
5.1 offsetof 宏的实现
#define OFFSETOF(type, m_name) (size_t)&(((type*)0)->m_name)
int main()
{
struct S s = {0};
printf("%d\n", OFFSETOF(struct S, c1));
printf("%d\n", OFFSETOF(struct S, i));
printf("%d\n", OFFSETOF(struct S, c2));
return 0;
}分析：假设0处放一个结构体，把0当成一个结构体的地址，即 (struct S*)0
找成员 ( (struct S*)0)->c1? ? ? ? 取出这个成员的地址 &(( (struct S*)0)->c1)
算偏移量（强制转换为无符号整型） (size_t)&(( (struct S*)0)->c1)
把宏参数放进去，即?(size_t)&(((type*)0)->m_name)
运行截图：
?
附：好书推荐
- 《C语言深度解剖》
- 《高质量C/C++编程指南》
- 《程序员的自我修养》
OK，以上就是本期知识点“程序环境和预处理”的知识啦~~，感谢友友们的阅读。后续还会继续更新，欢迎持续关注哟~
本期封面 ↓
