this指针、inline

this 指针

1. this 指针是一个隐含于每一个非静态成员函数中的特殊指针。它指向正在被该成员函数操作的那个对象。
2. 当对一个对象调用成员函数时，编译程序先将对象的地址赋给 this 指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含使用 this 指针。
3. 当一个成员函数被调用时，自动向它传递一个隐含的参数，该参数是一个指向这个成员函数所在的对象的指针。
4. this 指针被隐含地声明为: ClassName *const this，这意味着不能给 this 指针赋值；在 ClassName 类的 const 成员函数中，this 指针的类型为：const ClassName* const，这说明不能对 this 指针所指向的这种对象是不可修改的（即不能对这种对象的数据成员进行赋值操作）；
5. this 并不是一个常规变量，而是个右值，所以不能取得 this 的地址（不能 &this）。
6. 在以下场景中，经常需要显式引用 this 指针：
   a. 为实现对象的链式引用；
   b. 为避免对同一对象进行赋值操作；
   c. 在实现一些数据结构时，如 list。
7. this指针的使用：一种情况就是，在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this；

inline 内联函数

特征：

1. 相当于把内联函数里面的内容写在调用内联函数处（代码扩展），但inline只是对编译器的建议，是否执行要看编译器的选择；
2. 相当于不用执行进入函数的步骤（不进堆栈），直接执行函数体；
3. 相当于宏，却比宏多了类型检查，真正具有函数特性；
4. 不能包含循环、递归、switch等复杂操作；
5. 在类声明中定义的函数，除了虚函数的其他函数都会自动隐式地当成内联函数；
   使用：

// 声明1（加 inline，建议使用，且建议内联函数的定义放在头文件内）
inline int functionName(int first, int secend,...);
// 声明2（不加inline）
int functionName(int first, int second,...);
// 定义
inline int funcionName(int first, int seconde,...){/********/}; // inline要与定义放在一起才起作用，若只是和声明放在一起无所用

// 类内定义，隐式内联
class A{
    int doA() {return 0;}        // 隐式内联
}

// 类外定义，需要显示内联
class A{
    int doA();
}
inline int A::doA(){ return 0;}  // 需要显示内联，建议类外定义？形成统一的代码风格？

编译器对 inline 函数的处理步骤：

1. 将 inline 函数体复制到 inline 函数调用点处；
2. 为所用 inline 函数中的局部变量分配内存空间；
3. 将 inline 函数的输入参数和返回值映射到调用方法的局部变量空间中；
4. 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用GOTO）。？？？？？？？？

优缺点：

优点：

1. 内联函数同宏函数一样将在被调用出进行代码展开，省去了参数压栈，栈帧开辟与回收，结果返回等，从而提高程序运行速度；
2. 内联函数相比于红函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而宏定义则不会；
3. 在类中声明同时定义的成员函数，自动转换为内联函数，因此内联函数可以访问类的成员变量，而宏不能；
4. 内联函数在运行时可调试，而宏定义不可以；

缺点：

1. 代码膨胀。内联是以代码膨胀（复制）为代价，消除函数调用的开销。若执行函数体内代码的时间，相比于函数调用的开销较大，那效率反倒不高。2. 另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间；
2. inline 函数无法随着函数库升级而升级。inline 函数的改变需要重新编译， 不像 non-inline 可以直接链家；
   是否内联，程序员不可控。内联函数只是对编译器的建议，是否对函数内联，决定权在于编译器；

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

1. 虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联；
2. 内联是在编译期建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联；
3. inline virtual 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如Base::who()），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
   虚函数内联使用：

#include <iostream>  
using namespace std;
class Base
{
public:
    inline virtual void who() { cout<< "I am Base\n"; }
    virtual ~Base() {}
};
class Derived:public Base
{
public:
    inline void who()                  // 不写inline时隐式内联
    {
        cout<< " I am Derived\n";
    }
};

int main()
{
    Base b;         // 此处的虚函数who(), 是通过类（Base）的具体对象 b 来调用的，在编译期就可以确定
    b.who();        // 所以它可以是内联的，但最终是否内联取决于编译器；
    
    Base *ptr = new Derive();  // 此处的虚函数是通过指针调用的，呈现多态性
    ptr->who();                // 需要在运行期间才能确定，所以不能内联
    
    delete ptr;     // 因为 Base 有虚析构函数（virtual ~Base(){}），所以 delete 时，会先调用派生类(Derived)析构函数
    ptr = nullptr;  // 再调用基类(Base)析构函数，防止内存泄漏；
    
    system("pause");
    return 0;
}

【参考文献】
https://www.cnblogs.com/fnlingnzb-learner/p/6423917.html