一、由源码到可执行程序的过程
1. 预处理： 源码经过预处理器的预处理变成预处理过的.i中间文件
1 gcc -E test.c -o test.i
2. 编译： 中间文件经过编译器编译形成.s的汇编文件
1 gcc -S test.i -o test.s
3. 汇编： 汇编文件经过汇编器生成目标文件.o(机器语言)
1 gcc -c test.s -o test.o
4. 链接： 链接器将目标文件链接成.exe可执行程序(Linux下是.elf)
1 gcc test.o -o test.exe
在整个过程中，预处理用预处理器，编译用编译器，汇编用汇编器，链接用链接器，这几个工具再加上其他额外的可能会用到的工具，合起来叫编译工具链。gcc/g++就是一个编译工具链，在实际工程中并不会去手动生成那么多中间文件，而是直接一步到位：
1 gcc test.c -o test.exe
其中，编译器的主要目的是编译源代码，即将.c的源代码（.i本质上就是预处理过的.c)转化成.s汇编代码。为了让编译器聚焦核心功能，就将一些非核心功能剥离到预处理器去了，也就是所让预处理器帮编译器做一些编译前的准备工作。
二、编程中常见的预处理
- 头文件包含：
#include- 注释
- 条件编译：
#if #elif #endif...- 宏定义
2.1 头文件包含
2.1.1 #include <>和 #include ""的区别
#include <>专门用来包含系统提供的头文件，如果使用<>，编译器只会到系统指定目录(编译器中配置的或OS配置的目录，如在Ubuntu中是/usr/include，编译器还允许用-I来附加指定其他的包含路径)去寻找这个头文件，如果找不到就会提示这个头文件不存在。#include ""用来包含程序员写的头文件，编译器默认先在当前目录下寻找相应的头文件，如果没找到再到系统指定目录去寻找，如果还没找到则提示文件不存在。
使用原则
- 系统自带的用
<>- 程序员写的放在当前目录下用
""- 程序员写的集中放专门存放头文件的目录下，在编译器中用
-I参数寻找用<>
2.1.2 头文件包含在预处理时的处理方式
在预处理的时候，预处理器将所包含的头文件的内容原处展开替换这#include语句。
如下所示分别是同一目录下的.c文件和.h文件：
对其进行预编译生成.i文件后，.i文件的内容如下所示：
2.2 注释
我们在.c源文件中写的注释，预处理器在预处理阶段会将其擦除(在.c文件依然存在，在.i文件中不存在)。其实这也正顺应了注释是写给使用程序的人看的，而不是给编译器看的。如下所示：
2.3 条件编译
一般情况下，源程序中所有行都参与编译，但有时希望程序有多种配置，对一部分内容指定编译条件(如产品的调试版与正式版)，这就是条件编译(conditional compile)，条件编译有以下两种判定方法：
2.3.1 #if
这种判定方法类似于if...else...语句，格式为#if (条件表达式)，它的判定标准是()中的表达式是true还是flase，在进行预编译的过程中，只会保留条件表达式为真的那部分内容，如下所示测试代码：
1 #include <stdio.h>
2 #define DEBUG 1
3
4 int main(void)
5 {
6 #if(DEBUG == 1)
7 printf("Version: DEBUG!");
8 #elif(DEBUG == 2)
9 printf("Version: TEST!");
10 #else
11 printf("Version: LAST!");
12 #endif
13
14 return 0;
15 }
预编译结果如下所示：
我们也可以不在源码中对DEBUG进行宏定义，而在编译的时候可以用如下方法对其进行宏定义并指定值：
1 gcc -E -D DEBUG=2 test.c -o test.i
结果如下所示：
2.3.2 #ifdef
用#ifdef XXX判定条件成立与否时主要是看XXX这个符号在本语句之前有没有被定义，只要定义了，判断就成立，并不关心XXX的宏值为多少。测试代码及结果参见下文3.1非带参宏的内容
三、宏定义
3.1 非带参宏
非带参宏主要结合条件编译使用，比较简单，其定义格式为
#define 宏名 替换列表(替换列表可有可无)如下所示：
1 #define DEBUG
2 #define TEST 1
3 #define TEST2 TEST
宏定义的预处理
- 在预处理阶段由预处理器进行机械替换，而不做类型检查
- 宏定义替换会递归进行，直到替换出来的值本身不再是一个宏为止
如下是在STM32开发过程中常用的打印调试信息的一个调试代码段：
1 #include <stdio.h>
2
3 #define USER_TIMER_DEBUG
4 #ifdef USER_TIMER_DEBUG
5 #define user_timer_printf(format, ...) printf( format "
", ##__VA_ARGS__)
6 #define user_timer_info(format, ...) printf("[ timer]info:" format "
", ##__VA_ARGS__)
7 #define user_timer_debug(format, ...) printf("[ timer]debug:" format "
", ##__VA_ARGS__)
8 #define user_timer_error(format, ...) printf("[ timer]error:" format "
",##__VA_ARGS__)
9 #else
10 #define user_timer_printf(format, ...)
11 #define user_timer_info(format, ...)
12 #define user_timer_debug(format, ...)
13 #define user_timer_error(format, ...)
14 #endif
预编译结果如图所示：
3.2 带参宏
宏可以带参数，称为带参宏。带参宏的使用和带参函数非常相似，只是在使用上和处理上有一些差异，其定义格式为：
#define 标识符(参数1,参数2,...,参数n) 替换列表在定义带参宏时，每一个参数在宏体中引用时都必须加括号，最后整体再加括号，括号缺一不可。
不带括号的后果：
1 #include <stdio.h>
2 #define M(a, b) a * b
3 int main(void)
4 {
5 int result = M(2 + 3, 5)
6 printf("%d", result);
7 return 0;
8 }
如上测试代码，我们想得到(2 + 3) * 5的结果，但是由于宏在预处理的时候也是进行机械替换，int result = M(2 + 3, 5)变成了int result = 2 + 3 * 5，这及其容易出现逻辑上的错误
3.2.1 带参宏示例
1.MAX宏: 求2个数中较大的一个
#define MAX(a, b) (((a)>(b)) ? (a) : (b))2.SEC_PER_YEAR宏 用宏定义表示一年中有多少秒
#define SEC_PER_YEAR (365*24*60*60UL)这个宏需要注意的是
- 当一个数字直接出现在程序中时，它的是类型默认是
int- 一年有多少秒，这个数字超过了
int类型存储的范围- 加
UL将其转为无符长整型
3.2.2 带参宏和带参函数的区别
1.时间与空间
- 宏定义在预处理期间处理，进行简单的内容替换，无需额外空间
- 函数是在编译期间处理的，调用时需要为形参分配空间并将实参的值赋给形参
2.执行速度
- 宏只进行文本替换，函数运行阶段参数需要进行出入栈的操作，速度比宏慢
3.类型检查
- 宏定义不会检查参数的类型，返回值也不会附带类型
- 而数有明确的参数类型和返回值类型。当调用函数时编译器参数的静态类型检查，如果编译器发现实际传参和参数声明不同时会报警告或错误。
综合比较
宏和函数各有千秋，最大的特点是：用函数的时候程序员不太用操心类型不匹配因为编译器会检查，用宏的时候程序员必须注意实际传参和宏所希望的参数类型一致，或者自行加入类型检查，否则可能编译不报错但是运行有误。
如对MAX宏加入类型检查：
1 #define MAX(a, b) ({
2 typeof(a) _a = (a);
3 typeof(b) _b = (b);
4 (void) (&_a == &_b);
5 _a > _b ? _a : _b;})
测试代码:
1 #include <stdio.h>
2
3 #define MAX(a, b) ({
4 typeof(a) _a = (a);
5 typeof(b) _b = (b);
6 (void) (&_a == &_b);
7 _a > _b ? _a : _b;})
8
9 #define MAX2(a, b) a > b ? a : b
10
11 int main(void)
12 {
13 int a = 2;
14 float b = 3.1;
15 int result2 = MAX2(a, b);
16 typeof(MAX(a, b)) result = MAX(a, b);
17 printf("result = %f
", result);
18 printf("result2 = %d
", result2);
19 return 0;
20 }
四、内联函数
内联函数本质上是函数，通过在函数定义前加inline关键字实现，是编译器负责处理的，可以做参数的静态类型检查。同时也有带参宏的展开特性，运行时没有调用开销。
4.1 与常规函数对比
- 当函数体很短的时候，使用常规函数会造成很大的调用开销,内联函数采用原地展开的方式，没有调用开销
- 当函数体长的时候，由于内联函数展开会降低寻址效率，所以长函数体不会使用内联函数
- 内联函数本质上是函数，函数的性质内联函数都有
4.2 与宏的对比
- 参数类型检查。编译过程中，编译器仍可以对其内联函数进行参数检查
- 便于调试。函数支持的调试功内联函数同样支持，而宏不支持
- 接口封装。有些内联函数可以用来封装一个接口，而宏不具备这个特性
4.3 noinline和always_inline
当函数的函数体很小，而且被大量频繁调用，应该做内联展开时，就可以使用内联函数。但编译器会不会作内联展开，编译器也会有自己的权衡（不合理的内联函数会降低CPU寻址效率、函数运行效率、降低代码的可移植性…）。如果想告诉编译器一定要展开，或者不作展开，就可以使用noinline或always_inline对函数作一个属性声明。
1 static inline int func(int *, int);//编译器权衡是否内联展开
2 static inline __attribute__((noinline)) int func(int *, int);//不内联展开
3 static inline __attribute__((always_inline)) int func(int *, int);//内联展开
用static修饰呢是因为内联函数不一定会内联展开，当多个文件都包含同一个内联函数的定义时，如果没有static将函数的作用域限制在各自本地文件内，编译时就有可能报重定义错误
转自：https://blog.csdn.net/weixin_43955214/article/details/104255557