inline的作用

1、引入 inline 关键字的原因

在 c/c++ 中，为了解决一些频繁调用的小函数大量消耗栈空间（栈内存）的问题，特别的引入了 inline 修饰符，表示为内联函数。inline 只适合涵数体内代码简单的涵数使用，不能包含复杂的结构控制语句例如 while、switch，并且不能内联函数本身不能是直接递归函数（即，自己内部还调用自己的函数）。

#include 
 
inline const char *num_check(int v)
{
    return (v % 2 > 0) ? "奇" : "偶";
}
 
int main(void)
{
    int i;
    for (i = 0; i < 100; i++)
        printf("%02d   %s\n", i, num_check(i));
    return 0;
}

在内部的工作就是在每个 for 循环的内部任何调用 num_check(i) 的地方都换成了 (i%2>0)?"奇":"偶"，这样就避免了频繁调用函数对栈内存重复开辟所带来的消耗。

2. inline是用于实现的关键字

inline 函数仅仅是一个对编译器的建议，所以最后能否真正内联，看编译器的意思，它如果认为函数不复杂，能在调用点展开，就会真正内联，并不是说声明了内联就会内联，声明内联只是一个建议而已。

其次，因为内联函数要在调用点展开，所以编译器必须随处可见内联函数的定义，要不然就成了非内联函数的调用了。所以，这要求每个调用了内联函数的文件都出现了该内联函数的定义。因此，将内联函数的定义放在头文件里实现是合适的，省却你为每个文件实现一次的麻烦。

最后，定义在类中的成员函数默认都是内联的，如果在类定义时就在类内给出函数定义，那当然最好。

如果在类中未给出成员函数定义，而又想内联该函数的话，需要在类的头文件.h中定义这个函数，不能在相应的.cpp文件中定义。
因为内联函数要在调用点展开，所以编译器必须随处可见内联函数的定义，要不然就成了非内联函数的调用了。所以，这要求每个调用了内联函数的文件都出现了该内联函数的定义。
即，头文件中这样的写法

class Account {
public:
Account(double initial_balance) { balance = initial_balance; } //与1相同
double GetBalance(); //在类中声明
double Deposit( double Amount );
double Withdraw( double Amount );
private:
double balance;
};
inline double Account::GetBalance() { return balance; } //在类外定义时添加inline关键字
inline double Account::Deposit( double Amount ) { return ( balance += Amount ); }
inline double Account::Withdraw( double Amount ) { return ( balance -= Amount ); }

如果在.cpp文件中，就需要很危险的操作来完成内联，比如这样（极为不推荐）
//SomeInline.h中
#ifndef SOMEINLINE_H
#define SOMEINLINE_H
Type Example(void);
//........其他函数的声明
#include"SomeInlie.cpp" //源文件被包含进来了……
#endif
//SomeInline.cpp中
#include"SomeInline.h"
inline Type Example(void)
{
//..........
}
//...............其他函数的定义

3. 用法

关键字 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 程序设计风格的一个基本原则：声明与定义不可混为一谈，用户没有必要、也不应该知道函数是否需要内联。

4. 作用

内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。 
如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。

以下情况不宜使用内联： 
（1）如果函数体内的代码比较长，使用内联将导致内存消耗代价较高。 
（2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。类的构造函数和析构函数容易让人误解成使用内联更有效。要当心构造函数和析构函数可能会隐藏一些行为，如"偷偷地"执行了基类或成员对象的构造函数和析构函数。所以不要随便地将构造函数和析构函数的定义体放在类声明中。一个好的编译器将会根据函数的定义体，自动地取消不值得的内联（这进一步说明了 inline 不应该出现在函数的声明中）。

只有当函数非常短小的时候它才能得到我们想要的效果；但是，如果函数并不是很短而且在很多地方都被调用的话，那么将会使得可执行体的体积增大。

5.思考

在重构老代码时候，提取函数是常用的技法，但是频繁增加函数会显著提高栈占用，这个时候使用inline函数，会在美观性和性能中取得一个比较好的折衷点。

6. 原理

函数是将程序执行转移到被调用函数所存放的内存地址，将函数执行完后，在返回到执行此函数前的地方。这种转移操作需要保护现场、包括进栈等操作，在被调用函数代码执行完后，再恢复现场。但是保护现场和恢复现场需要较大的资源开销。对于一些较小的调用函数来说，若是频繁调用，函数调用过程甚至可能比函数执行过程需要的系统资源更多。所以引入内联函数，编译器会把内联函数的函数体嵌入到每一个调用了它的地方，以代码段的膨胀代替调用栈的开销。

7. 更深的领悟

更深的领悟就是我在.h的类定义中声明了成员函数，在.cpp的实现中加入了inline关键词，会有坑出现。
编译器不断报错，“无法解析的外部符号”，因为有的cpp展开了，有的cpp没看到定义，就没有展开，就报错了
//a.h -----------------
#pragma once

class a
{
public:
    a() {}
    ~a() {}
    void hello();

private:

};
//a.cpp -----------------
#include
#include "a.h"
/* void a::hello() */
inline void a::hello()
{
    std::cout<<"hello"< }
//b.cpp------------------
#include "a.h"
#include

int main()
{
    a x;
    x.hello();
    std::cout << "Hello world" << std::endl;
    return 0;
}