C++中内联函数——inline

在大多数机器上，调用函数要做很多工作：调用前要保存寄存器，并在返回时恢复、复制实参，程序还必须转向一个新位置执行。
C++中支持内联函数，其目的是为了解决程序中函数调用问题，提高函数执行效率，用关键字inline放在函数定义的前面可将函数指定为内联函数。

关键字inline必须放在函数定义前面才能使函数成为内联，放在声明前面不起任何作用。
头文件中声明方法：

class A
{
public:
    void f1(int x); 

    /**
     * @brief 类中定义了的函数是隐式内联函数,声明要想成为内联函数，必须在实现处(定义处)加inline关键字。
     *
     * @param x
     * @param y
     */
    void Foo(int x,int y) ///< 定义即隐式内联函数！
    {

    };
    void f1(int x); ///< 声明后，要想成为内联函数，必须在定义处加inline关键字。  
};

实现文件中定义内联函数：

#include <iostream>
#include "inline.h"

using namespace std;

/**
 * @brief inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字”
 *
 * @param x
 * @param y
 *
 * @return 
 */
int Foo(int x,int y);  // 函数声明
inline int Foo(int x,int y) // 函数定义
{
    return x+y;
}

// 定义处加inline关键字，推荐这种写法！
inline void A::f1(int x){

}

int main()
{


    cout<<Foo(1,2)<<endl;

}
/**
 * 编译器对 inline 函数的处理步骤
 * 将 inline 函数体复制到 inline 函数调用点处；
 * 为所用 inline 函数中的局部变量分配内存空间；
 * 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
 * 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。
 */

内联函数能提高函数效率，但并不是所有的函数都可以定义成内联函数！内联函数是以代码膨胀（复制）为代价，仅只是省去了函数调用的开销，从而提高函数的执行效率。

• 如果执行函数体内代码的时间相比于函数调用的开销较大，那么效率的收获会更少。
• 每一处内联函数的调用都要复制代码，使程序的总代码量增大，消耗更多的内存空间。
  下列情况不宜用内联：
• 若函数体代码较长，则内存消耗较高
• 若函数体内存在循环，则执行函数体内代码时间要长于函数调用。

虚函数可以是内联函数吗？

• 虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能用内联。
• 内联在编译期间由编译器内联 虚函数多态性在运行期 编译器无法知道运行期调用哪个代码 所以不可内联
• 虚函数唯一可内敛的时机为：编译器知道所调用的对象是哪个类，仅只在编译器具有实际对象而不是对象的指针或引用时才会发生。

# include <iostream>
using namespace std;

class Base {
public:
	//构造函数
	inline virtual void who() {
		cout << "I am Base!" << endl;
	}
	//析构函数
	virtual ~Base() {

	}
};

class Device : public Base {
public:
	inline void who() {
		cout << "I am Device!" << endl;
	}
};

int main() {
	Base b; //此处的虚函数who通过Base的具体对象调用 编译期间就能确定
	b.who();//但是否内联取决于编译器

	Base* ptr = new Device();//此处的虚函数通过指针调用 呈现多态性 需在运行期间确定
	ptr->who();//所以不能内联

	delete ptr;
	ptr = nullptr;

	cin.get();
	return 0;
}

/*
总结：
	1、虚函数可以是内联函数，内联可修饰虚函数，但当虚函数表现多态时不能内联
	2、内联在编译期间由编译器内联 虚函数多态性在运行期 编译器无法知道运行期调用哪个代码 所以不可内联
	3、inline virtual唯一可以内联的时候是编译器知道所调用的对象时那个类（如Base::b）在编译器具有实际对象而非指针和引用时才会发生
*/