C语言篇：内联函数

重要提醒，本文涉及许多C语言的高级概念，比如声明、定义、链接类型等。如果你不了解这些概念，可以先阅读我的另外一篇文章《C语言篇：语法进阶》。

内联替换

内联替换是一种常见的编译时优化方法，通过把函数调用原地替换为对应函数的代码，来避免函数调用产生的上下文切换开销，从而加快程序的运行速度。虽然内联替换省去了上下文切换的指令，但是每个替换处都会生成一份函数指令的副本。一般来说，如果函数指令较多且多次被内联替换，会显著增加可执行文件的体积，这是一种用空间换时间的优化策略。

C语言在 C99 标准引入了 inline 关键字，用来指示一个函数需要被内联替换。这个关键字是从 C++ 抄过来的，但二者的语法和机制有很大不同，下文会详细说明。

内联函数跟带参数的宏在作用机制上很像，都是用代码替换来避免函数调用，但是宏替换发生在预处理阶段，只是简单的文本处理，没有语法信息，而内联替换发生在编译阶段，可以享受到函数的所有好处，比如类型检查、参数传递等。

抽丝剥茧

基础认识

虽然原理很简单，但是考虑到C语言的语法交互以及C语言编译器的特性，内联函数绝不是只在函数前面加个 inline 就完事了。

首先，内联替换是在编译阶段完成的，而C语言的编译以单个源文件为单位，也就是说，内联函数的定义与使用必须在同一个源文件内。这点与 static 函数非常像，于是理所当然地可以在任何 static 函数前面加上 inline 使其变成内联函数（不过后面我会告诉你这样做毫无意义）。

但是 inline 只是一个建议，而不是必须执行的命令，因为有些函数无法或很难被内联替换，只有在编译时才能知道一个函数能不能被内联替换，我们在编码时是不能确定的，所以必须做两手准备，内联函数必须既可以作为普通函数提供函数调用，也可以被直接替换。

困境

对于 static inline 函数来说，这两个方面互不冲突。如果不能内联替换，它就是个普通的 static 函数；如果可以内联替换，它就是一个替换模板。

但是 static 函数只能用在源文件内部，如果我们写了一个库，向外提供了一个函数，并且希望它能享受到内联替换的速度优势，该怎么做呢？

最简单的做法就是把 static inline 函数的定义放在头文件里，这样它就会成为每个包含它的源文件的内部函数，并且可以被内联替换。但是这样做有一个严重的问题，如果这个函数最终没有被内联替换，那么就相当于往所有这些源文件里都塞了一个相同 static 函数，与使用单个外部函数（外部链接的函数）比起来，这增大了可执行文件的体积并且减慢了编译速度。

于是人们试图寻找一种方法，对于跨源文件的内联函数，当它无法被内联替换时，让它变成普通的外部函数。

但是这跟我们前面的要求产生了冲突。作为替换模板，它必须在每个源文件中被定义；但作为提供函数调用的外部函数，它无法被重复定义。所以必须对现有语法进行修改才能满足我们的要求。

解决方案

C++ 的方式非常简单直接，允许外部链接的内联函数被重复定义，在编译时它们互不影响，在链接时被合并成一个外部函数。因此在 C++ 里，你可以直接给一个外部函数加上 inline ，然后放在头文件里。

C语言则选择了一个非常蹩脚的方案，后面会详细介绍。它没有链接时的内联函数合并，而是要求程序员显式提供一个外部定义（外部链接的函数的定义）。

深入理解

事实上，一个函数是否可以或是否应该被内联替换，完全取决于编译器。编译器基本上会完全忽略 inline 的内联语义，一个函数即使没加 inline 也会在合适的情况下被内联替换，即使加了 inline 编译器也可以选择不内联替换。因此给 static 函数加 inline 是没有任何意义的，加或不加生成的汇编代码完全一样。

不过 inline 并没有像 register 那样一无是处。不管编译器多么牛逼，只要它还是按单个源文件进行编译的，就必须要看到函数定义才能进行内联替换，而这样就会遇到前面提过的重复定义的问题，就需要手动利用 inline 来解决。可以看出，虽然 inline 的目的是实现内联函数，但它的直接语义早已不是建议内联替换，而是允许重复定义。

语法

由于给 static 函数加 inline 是没有意义的，所以下文只介绍外部链接的内联函数。

首先，为了进行内联替换，如果一个函数的声明带有 inline ，则这个函数必须在此源文件内定义。

为了解决重复定义的问题，C语言标准专门发明一个概念叫做 “内联定义” 。内联定义不是外部定义，所以可以在不同的源文件内重复定义，因为它们代表不同的函数。当一个内联函数被调用时，编译器既可以选择用它的内联定义进行内联替换，也可以选择用它的外部定义生成一个函数调用。

因为内联定义不是外部定义，所以必须为内联函数提供一个专门的外部定义，否则会遇到链接错误。

示例如下：

// main.c

#include 

// inline definition
inline int fn() {
    return 1;
}

int main() {
    printf("%dn", fn());
    return 0;
}

// fn.c

// external definition
int fn() {
    return 1;
}

有趣（或者说令人困惑）的是，尽管在main.c中，fn()是一个内联定义，但它声明了一个具有外部链接的函数，正因如此，才能在main()函数中使用它（毕竟在C语言里，标识符必须先声明后使用）。换句话说，这个标识符能够代表两个函数（内联定义或者外部定义），具体代表哪一个则由编译器来决定。

如果用 gcc -S （生成汇编代码，默认不开优化，即没有内联替换）编译 main.c，你会发现在 main.s 文件中根本没有函数 fn 的代码（因为内联定义不提供函数调用，只在编译时作为替换模板，编译结束后就没用了，直接删掉以减小体积），但 main 函数中有一条 fn 的 call 指令。如果没有编译链接 fn.c ，就会因为找不到 fn 的定义而链接错误。

如果用 gcc -S -O1 （开启优化，包括内联替换）编译，你会发现 fn 的 call 指令没了，被立即数替代。

为了保证内联定义和外部定义具有完全相同的行为，C语言标准禁止在外部链接的内联函数中创建静态生存期的变量（使用 static ），也禁止使用内部链接的标识符（还是用 static ）。

比如：

extern void ex_fn();
static void st_fn();

extern int ex_var;
static int st_var;

inline void in_fn() {
    int in_var;           // valid
    static int in_st_var; // invalid
    in_var = ex_var;      // valid
    in_var = st_var;      // invalid
    ex_fn();              // valid
    st_fn();              // invalid
}

最初的示例有一个巨大的缺陷，为了实现跨源文件的内联函数，我必须在一个单独的源文件中维护一个外部定义。如果我修改了内联定义（一般放在头文件中，所有调用者同步），但忘记同步修改外部定义，那么是否进行内联替换就会产生不同的行为。

为了解决需要维护两份函数定义的问题，C语言标准又加入了新的规则。在一个源文件内，如果一个函数的所有文件作用域（为了加快处理速度）的声明都带 inline 并且都不带 extern ，它才是一个内联定义。也就是说，在已经有内联定义的情况下，我只需要再写一个声明，把 inline 去掉，或者加个 extern （或者都搞一下），就可以把这个内联定义变成外部定义。

最佳实践

在头文件中定义内联函数，除了 inline 以外什么都不加。

// sum.h

#pragma once

inline int sum(int l, int r) {
    return l + r;
}

在对应的源文件里包含该头文件，接着写一个带有 extern 的函数声明，如此一来，就能将头文件中的内联定义转化为外部定义了。这种方式既提供了外部定义，又无需额外维护另一个函数。之所以选择添加 extern 而非删掉 inline ，是因为一个普通的函数声明可能无法引起程序员的重视，他们或许会觉得没用就给删了，而 inline 能够提示代码的意图。

尽管如此还是非常地反直觉，因为 extern 本来表示声明一个在其他源文件中被定义的函数，但在这里却表示一个内联函数的外部定义在此源文件内。

// sum.c

#include "sum.h"

extern inline int sum(int l, int r);

其他源文件直接包含该头文件并使用内联函数。

// main.c

#include 

#include "sum.h"

int main() {
    printf("%dn", sum(1, 2));
    return 0;
}