【转】C语言的inline关键字

GCC的static inline定义很容易理解：你可以把它认为是一个static的函数，加上了inline的属性。这个函数大部分表现和普通的static函数一样，只不过在调用这种函数的时候，gcc会在其调用处将其汇编码展开编译而不为这个函数生成独立的汇编码。除了以下几种情况外：

static inline函数和static函数一样，其定义的范围是local的，即可以在程序内有多个同名的定义（只要不位于同一个文件内即可）。

相对于C99的inline来说，GCC的inline更容易理解：可以认为它是一个普通全局函数加上了inline的属性。即在其定义所在文件内，它的表现和static inline一致：在能展开的时候会被内联展开编译。但是为了能够在文件外调用它，gcc一定会为它生成一份独立的汇编码，以便在外部进行调用。即从文件外部看来，它和一个普通的extern的函数无异。举个例子：

foo.c:<br /><br />/* 这里定义了一个inline的函数foo() */<br />inline foo() {<br />    ...;   &lt;- 编译器会像非inline函数一样为foo()生成独立的汇编码<br />}<br /><br />void func1() {<br />    foo(); &lt;- 同文件内foo()可能被编译器内联展开编译而不是直接call上面生成的汇编码<br />}

而在另一个文件里调用foo()的时候，则直接call的是上面文件内生成的汇编码：

bar.c:<br /><br />extern foo(); &lt;- 声明foo()，注意不能在声明内带inline关键字<br /><br />void func2() {<br />    foo();    &lt;- 这里就是直接call在foo.c内为foo()函数生成的汇编码了<br />}

GCC的static inline和inline都很好理解：看起来都像是对普通函数添加了可内联的属性。但是这个extern inline就千万不能想当然地理解成就是一个extern的函数+inline属性了。实际上gcc的extern inline十分古怪：一个extern inline的函数只会被内联进去，而绝对不会生成独立的汇编码！即使是通过指针应用或者是递归调用也不会让编译器为它生成汇编码，在这种时候对此函数的调用会被处理成一个外部引用。另外，extern inline的函数允许和外部函数重名，即在存在一个外部定义的全局库函数的情况下，再定义一个同名的extern inline函数也是合法的。以下用例子具体说明一下extern inline的特点：

foo.c:<br /><br /><div class="dp-highlighter"><div class="bar"><div class="tools"><a href="http://blog.csdn.net/lidh04/archive/2009/01/16/3795802.aspx#"><font color="#a0a0a0">view plain</font></a><a href="http://blog.csdn.net/lidh04/archive/2009/01/16/3795802.aspx#"><font color="#a0a0a0">copy to clipboard</font></a><a href="http://blog.csdn.net/lidh04/archive/2009/01/16/3795802.aspx#"><font color="#a0a0a0">print</font></a><a href="http://blog.csdn.net/lidh04/archive/2009/01/16/3795802.aspx#"><font color="#a0a0a0">?</font></a></div></div><ol class="dp-cpp"><li class="alt"><span><span class="keyword"><strong><font color="#006699">extern</font></strong></span><span> </span><span class="keyword"><strong><font color="#006699">inline</font></strong></span><span>&nbsp;&nbsp;</span></span></li><li><span class="datatypes"><strong><font color="#2e8b57">int</font></strong></span><span> foo(</span><span class="datatypes"><strong><font color="#2e8b57">int</font></strong></span><span> a) &nbsp;&nbsp;</span></li><li class="alt"><span>{ &nbsp;&nbsp;</span></li><li><span>&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="keyword"><strong><font color="#006699">return</font></strong></span><span> (-a); &nbsp;&nbsp;</span></li><li class="alt"><span>} &nbsp;&nbsp;</span></li><li><span>&nbsp;&nbsp;</span></li><li class="alt"><span class="keyword"><strong><font color="#006699">void</font></strong></span><span> func1() &nbsp;&nbsp;</span></li><li><span>{ &nbsp;&nbsp;</span></li><li class="alt"><span>&nbsp;&nbsp;&nbsp;&nbsp;  ...; &nbsp;&nbsp;</span></li><li><span>&nbsp;&nbsp;&nbsp;&nbsp;  a = foo(a);&nbsp;&nbsp;&nbsp;  ① &nbsp;&nbsp;</span></li><li class="alt"><span>&nbsp;&nbsp;&nbsp;&nbsp;  p_foo = foo;&nbsp;&nbsp;  ② &nbsp;&nbsp;</span></li><li><span>&nbsp;&nbsp;&nbsp;&nbsp;  b = p_foo(b); ③ &nbsp;&nbsp;</span></li><li class="alt"><span>}&nbsp;&nbsp;</span></li></ol></div>

在这个文件内，gcc不会生成foo函数的汇编码。在func1中的调用点①，编译器会将上面定义的foo函数在这里内联展开编译，其表现类似于普通inline函数。因为这样的调用是能够进行内联处理的。而在②处，引用了foo函数的地址。但是注意：编译器是绝对不会为extern inline函数生成独立汇编码的！所以在这种非要个函数地址不可的情况下，编译器不得不将其处理为外部引用，在链接的时候链接到外部的foo函数去（填写外部函数的地址）。这时如果外部没有再定义全局的foo函数的话就会在链接时产生foo函数未定义的错误。

假设在另一个文件里面也定义了一个全局函数foo：

foo2.c:<br /><br /><div class="dp-highlighter "><div class="bar"><div class="tools"><a href="http://blog.csdn.net/lidh04/archive/2009/01/16/3795802.aspx#"><font color="#a0a0a0">view plain</font></a><a href="http://blog.csdn.net/lidh04/archive/2009/01/16/3795802.aspx#"><font color="#a0a0a0">copy to clipboard</font></a><a href="http://blog.csdn.net/lidh04/archive/2009/01/16/3795802.aspx#"><font color="#a0a0a0">print</font></a><a href="http://blog.csdn.net/lidh04/archive/2009/01/16/3795802.aspx#"><font color="#a0a0a0">?</font></a></div></div><ol class="dp-cpp"><li class="alt"><span><span class="datatypes"><strong><font color="#2e8b57">int</font></strong></span><span> foo(</span><span class="datatypes"><strong><font color="#2e8b57">int</font></strong></span><span> a) &nbsp;&nbsp;</span></span></li><li><span>{ &nbsp;&nbsp;</span></li><li class="alt"><span>&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="keyword"><strong><font color="#006699">return</font></strong></span><span> (a); &nbsp;&nbsp;</span></li><li><span>} </span></li></ol></div>

那么在上面那个例子里面，后面一个对foo函数地址的引用就会在链接时被指到这个foo2.c中定义的foo函数去。也就是说：①调用foo函数的结果是a=-a，因为其内联了foo.c内的foo函数；而③调用的结果则是b=b，因为其实际上调用的是foo2.c里面的foo函数！

extern inline的用法很奇怪也很少见，但是还是有其实用价值的。第一：它可以表现得像宏一样，可以在文件内用extern inline版本的定义取代外部定义的库函数（前提是文件内对其的调用不能出现无法内联的情况）；第二：它可以让一个库函数在能够被内联的时候尽量被内联使用。举个例子：

在一个库函数的c文件内，定义一个普通版本的库函数libfunc：

lib.c:<br /><br />void libfunc()<br />{<br />    ...;<br />}

然后再在其头文件内，定义（注意不是声明！）一个实现相同的exterin inline的版本：

lib.h:<br /><br />extern inline libfunc()<br />{<br />    ...;<br />}

那么在别的文件要使用这个库函数的时候，只要include了lib.h，在能内联展开的地方，编译器都会使用头文件内extern inline的版本来展开。而在无法展开的时候（函数指针引用等情况），编译器就会引用lib.c中的那个独立编译的普通版本。即看起来似乎是个可以在外部被内联的函数一样，所以这应该是gcc的extern inline意义的由来。

但是注意这样的使用是有代价的：c文件中的全局函数的实现必须和头文件内extern inline版本的实现完全相同。否则就会出现前面所举例子中直接内联和间接调用时函数表现不一致的问题。

同GCC的static inline（第 1.1 节 “static inline”）。

C99的inline的使用相当令人费解。当一个定义为inline的函数没有被声明为extern的时候，其表现有点类似于gcc中extern inline那样（C99里面这段描述有点晦涩，原文如下）：

即如果一个inline函数在文件范围内没有被声明为extern的话，这个函数在文件内的表现就和gcc的extern inline相似：在本文件内调用时允许编译器使用本文件内定义的这个内联版本，但同时也允许外部存在同名的全局函数。只是比较奇怪的是C99居然没有指定编译器是否必须在本文件内使用这个inline的版本而是让编译器厂家自己来决定，相当模糊的定义。

如果在文件内把这个inline函数声明为extern，则这个inline函数的表现就和gcc的inline一致了：这个函数即成为一个“external definition”（可以简单理解为全局函数）：可以在外部被调用，并且在程序内仅能存在一个这样名字的定义。

下面举例说明C99中inline的特性：

inline double fahr(double t)<br />{<br />    return (9.0 * t) / 5.0 + 32.0;<br />}<br /><br />inline double cels(double t)<br />{<br />    return (5.0 * (t - 32.0)) / 9.0;<br />}<br /><br />extern double fahr(double);   ①<br /><br />double convert(int is_fahr, double temp)<br />{<br />    return is_fahr ? cels(temp) : fahr(temp);   ②<br />}

在上面这个例子里，函数fahr是个全局函数：因为在①处将fahr声明为extern，因此在②处调用fahr的时候使用的一定是这个文件内所定义的版本（只不过编译器可以将这里的调用进行内联展开）。在文件外部也可以调用这个函数（说明像gcc的inline一样，编译器在这种情况下会为 fahr生成独立的汇编码）。

而cels函数因为没有在文件范围内被声明为extern，因此它就是前面所说的“inline definition”，这时候它实际上仅能作用于本文件范围（就像一个static的函数一样），外部也可能存在一个名字也为cels的同名全局函数。在②处调用cels的时候编译器可能选择用本文件内的inline版本，也有可能跑去调用外部定义的cels函数（C99没有规定此时的行为，不过编译器肯定都会尽量使用文件内定义的inline版本，要不然inline函数就没有存在的意义了）。从这里的表现上看C99中未被声明为extern的 inline函数已经和gcc的extern inline十分相似了：本文件内的inline函数可以作为外部库函数的替代。

foo.h:<br /><br />extern foo();

foo.c:<br /><br />#include &quot;foo.h&quot;<br /><br />inline void foo()<br />{<br />    ...;<br />}

C99没有见到extern inline的用法。