C++ inline函数简介

inline 简介

       inline 函数由 inline 关键字定义，引入 inline 函数的主要原因是用它替代 C 中复杂易错不易维护的宏函数。

编译器对 inline 函数的处理办法

       编译器在编译阶段完成对 inline 函数的处理，即对 inline 函数的调用替换为函数的本体。但 inline 关键字对编译器只是一种建议，编译器可以这样去做，也可以不去做。从逻辑上来说，编译器对 inline 函数的处理步骤一般如下：
       （1）将 inline 函数体复制到inline函数调用处；
       （2）为所用 inline 函数中的局部变量分配内存空间；
       （3）将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
       （4）如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用GOTO）。
       比如如下代码：

//求0-9的平方
inline int inlineFunc(int num)
{  
    if(num > 9 || num < 0)
    {
        return -1;  
    }
    return num*num;  
}  

int main()
{
    int a=8;
    int res=inlineFunc(a);
    cout << "res:" << res << endl;
}

       inline 之后的 main 函数代码类似于如下形式：

int main()
{
    int a = 8;
    {  
        int _temp_b = 8;  
        int _temp;  
        if(_temp_b > 9 || _temp_b < 0) _temp = -1;  
        else _temp =_temp*_temp;  
        b = _temp;  
    }
}

       经过以上处理，可消除所有与调用相关的痕迹以及性能的损失。inline 通过消除调用开销来提升性能。

inline 函数使用的一般方法

       函数定义时，在返回类型前加上关键字 inline 即把函数指定为内联，函数申明时可加也可不加。但是建议函数申明的时候，也加上 inline，这样能够达到“代码即注释”的作用。
       使用格式如下：

inline int functionName(int first, int secend,...) {/****/};

       inline 如果只修饰函数的申明的部分，如下风格的函数foo不能成为内联函数：

inline void foo(int x, int y); //inline仅与函数声明放在一起
void foo(int x, int y) {}

       而如下风格的函数foo 则成为内联函数：

void foo(int x, int y);
inline void foo(int x, int y) {} //inline与函数定义体放在一起

inline 函数的优点与缺点

       从上面可以知道，inline 函数相对宏函数有如下优点：
       （1）内联函数同宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度。
       （2）内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而宏定义则不会。
       例如宏函数和内联函数：

//宏函数
#define MAX(a，b) ((a)>(b)?(a):(b))

//内联函数
inline int MAX(int a，int b)
{
    return a>b?a:b；
}

       使用宏函数时，其书写语法也较为苛刻，如果对宏函数出现如下错误的调用，MAX(a,"Hello") 宏函数会错误地比较int和字符串，没有参数类型检查，但是使用内联函数的时候，会出现类型不匹配的编译错误。
       （3）在类中声明同时定义的成员函数，自动转化为内联函数，因此内联函数可以访问类的成员变量，宏定义则不能。
       （4）内联函数在运行时可调试，而宏定义不可以。
       万事万物都有阴阳两面，内联函数也不外乎如此，使用 inline 函数，也要三思慎重。inline 函数的缺点总结如下：
       （1）代码膨胀。inline 函数带来的运行效率是典型的以空间换时间的做法。内联是以代码膨胀（复制）为代价，消除函数调用带来的开销。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
       （2）inline 函数无法随着函数库升级而升级。如果f是函数库中的一个 inline 函数，使用它的用户会将f函数实体编译到他们的程序中。一旦函数库实现者改变f，所有用到f的程序都必须重新编译。如果f是 non-inline 的，用户程序只需重新连接即可。如果函数库采用的是动态连接，那这一升级的f函数可以不知不觉的被程序使用。
       （3）是否内联，程序员不可控。inline 函数只是对编译器的建议，是否对函数内联，决定权在于编译器。编译器认为调用某函数的开销相对该函数本身的开销而言微不足道或者不足以为之承担代码膨胀的后果则没必要内联该函数，若函数出现递归，有些编译器则不支持将其内联。

inline 函数的注意事项

       了解了内联函数的优缺点，在使用内联函数时，我们也要注意以下几个事项和建议。
       （1）使用函数指针调用内联函数将会导致内联失败。也就是说，如果使用函数指针来调用内联函数，那么就需要获取 inline 函数的地址。如果要取得一个 inline 函数的地址，编译器就必须为此函数产生一个函数实体，那么就内联失败。
       （2）如果函数体代码过长或者有多重循环语句，if或witch分支语句或递归时，不宜用内联。
       （3）类的 constructors、destructors 和虚函数往往不是 inline 函数的最佳选择。类的构造函数（constructors）可能需要调用父类的构造函数，析构函数同样可能需要调用父类的析构函数，二者背后隐藏着大量的代码，不适合作为 inline 函数。虚函数（destructors）往往是运行时确定的，而 inline 是在编译时进行的，所以内联虚函数往往无效。如果直接用类的对象来使用虚函数，那么对有的编译器而言，也可起到优化作用。
       （4）至于内联函数是定义在头文件还是源文件的建议。内联展开是在编译时进行的，只有链接的时候源文件之间才有关系。所以内联要想跨源文件必须把实现写在头文件里。如果一个 inline 函数会在多个源文件中被用到，那么必须把它定义在头文件中。

// base.h
class Base { protected: void fun(); };

// base.cpp
#include base.h
inline void Base::fun() {}

//derived.h
#include base.h
class Derived : public Base { public:void g(); };

// derived.cpp
void Derived::g() { fun(); } //VC2010: error LNK2019: unresolved external symbol

       上面这种错误，就是因为内联函数 fun() 定义在编译单元 base.cpp 中，那么其他编译单元中调用fun()的地方将无法解析该符号，因为在编译单元 base.cpp 生成目标文件 base.obj 后，内联函数fun()已经被替换掉，编译器不会为 fun() 生成函数实体，链接器自然无法解析。所以如果一个 inline 函数会在多个源文件中被用到，那么必须把它定义在头文件中。
       这里有个问题，当在头文件中定义内联函数，那么被多个源文件包含时，如果编译器因为 inline 函数不适合被内联时，拒绝将 inline 函数进行内联处理，那么多个源文件在编译生成目标文件后都将各自保留一份 inline 函数的实体，这个时候程序在链接阶段会出现重定义错误吗？答案是不会，原因是，链接器在链接的过程中，会删除多余的 inline 函数实体，只保留一份，所以不会报重定义错误，因此我们不需要使用 static 关键字去多余地修饰 inline 函数，即不必像下面这样。

//test.h
static inline int max(int a, int b)
{
    return a > b ? a : b;
}

       （5）能否强制编译器进行内联操作？也有人可能会觉得能否强制编译器进行函数内联，而不是建议编译器进行内联呢？很不幸的是目前还不能强制编译器进行函数内联，如果使用的是 MS VC++，注意 __forceinline 如同 inine 一样，也是一个用词不当的表现，它只是对编译器的建议比 inline 更加强烈，并不能强制编译器进行 inline 操作。
       （6）如何查看函数是否被内联处理了？在 VS2017 中查看预处理后的.i文件，发现 inline 函数的内联处理不是在预处理阶段，而是在编译阶段。将源文件编译为汇编代码，或者将可执行文件反汇编生成汇编代码，在汇编代码中查看 inline 函数被调用处是否出现汇编的call指令，如果没有则说明 inline 函数在被调用处进行了函数体的替换操作，即内联处理。具体可以参考内联函数到底有没有被嵌入到调用处呢？
       （7）C++类成员函数定义在类体内为什么不会报重定义错误？
       类成员函数定义在类体内，并随着类的定义放在头文件中，当被不同的源文件包含，那么每个源文件都应该包含了类成员函数的实体，为何在链接的过程中不会报函数的重定义错误呢？
       原因是在类里定义时，这种函数会被编译器编译成内联函数，在类外定义的函数则不会。内联函数的好处是加快程序的运行速度，缺点是会增加程序的尺寸。比较推荐的写法是把一个经常要用的而且实现起来比较简单的小型函数放到类里去定义，大型函数最好还是放到类外定义。
       可能存在疑问，类体内的成员函数被编译器内联处理，但并不是所有的成员函数都会被内联处理，比如包含递归的成员函数。但是实际测试，将包含递归的成员函数定义在类体内，被不同的源文件包含并不会报重定义错误，为什么会这样呢？请保持着疑问与好奇心，请继续往下看。
       如果编译器发现被定义在类体内的成员函数无法被内联处理，那么在程序的链接过程中也不会出现函数重定义的错误。其原因是什么呢？其实很简单，类体内定义的成员函数即使不被内联处理，在链接时，链接器会对重复的成员函数实体进行冗余优化，只保留一份函数实体，也就不会出现函数重定义的错误了。
       除了 inline 函数，C++编译器在很多时候都会产生重复的代码，比如模板（Templates）、虚函数表（Virtual Function Table）、类的默认成员函数（构造函数、析构函数和赋值运算符）等。以函数模板为例，在多个源文件中生成相同的实例，链接时不会出现函数重定义的错误，实际上是一个道理，因为链接器会对重复代码进行删除，只保留一份函数实体。

小结

       可以将内联理解为 C++ 中对于函数专有的宏，对于 C 的函数宏的一种改进。对于常量宏，C++ 提供 const 替代；而对于函数宏，C++ 提供的方案则是 inline。C++ 的内联机制，既具备宏代码的效率，又增加了安全性，还可以自由操作类的数据成员，算是一个比较完美的解决方案。