C++中内联函数的作用以及与宏代码的区别

内联函数的定义

C++中支持内联函数，其目的是为了提高函数的执行效率，用关键字 inline 放在函数定义（非声明）的前面即可将函数指定为内联函数，内联函数通常就是将它在程序中的每个调用点上“内联地”展开。

内联函数的作用

1、内联函数在编译时直接将函数体插入函数调用的地方。
2、inline只是一种请求，编译器不一定允许这种请求。
3、内联函数省去了普通函数调用时压栈，跳转和返回的开销。
4、内联函数在编译阶段不能生成符号，所以只有本文件可见，功能类似与static函数，但是static修饰的函数会产生本地的符号。内联函数和静态函数的定义一般可以放在头文件，但不能将内联函数的定义和内联函数的使用放在不同的源文件中。
5、内联只在release版本起作用，在debug版本不起作用，目的是为了方便调试。
6、与宏替换作用一样，只是内联发生在编译阶段、宏替换发生在预处理阶段，而且内联函数会做类型检查，但宏替换只是做简单地字符替换，并不会做类型检查。

内联函数的使用

假设我们将max函数定义为内联函数：
代码如下:

inline int max(int a, int b){     return a > b ? a : b;}

则调用： cout<<max(a, b)<<endl;
在编译时展开为： cout<<(a > b ? a : b)<<endl;
从而消除了把 max写成函数的额外执行开销。

内联函数与宏代码的区别

C++中用内联取代宏代码。
在 C 程序中，可以用宏代码提高执行效率。宏代码本身不是函数，但使用起来象函数。预处理器用复制宏代码的方式代替函数调用，省去了参数压栈、生成汇编语言的CALL 调用、返回参数、执行return 等过程，从而提高了速度。使用宏代码最大的缺点是容易出错，预处理器在复制宏代码时常常产生意想不到的边际效

#define MAX(a, b) (a) > (b) ? (a) :(b)result = MAX(i, j) + 2 ;

处理器解释为

result = (i) > (j) ? (i) : (j) + 2 ;

由于运算符‘+’比运算符‘:’的优先级高，所以上述语句并不等价于期望的

result = ( (i) > (j) ? (i) : (j) ) + 2 ;

如果把宏代码改写为

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )

则可以解决由优先级引起的错误。但是即使使用修改后的宏代码也不是万无一失的，例
如语句

result = MAX(i++, j);

将被预处理器解释为

result = (i++) > (j) ? (i++) : (j);

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

让我们看看C++ 的“函数内联”是如何工作的。对于任何内联函数，编译器在符号表里放入函数的声明（包括名字、参数类型、返回值类型）。如果编译器没有发现内联函数存在错误，那么该函数的代码也被放入符号表里。在调用一个内联函数时，编译器首先检查调用是否正确（进行类型安全检查，或者进行自动类型转换，当然对所有的函数都一样）。如果正确，内联函数的代码就会直接替换函数调用，于是省去了函数调用的开销。这个过程与预处理有显著的不同，因为预处理器不能进行类型安全检查，或者进行自动类型转换。假如内联函数是成员函数，对象的地址（this）会被放在合适的地方，这也是预处理器办不到的。
C++ 语言的函数内联机制既具备宏代码的效率，又增加了安全性，而且可以自由操作类的数据成员。所以在C++ 程序中，应该用内联函数取代所有宏代码，“断言assert”恐怕是唯一的例外。assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发生的情况。为了不在程序的Debug 版本和Release 版本引起差别，assert 不应该产生任何副作用。如果assert 是函数，由于函数调用会引起内存、代码的变动，那么将导致Debug版本与Release 版本存在差异。所以assert 不是函数，而是宏。

内联函数的编程风格

关键字 inline 必须与函数定义体放在一起才能使函数成为内联，仅将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 关键字，但我认为inline 不应该出现在函数的声明中。这个细节虽然不会影响函数的功能，但是体现了高质量C++/C 程序设计风格的一个基本原则：声明与定义不可混为一谈，用户没有必要、也不应该知道函数是否要内联。
定义在类声明之中的成员函数将自动地成为内联函数，例如

class A{public:    void Foo(int x, int y) { … } // 自动地成为内联函数}

将成员函数的定义体放在类声明之中虽然能带来书写上的方便，但不是一种良好的编程
风格，上例应该改成：

// 头文件class A{public:    void Foo(int x, int y)；}// 定义文件inline void A::Foo(int x, int y){    …}

但是编译器是否将它真正内联则要看 Foo函数如何定义

内联函数应该在头文件中定义，这一点不同于其他函数。编译器在调用点内联展开函数的代码时，必须能够找到 inline 函数的定义才能将调用函数替换为函数代码，而对于在头文件中仅有函数声明是不够的。

当然内联函数定义也可以放在源文件中，但此时只有定义的那个源文件可以用它，而且必须为每个源文件拷贝一份定义(即每个源文件里的定义必须是完全相同的)，当然即使是放在头文件中，也是对每个定义做一份拷贝，只不过是编译器替你完成这种拷贝罢了。但相比于放在源文件中，放在头文件中既能够确保调用函数是定义是相同的，又能够保证在调用点能够找到函数定义从而完成内联(替换)。

但是你会很奇怪，重复定义那么多次，不会产生链接错误？

我们来看一个例子：

A.h
代码如下:

class A{public:     A(int a, int b) : a(a),b(b){}     int max();private:     int a;     int b;};

A.cpp
代码如下:

#include "A.h"inline int A::max(){     return a > b ? a : b;}

Main.cpp :
代码如下:

#include <iostream>#include "A.h"using namespace std;inline int A::max(){ return a > b ? a : b;}int main(){     A a(3, 5);     cout<<a.max()<<endl;     return 0;}

一切正常编译，输出结果：5

倘若你在Main.cpp中没有定义max内联函数，那么会出现链接错误：

error LNK2019: 无法解析的外部符号 "public: int __thiscall A::max(void)" (?max@A@@QAEHXZ)，该符号在函数 _main 中被引用

找不到函数的定义，所以内联函数可以在程序中定义不止一次，只要 inline 函数的定义在某个源文件中只出现一次，而且在所有源文件中，其定义必须是完全相同的就可以。

在头文件中加入或修改 inline 函数时，使用了该头文件的所有源文件都必须重新编译。

慎用内联

内联能提高函数的执行效率，为什么不把所有的函数都定义成内联函数？如果所有的函数都是内联函数，还用得着“内联”这个关键字吗？

内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。以下情况不宜使用内联：
（1）如果函数体内的代码比较长，使用内联将导致内存消耗代价较高。
（2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
类的构造函数和析构函数容易让人误解成使用内联更有效。要当心构造函数和析构函数可能会隐藏一些行为，如“偷偷地”执行了基类或成员对象的构造函数和析构函数。所以不要随便地将构造函数和析构函数的定义体放在类声明中。
一个好的编译器将会根据函数的定义体，自动地取消不值得的内联（这进一步说明了inline 不应该出现在函数的声明中）。

而在Google C++编码规范中则规定得更加明确和详细：

（1）只有当函数只有 10 行甚至更少时才将其定义为内联函数。

定义: 当函数被声明为内联函数之后，编译器会将其内联展开，而不是按通常的函数调用机制进行调用。
优点: 当函数体比较小的时候，内联该函数可以令目标代码更加高效。 对于存取函数以及其它函数体比较短，性能关键的函数，鼓励使用内联。
缺点: 滥用内联将导致程序变慢。内联可能使目标代码量或增或减，这取决于内联函数的大小。内联非常短小的存取函数通常会减少代码大小，但内联一个相当大的函数将戏剧性的增加代码大小。现代处理器由于更好的利用了指令缓存，小巧的代码往往执行更快。
结论: 一个较为合理的经验准则是, 不要内联超过 10 行的函数。谨慎对待析构函数, 析构函数往往比其表面看起来要更长， 因为有隐含的成员和基类析构函数被调用！
另一个实用的经验准则：内联那些包含循环或 switch 语句的函数常常是得不偿失 (除非在大多数情况下，这些循环或 switch 语句从不被执行)。
有些函数即使声明为内联的也不一定会被编译器内联，这点很重要；比如虚函数和递归函数就不会被正常内联。通常， 递归函数不应该声明成内联函数.(递归调用堆栈的展开并不像循环那么简单，比如递归层数在编译时可能是未知的， 大多数编译器都不支持内联递归函数)。 虚函数内联的主要原因则是想把它的函数体放在类定义内，为了图个方便，抑或是当作文档描述其行为，比如精短的存取函数。
（2） 复杂的内联函数的定义， 应放在后缀名为 -inl.h 的头文件中。

内联函数的定义必须放在头文件中， 编译器才能在调用点内联展开定义。然而，实现代码理论上应该放在 .c 文件中，我们不希望 .h 文件中有太多实现代码，除非在可读性和性能上有明显优势。

如果内联函数的定义比较短小，逻辑比较简单， 实现代码放在 .h 文件里没有任何问题。比如，存取函数的实现理所当然都应该放在类定义内。 出于编写者和调用者的方便，较复杂的内联函数也可以放到 .h 文件中，如果你觉得这样会使头文件显得笨重， 也可以把它萃取到单独的 -inl.h 中。 这样把实现和类定义分离开来，当需要时包含对应的 -inl.h 即可。

参考：http://blog.csdn.net/u011327981/article/details/50601800
http://blog.csdn.net/hyqsong/article/details/51857833
继续学习：
http://blog.csdn.net/forarrow/article/details/6394931
http://www.runoob.com/cplusplus/cpp-inline-functions.html
http://blog.csdn.net/coder_xia/article/details/6723387
http://blog.csdn.net/a623891391/article/details/50612316
http://blog.csdn.net/shltsh/article/details/45941169