[C++知识库]一个程序的生老病死【预处理】【编译】【链接】

本章重点

• 程序的翻译环境
• 程序的执行环境
• C语言程序的编译+链接
• 预定义符号介绍
• 预处理指令#define
• 宏和函数的对比
• 预处理操作符#和##的介绍
• 命令定义
• 预处理指令 #include
• 预处理指令 #undef
• 条件编译

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

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

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

翻译环境

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

翻译环境分为四个：

预处理 编译 汇编 链接

预处理

在Linux上操作是：
gcc test.c-E
->test.i

作用：

1. 头文件展开
2. 宏替换
3. 条件编译
4. 去注释

编译

在Linux上操作是：
gcc test.i -S
->test.s

作用：
检查语法，生成汇编代码

1. 语法分析
2. 词法分析
3. 语义分析
4. 符号汇总（汇总的是全局的符号）
5. 把C语言代码转换成汇编代码

汇编

在Linux上操作是：
gcc test-s -C
->test.o

作用：

1. 形成符号表
2. 把汇编代码转换成二进制指令（机器指令）

链接

在Linux上操作是：
gcc test.c
->a.out

作用：

1. 合并段表
2. 符号表的合并和重定位
3. 自身程序+库文件进行关联（动态链接，静态链接），形成可执行程序

库：可以提高效率，和增加健壮性（鲁棒性）

相当于把几个目标文件链接到一起，比如你在func.c中实现函数的定义，在func.h中实现函数的声明，test.c中包含func.h头文件，调用此函数，则链接的重要任务就是，让func.h中的函数的声明根据函数的命名规则找到函数定义的地址。

运行环境

程序执行的过程：

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

预处理详解

__FILE__ //输出当前文件的位置
__LINE__ //文件当前的行号
__DATE__ //文件被编译的日期
__TIME__ //文件被编译的时间

预处理指令#define

#define 定义标识符
#define这个简单的用法就不必多说

1、在define定义标识符的时候，要不要在最后加上 ;

比如：

#define MAX 100;
#define MAX 100

建议不要加，容易出错，比如在if else语句中

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

2、宏定义应多用括号，规范定义

#define DOUBLE(x) x+x
10*DOUBLE(2)是多少？
难道是10*4=40吗
错！
其实是 10*2+2=22

因为宏定义是简单的文本替换，它不会先计算好再用，而是直接文本替换，所以使用的时候一定要规范，多加（），避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。

3、宏参数和#define定义中可以出现其他#define定义的变量。但对于宏，不能出现递归

4、当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索

#define M 10
int main()
{
    printf("M=%d\n",M);
}
最后结果是M=10

5、# 和 ##

#define X #X
这里的X会被替换成字符串"X"

#define A(X,Y) X##Y
这里会把X和Y合并成一个
比如：
int B23=100;
printf("%d\n",A(B,23));
printf("%d\n",B23);
这两个结果一样

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

#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);//输出的结果是什么？

记住一点就是，x++和y++是直接替换进去的，不是计算完再替换

MAX(x, y) ( (x++) > (y++) ? (x++) : (y++) )

宏和函数对比

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

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

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

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

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

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

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

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

int main()
{
   int*p=MALLOC(10,int);
}

宏和函数的一个对比

命名约定

我们一般宏的定义都用大写英文，函数名一般不要全部大写，一般为开头大写和分隔词大写。

#undef

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

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

命令行定义（参数）

许多C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。
例如：当我们根据同一个源文件要编译出不同的一个程序的不同版本的时候，这个特性有点用处。

举例：

int main()
{
    int arr[M]={0};
    for(int i=0;i<M;i++)
    {
        arr[i]=i;
    }
}

在Linux平台我们可以使用命令行参数来指定M的大小

gcc -D M=10 

条件编译

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

条件编译是什么：
条件编译简单来说就是代码裁剪工具，本质认识是编译器根据实际情况，对代码进行裁剪，这里的实际情况，取决于运行的平台，和代码本身的业务逻辑。

条件编译的好处：
通过裁剪代码，快速达到某种目的，只保留当前需要的代码逻辑。减少代码生成的大小。
可以写出跨平台的代码，让一个具体业务，在不同平台编译的时候，可以有相同的表现。

条件编译使用场景：
版本的维护，像free版本，VIP版本，家庭版，企业版，我们就可以使用条件编译对代码进行裁剪，你是什么版本的就给你相应版本的代码。（公司肯定不会专门写好几套项目，那样维护成本太高）。著名的Linux内核，功能上也是使用条件编译进行裁剪的，来满足不同平台的软件使用。

常见的条件编译指令：

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

#define c
#ifdef c
//...
#else
//...
#endif

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

文件包含

我们已经知道， #include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。
这种替换的方式很简单： 预处理器先删除这条指令，并用包含文件的内容替换。 这样一个源文件被包含10次，那就实际被编译10次。

头文件被包含的方式：
1、本地文件包含

#include "func.h"

查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件。 如果找不到就提示编译错误。
linux环境的标准头文件的路径：/usr/include
VS环境的标准头文件的路径：
C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include

2、库文件包含

#include <stdio.h>

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

嵌套文件包含
如果出现这样的情况怎么办

这样就造成了文件重复包含，就会导致头文件重复展开，影响代码执行效率
两个解决办法：
1、

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

2、

#pragma once

推荐第二种简单嘛，这样就可以避免头文件被重复包含了

这期就到这里啦，感谢阅读，我们下期再见
如有错 欢迎提出一起交流
关注周周汪哦

关注三连么么么哒