基础篇 | 16 C++ 编程入门（七）虚函数

虚函数是C++当中非常重要的概念，它事实上是C++组装成完整程序当中最为重要的环节。如果大家不能理解虚函数是怎么工作的，能解决什么样的问题。这个事情是很麻烦，所以今天要我们来谈谈虚函数是怎么回事。

Virtual 的定义及作用

为了直观解释，我们先来看一段代码

// 定义基类
class BaseClass // 虚基类 // 接口类 // 接口
{
public:
    BaseClass(){};
    virtual ~BaseClass(){};

    virtual void PrintMyName() {
        // implement it
    } // 虚函数
    virtual void PrintYourName() = 0; // "纯"虚函数 -> 用于定义接口，没有对应实现
};

我们通过在函数前面加virtual这个keyword里定义虚函数，而最后一个函数我们定义了PrintYourName() = 0;称为“纯虚”函数。“纯”虚函数一般用于定义接口，没有对应的实现。

在Java或C#当中，我们一般这样定义接口：

 public interface BaseClass
 {
    public void MyFunction();
 }

我们会明确的使用interface去定义接口。但是在C++当中，我们只有一个标记class，我们用class来定义一个类，怎么知道这个类是不是一个接口呢，通常情况下我们通过纯虚函数来做。

如果BaseClass里存在一个纯虚函数，“Class* myPtr = new BaseClass();”这种写法是不可以的。

因为如果BassClass里面有一个虚函数，而虚函数没有对应实现，那么我们称BaseClass为虚基类。或称为接口类或接口。

纯虚函数是没有实现的，所以对象没办法初始化出来，new肯定是不行的。那如果遇到这种情况怎么办，我们可以定义它的子类SubClass.子类在接口PrintYourName（）做实现，我们就可以在子类创建对象 SubClass* myPtr = new SubClass（）;

那大家可能会有有两个疑问：

1. BaseClass中，PrintMyname()不是已经实现了吗？
   是的，但是PrintYourName是没有实现的，对于这个类来说，它是不完整的，如果它不完整，我们就不可以直接去初始化它。它是一个虚基类，通常情况下，这个设计不是我们编码的时候想要的设计，这样的设计是不好的。它有实现，又有没有实现，看起来就非常的奇怪，你说它到底是不是一个接口呢，很难定义，所以说这里有一个Practice，通常情况下，如果我们定义接口的话，不要去做任何的实现，全是等于0的，不要出现PrintMyname()这样的实现。

2. 一定要等于0吗？
   这是C++的语法，如果我们定义一个纯虚函数，一定要等于0。

Virtual 的应用技巧

接下来我们定义两个BaseClass的子类。

class SubClass : public BaseClass
{
public:
    SubClass(){};
    virtual ~SubClass(){};
    // add 'override' keyword
    virtual void PrintMyName() override {
        printf("I am SubClass\n");
    }
    virtual void PrintYourName()  override {
        // Do something
    }
};

class AnotherSubClass : public BaseClass
{
public:
    AnotherSubClass(){};
    virtual ~AnotherSubClass(){};
    virtual void PrintMyName() override{

        printf("I am AnotherSubClass\n");
    }
    virtual void PrintYourName() override {

    }
};

注意
这里面注意‘override’’这个关键字，‘override’是C++ 的标准之一，如果我们复写了父类的实现，尽可能的加override这样的标签。

接下来，我们定义两个函数，来看一下虚函数的使用。

void PrintMyName(BaseClass* base) {
    base->PrintMyName();
}

void LearnVirtualFuction()
{
    // 为什么要加virtual
    // RTTI 动态类型绑定 --> 我们引入一个新的概念：C++ 多态
    SubClass* sub = new SubClass();
    AnotherSubClass* anotherSub = new AnotherSubClass();
    PrintMyName(sub); // 会调用 SubClass 当中的PrintMyName()
    PrintMyName(anotherSub); // 会调用 AnotherSubClass 当中的PrintMyName()

    // clear up
    delete sub;
    delete anotherSub;
}

int main(int argc, const char * argv[]) {
    LearnVirtualFuction();
    return 0;
}

Prints:
*I am SubClass*
*I am AnotherSubClass*

我们为什么要加virtual，这也和RTTI动态类型绑定有关，我们到此引入了一个新的概念，C++的多态，它可以实现C++的多态，我们看到，虽然我们的函数要求传入的参数是BassClass * 类型，但是我们打印的结果是他们都调用类自己的PrintMyName而不是基类的。

如果我把BaseClass、SubClass、AnotherSubClass里面的virtual都去掉， 再调用PrintMyName它会全部调用基类里面的PrintMyName().没有virtual function，我们做不到这样的功能，所以virtual的功能一目了然，它让我们做到多态。

那这到底是为什么呢，它又是如何做到的呢，怎么进行动态类型绑定的呢？

Virtual 的运作原理

关于C++是如果利用Virtual做动态识别的，这里又设计到两个概念，虚指针和虚表。

对于C++程序来说，每当在程序里面定义一个Virtual，都会在程序的binary system当中创建虚表。虚表存储程序真正的内存地址。真正的函数放在另一个地方。

上图大致表现了C++是怎么去做动态识别的，一个是虚表、是个是虚指针。

虚指针在对象里面。不是类型。所以我们在调用对象的时候会找到对象的真正类型。当我们写SubClass* sub = new SubClass()的时候，调用SubClass的时候呢，C++会调用SubClass的构造函数。调用构造函数的时候C++会在程序当中隐式的去创建一个虚指针vptr。这个vptr就是虚指针。所以说我在调用构造函数之后才会去创造虚指针。而虚指针在对象里面。所以虽然我们在PrintMyName()里传进去的是SubClass类型。被隐式转换为BaseClass，但是它里面存的vptr仍然是SubClass的vptr。所以它会调用自己的PrintMyName，而不是基类的。

所以，如果我们使用了虚函数和RTTI，它的调用比普通函数要慢，因为要做一系列动态绑定和查找，但这个是可以接受的。普通的函数不需要查询，所以会快，为了搞这一套技术，C++有了虚函数、虚表、虚指针的概念，这一切的背后是RTTI，这个图是一个抽象，真正的过程比它还要复杂一些。但大致的流程不会有什么偏差，不同的编译器也大概是这样去处理。那gcc compiler ,gcc c++ ,clang,VC他们在处理虚函数上面有一些差别，特别是gcc会做一些优化，优化的事情咱们暂时不去谈，谈的话就太复杂了。大家就大概知道虚函数是这样一个东西，虚函数的机理大概是这个样子就可以了。

最后解释两个问题：

1. 为什么在析构函数前加virtual?
   C++规定，这样能够保证整个继承链上的的所有析构函数都能被调用，从而保证整个继承链上的所有数据都能被销毁。
2. 我们可以在构造函数前加virtual吗?
   我们在一个对象成功创建了之后（new）才创建了虚指针，那如果构造函数都是虚的，那虚指针从哪来呢，所以，构造函数一定不能加virtual。

---