什么是内联函数

2024年7月12日 | 分类: 【编程】

一、定义：

如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 inline 。

内联函数是C++的增强特性之一，用来降低程序的运行时间。当内联函数收到编译器的指示时，即可发生内联：把内联函数的函数体在编译器预处理的时候替换到函数调用处（加副本），这样代码运行到这里时候就不需要花时间去调用函数（减少了函数调用过程的入栈出栈等开销），注意这种替代行为发生在编译阶段而非程序运行阶段，且对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。

值得注意的是，内联函数仅仅是对编译器的内联建议，编译器是否觉得采取你的建议取决于函数是否符合内联的有利条件。如果函数体非常大，那么编译器将忽略函数的内联声明，而将内联函数作为普通函数处理。

二、例子：

有时候我们会写一些功能专一的函数，这些函数的函数体不大，包含了很少的执行语句。例如在计算1~1000以内的素数时，我们经常会使用开方操作使运算范围缩小，这时我们会写一个函数：

int root(int n)
{
　　return (int)sqrt((float)n);
}

然后我们的求范围内素数的函数可以这样写：

int prime(int n)
{
    int i;
    for (i = 2; i <= root(n); i++)
    {
        if (n%i == 0)
　　　　　　return 0;
        return 1;
    }
}

当然，把root函数放在循环中不是个不明智的选择，但想象一下，在某个程序上下文内必须频繁地调用某个类似root的函数，其调用函数的花销会有多大：当遇到普通函数的调用指令时，程序会保存当前函数的执行现场，将函数中的局部变量以及函数地址压入堆栈，然后再将即将调用的新函数加载到内存中，这要经历复制参数值、跳转到所调用函数的内存位置、执行函数代码、存储函数返回值等过程，当函数执行完后，再获取之前正在调用的函数的地址，回去继续执行那个函数，运行时间开销简直太多了。

三、优缺点

1、优点

通过避免函数调用所带来保存现场、变量弹栈压栈、跳转新函数、存储函数返回值、执行完返回原现场等开销，提高了程序的运行速度
通过将函数声明为内联，你可以把函数定义放在头文件内。编译器需要把inline函数体替换到函数调用处，所以编译器必须要知道inline函数的函数体是啥，所以要将inline函数的函数定义和函数声明一起写在头文件中，便与编译器查找替换。

2、缺点

因为代码的替换扩展，内联函数会增大可执行程序的体积，进而导致程序变得更慢
C++内联函数的展开是中编译阶段，这就意味着如果你的内联函数发生了改动，那么就需要重新编译代码
当你把内联函数放在头文件中时，它将会使你的头文件信息变多，不过头文件的使用者不用在意这些

四、什么时候可以使用内联函数

对程序执行性能有要求且函数不超过10行
想宏定义一个函数（待补充）
在类内部定义的函数会默认声明为inline函数，这有利于类实现细节的隐藏

一.什么是内联函数

1.直观上定义：

内联函数的定义与普通函数基本相同,只是在函数定义前加上关键字 inline。

inline void print(char *s)
{
    printf("%s", s);
}

2.更深入的思考：

1. 函数前面加上inline一定会有效果吗？
2. 如果不加inline就不是内联函数了吗？

后面让我们慢慢来解答这两个问题。

二.为什么使用内联函数

1. 内联函数最初的目的：代替部分 #define 宏定义
2. 使用内联函数替代普通函数的目的：提高程序的运行效率；

针对上述两个方面我们展开讨论：

1.为什么要代替部分宏定义

1. 宏是预处理指令，在预处理的时候把所有的宏名用宏体来替换；内联函数是函数，在编译阶段把所有调用内联函数的地方把内联函数插入；

2. 宏没有类型检查，无论对还是错都是直接替换；而内联函数在编译时进行安全检查；

3. 宏的编写有很多限制，例如只能写一行，不能使用return控制流程等；

4. 对于C++ 而言，使用宏代码还有另一种缺点：无法操作类的私有数据成员。

2.普通函数频繁调用的过程消耗栈空间

函数是一个可以重复使用的代码块，CPU 会一条一条地挨着执行其中的代码。CPU 在执行主调函数代码时如果遇到了被调函数，主调函数就会暂停，CPU 转而执行被调函数的代码；被调函数执行完毕后再返回到主调函数，主调函数根据刚才的状态继续往下执行。

一个 C/C++程序的执行过程可以认为是多个函数之间的相互调用过程，它们形成了一个或简单或复杂的调用链条，这个链条的起点是main()，终点也是main()。当main()调用完了所有的函数，它会返回一个值（例如return 0;）来结束自己的生命，从而结束整个程序。

函数调用是有时间和空间开销的。程序在执行一个函数之前需要做一些准备工作，要将实参、局部变量、返回地址以及若干寄存器都压入栈中，然后才能执行函数体中的代码；函数体中的代码执行完毕后还要清理现场，将之前压入栈中的数据都出栈，才能接着执行函数调用位置以后的代码。

栈空间就是指放置程式的局部数据也就是函数内数据的内存空间，在系统下，栈空间是有限的，假如频繁大量的使用就会造成因栈空间不足所造成的程式出错的问题，函数的死循环递归调用的最终结果就是导致栈内存空间枯竭。

如果函数体代码比较多，需要较长的执行时间，那么函数调用机制占用的时间可以忽略；如果函数只有一两条语句，那么大部分的时间都会花费在函数调用机制上，这种时间开销就就不容忽视。

具体的一个调用效率讨论在第六章节 内联函数的类方法实现

为了消除函数调用的时空开销，C++ 提供一种提高效率的方法，即在编译时将函数调用处用函数体替换，类似于C语言中的宏展开。这种在函数调用处直接嵌入函数体的函数称为内联函数（Inline Function）。但也存在缺点，就是每一调用处均会展开，增加了重复的代码量。

可以理解为内联函数的关键词是：替换

3.更深入的思考

通过上述内容我们知道内联函数是在调用的地方展开函数定义，那么问题又来了，展开也好，替换也好，都存在下面两个问题：

1. 内联函数一定就会展开吗？
2. 在什么情况下内联函数会展开？

三.内联函数和编译过程的相爱相杀

在这一节，我们先一口气回答前两节的所有问题，然后慢慢引出后面的话题。

1. 函数前面加上inline一定会有效果吗？

答：不会，使用内联inline关键字修饰函数只是一种提示，编译器不一定认。

2. 如果不加inline就不是内联函数了吗？

答：存在隐式内联，不用inline关键字，C++中在类内定义的所有函数都自动称为内联函数。

3. 内联函数一定就会展开吗？

答：其实和第一个问题类似，还是看编译器认不认。

4. 在什么情况下内联函数会展开？

答：首先需要满足有inline修饰或者是类中的定义的函数，然后再由编译器决定。

一言蔽之：内联函数管不管用是由编译器决定的！

那如何要求编译器展开内联函数呢？

1. 编译器开优化：gcc -O2 test.c -o test，只有在编译器开启优化选项的时候，才会有inline行为的存在，比如对g++在-O0时就不会作任何的inline处理，对于-O2的优化方式，编译器会通过启发式算法决定是否值得对一个函数进行内联，同时要保证不会对生成文件的大小产生较大影响。而-O3模式则不在考虑生成文件的大小；

2. 使用attribute属性：static inline __attribute__((always_inline)) int add_i(int a,int b)；

3. 使用auto_inline：#pragma auto_inline(on/off)，当使用#pragma auto_inline(off)指令时，会关闭对函数的inline处理，这时即使在函数前面加了inline指令，也不会对函数进行内联处理。

上述操作都仅仅是对编译器提出内联的建议，最终是否进行内联由编译器自己决定，大多数编译器拒绝它们认为太复杂的内联函数（例如，那些包含循环或者递归的），而且类的构造函数、析构函数和虚函数往往不是内联函数的最佳选择。

有关visual studio中编译优化选择的位置如图，gcc编译见上面的例子也可以直接man gcc查看。

四.内联函数怎么用，在哪儿用？

基本介绍完内联的概念，接下来说说内联怎么用，在哪儿用？

内联函数是定义在头文件还是源文件？

内联展开是在编译时进行的，只有链接的时候源文件之间才有关系。所以内联要想跨源文件必须把实现写在头文件里。如果一个内联函数会在多个源文件中被用到，那么必须把它定义在头文件中

内联函数的定义不一定要跟声明放在一个头文件里面：定义可以放在一个单独的头文件中，里面需要给函数定义前加上inline 关键字，原因看下面第 2.点；然后声明放在另一个头文件中，此文件include上一个头文件。这种用法 boost里很常见：优点1. 实现跟API分离封装。优点2. 可以解决有关inline函数的循环调用问题。

1.隐式内联：如第三节说的C++中在类内定义的所有函数都自动称为内联函数，类的成员函数的定义直接写在类的声明中时，不需要inline关键字

#include <stdio.h>
class Trace{
public:
Trace()
{
noisy = 0;
}
void print(char *s)
{
if (noisy)
{
printf(“%s”, s);
}
}
void on(){ noisy = 1; }
void off(){ noisy = 0; }
private:
int noisy;
};

2.显示内联：需要使用inline关键字

#include <stdio.h>
class Trace{
public:
Trace()
{
noisy = 0;
}
void print(char *s); //类内没有显示声明
void on(){ noisy = 1; }
void off(){ noisy = 0; }
private:
int noisy;
};
//类外显示定义
inline void Trace::print(char *s)
{
if (noisy)
{
printf(“%s”, s);
}
}

五.内联函数和重定义

这一部分我们带着问题一步步进行分析思考

1. - 什么是重定义？

答：C/C++语法中，如果变量、函数在同一个工程中被多次定义，链接期间会报类似“对 xxx 多重定义”的错误。

当内联函数的声明和定义分别在头文件和源文件中，并且在其他文件中被调用时，链接期间编译器会报“对 xxx 未定义的引用”错误。内联函数如果会在多处被调用，则需要将函数的定义写在头文件中。

1. - 为什么inline关键字修饰的函数定义在头文件中（函数可能会被多次定义），编译器不会报“对 xxx 多重定义”的错误呢？

答：编译器对被inline修饰的函数做了特殊处理，inline起到了内联的作用；

1. - inline为什么能起作用？

答：因为inline是一个弱符号；

1. - 什么是弱符号？

答：在C语言中，编译器默认函数和初始化了的全局变量为强符号（Strong Symbol），未初始化的全局变量为弱符号（Weak Symbol）。强符号之所以强，是因为它们拥有确切的数据，变量有值，函数有函数体；弱符号之所以弱，是因为它们还未被初始化，没有确切的数据。

链接器会按照如下的规则处理被多次定义的强符号和弱符号：
1) 不允许强符号被多次定义，也即不同的目标文件中不能有同名的强符号；如果有多个强符号，那么链接器会报符号重复定义错误。

2) 如果一个符号在某个目标文件中是强符号，在其他文件中是弱符号，那么选择强符号。

3) 如果一个符号在所有的目标文件中都是弱符号，那么选择其中占用空间最大的一个。

1. - 怎么知道inline是个弱符号的？

答：反汇编：objdump -dS test，看下面两个例子：

下面两个.cpp文件，除Function()的inline修饰符外其他内容完全一致

1.正常的函数

/* NormalMain.cpp */
#include <cstdio>
void Function()
{
printf(“[Function]========= Get!!!\n”);
}
int main() {
Function();
}

汇编结果：

.file “NormalMain.cpp”
.section .rodata
.LC0:
.string “[Function]========= Get!!!”
.text
.globl _Z8Functionv
.type _Z8Functionv, @function
_Z8Functionv:
;…

2.内联函数

/* InlineMain.cpp */
#include <cstdio>
inline void Function()
{
printf(“[Function]========= Get!!!\n”);
}
int main() {
Function();
}

汇编结果：

.file “InlineMain.cpp”
.section .rodata
.LC0:
.string “[Function]========= Get!!!”
.section .text._Z8Functionv,“axG”,@progbits,_Z8Functionv,comdat
.weak _Z8Functionv
.type _Z8Functionv, @function
_Z8Functionv:
;…

很容易发现，inline修饰的Function()编译结果是.weak弱符号，而没有被inline修饰的Function()编译结果是.globl全局符号（强符号）因此，如果一个符号在所有的目标文件中都是弱符号，那么选择其中占用空间最大的一个,那么问题又来了：

1. - 如果 1.obj 和 2.obj 中同名的 inline 函数体，它们的实现代码不一样会如何？

答：按理说选择其中占用空间最大的一个，但是链接器选了最偷懒的方案，会挑最先碰到的那个来用，甚至不会给出警告。

所以内联函数里面坑很多，即使因为inline的弱符号特性避免了重定义，但是也会出现其他坑，比如编译器优化开关关闭时，inline函数可能会被同名的其它函数替代，弱符号被强符号代替，从而影响业务逻辑的正确性。

/* InlineMain.cpp */
#include <cstdio>
inline void Function()
{
printf(“[Function]========= Get!!!\n”);
}

/* FunctionDef.cpp */
#include <cstdio>
void Function()
{
printf(“[Another Function]========= Get!!!\n”);
}

int main() {
Function();
}

运行结果为

[Another Function]========= Get!!!

编译器优化开关打开时，运行结果正常不存在问题。

[Function]========= Get!!!

六.内联函数的类方法实现

大家都知道，C++相比于C来说，多了Class这一用法，增加了面向对象编程的思想，也有很多人称C++为C With Class，C++比C语言上多了类这一特性，从函数内联的角度上来讨论分析一下类实现内联函数和不使用类的C风格函数在效率上直观的区别。

1.C++类实现

C++中在类内定义的所有函数都自动称为内联函数（隐式内联）

内联函数本身也是一个真正的函数，具有普通函数的所有行为，唯一不同之处在于内联函数会在适当地方像预定义宏一样展开，在程序运行时不再进行函数调用和返回，从而消除函数调用和返回的系统开销,提高了程序执行效率。

#include <stdio.h>
class Trace{
public:
Trace()
{
noisy = 0;
}
void print(char *s)
{
if (noisy)
{
printf(“%s”, s);
}
}
void on(){ noisy = 1; }
void off(){ noisy = 0; }
private:
int noisy;
};

对于Trace类来说，其中的成员函数定义在类内，C++会内联扩展他们

int main()
{
Trace t;
t.print(“inline function”);
return 0;
}

2.C语言不用类实现

在C语言中，如果一些函数被频繁调用，不断地有函数入栈，即函数栈，会造成栈空间或栈内存的大量消耗。

#include <stdio.h>
static int noisy = 1;
void trace(char *s)
{
if(noisy)printf(“%s”, s);
}
void trace_on(){ noisy = 1; }
void trace_off(){ noisy = 0; }
int main()
{
trace(“trace”);
return 0;
}

上述代码中还引入了更多的全局变量，C++只有一个，C有三个

五.内联与宏

第二节已经基本说明为什么使用内联函数代替宏，下面举一个例子说明。

在C程序中，可以用宏代码提高执行效率。宏代码本身不是函数，但使用起来象函数。预处理器用复制宏代码的方式代替函数调用，省去了参数压栈、生成汇编语言的CALL调用、返回参数、执行return等过程，从而提高了速度。
使用宏代码最大的缺点是容易出错，预处理器在复制宏代码时常常产生意想不到的边际效应。宏看起来像函数调用，但没有参数类型及返回值，实际会有隐藏的难以发现的问题，例如执行ans = MyAdd(2, 3)*2时会返回2+3*2。

六.内联的局限性

内联能提高函数的执行效率，为什么不把所有的函数都定义成内联函数？
1.内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。(一般情况，在函数频繁调用且函数内部代码很少的情况下使用内联)
2.每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
3.类的构造函数和析构函数容易让人误解成使用内联更有效。要当心构造函数和析构函数可能会隐藏一些行为，如“偷偷地”执行了基类或成员对象的构造函数和析构函数。所以不要随便地将构造函数和析构函数的定义体放在类声明中。
4.一个好的编译器将会根据函数的定义体，自动地取消不值得的内联。对函数作inline声明只是程序员对编译器提出的一个建议，而不是强制性的，并非一经指定为inline编译器就必须这样做。编译器有自己的判断能力，它会根据具体情况决定是否这样做。一个好的编译器将会根据函数的定义体，自动地取消不值得的内联（这进一步说明了inline 不应该出现在函数的声明中）。具体是否会被编译器优化为内联也要看优化级别。有些函数即使声明为内联的也不一定会被编译器内联，这点很重要。比如虚函数和递归函数就不会被正常内联。通常，递归函数不应该声明成内联函数。（递归调用堆栈的展开并不像循环那么简单，比如递归层数在编译时可能是未知的，大多数编译器都不支持内联递归函数）。虚函数内联的主要原因则是想把它的函数体放在类定义内，为了图个方便，抑或是当作文档描述其行为, 比如精短的存取函数。将内联函数放在头文件里实现是合适的，省却你为每个文件实现一次的麻烦。而所以声明跟定义要一致，其实是指，如果在每个文件里都实现一次该内联函数的话，那么，最好保证每个定义都是一样的，否则，将会引起未定义的行为，即是说，如果不是每个文件里的定义都一样，那么，编译器展开的是哪一个，那要看具体的编译器而定。所以，最好将内联函数定义放在头文件中。

七.内联的使用建议

使用：

当对程序执行性能有要求时，那么就适当使用内联函数
当你想宏定义一个函数时，使用内联函数
写一些功能专一且性能关键的函数，这些函数的函数体不大，包含了很少的执行语句。通过inline声明，编译器不需要跳转到内存其他地址去执行函数调用，也不需要保留函数调用时的现场数据。
在类内部定义的函数会默认声明为inline函数，这有利于类实现细节的隐藏。（但也需要斟酌如果不需要隐藏的时候，其实大部分是不推荐默认inline的）
不使用：

不使用：如果函数体内的代码比较长，使用内联将导致内存消耗代价较高。
不使用：如果函数体内出现循环或者开关语句；那么执行函数体内代码的时间要比函数调用的开销大。

八.内联和static

多数情况下，inline 前面会加static关键字。why?

分开理解：

static 意味着本地化，每个包含头文件的C文件均在本地产生一个独立的内联函数。当有多个C文件包含头文件时，不会因为函数名相同而报重定义错误。(代价就是代码所占的空间会变大)

谨慎使用 static：如果只是想把函数定义写在头文件中，用 inline，不要用static。static 和 inline 不一样：

1. - static 的函数是 internal linkage。不同编译单元可以有同名的static 函数，但该函数只对对应的编译单元可见。如果同一定义的 static 函数，被不同编译单元调用，每个编译单元有自己单独的一份拷贝，且此拷贝只对对应的编译单元可见。
  - inline 的函数是 external linkage，如果被不同编译单元调用，每个编译单元引用／链接的是同一函数，同一定义。
  - 上面的不同直接导致：如果函数内有 static 变量，对inline 函数，此变量对不同编译单元是共享的（Meyer’s Singleton）；对于static 函数，此变量不是共享的。看后面的代码就明白区别了。

static inline 函数，跟 static 函数单独没有差别，所以没有意义，只会混淆视听。