[C++] 多态机制的实现原理之虚函数表

什么是多态？

程序运行时，父类指针可以根据具体指向的子类对象，来执行不同的函数

虚函数实现多态

• 每一个有虚函数的类（或者有虚函数的类的派生类）都有一个虚函数表
• 虚函数表占4个字节
• 类对象存储空间的最前端存放的就是虚函数表的指针
• 该类的任何对象中都放着虚函数表的指针，vptr指针
• 虚函数表是编译器生成的，程序运行时被载入内存
• 一个类的虚函数表中列出了该类的全部虚函数地址

举例

#include <iostream>
using namespace std;
class A {
public:
    int i;
    //父类虚函数必须要有virtual关键字
    virtual void func() {
        cout << "father" << endl;
    }
    virtual void func2() {}
};
class B : public A {
    int j;
    void func() {
        cout << "son" << endl;
    }
};
int main() {
    A* a = nullptr;//父类指针
    A father;//父类对象
    B son;//子类对象
    a = &father;//父类指针指向父类对象
    a -> func();//执行父类的func函数
    a = &son;//父类指针指向子类对象
    a -> func();//执行子类的func函数
    return 0;
}

输出结果：

当传入父类对象时，执行父类的成员函数；当传入子类对象时，指向子类成员函数

father
son

多态的函数调用语句被编译成根据基类指针（或基类引用）所指向的对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的一系列指令

• 比如说有一个父类指针a要调用虚函数func()函数
• 取出父类指针所指位置的前4个字节（对象所属类的虚函数表的地址，也就是虚函数表指针），如果父类指针指向的是类A的对象，则这个地址就是类A的虚函数表的地址，如果父类指针指向的是类B的对象，则这个地址就是类B的虚函数表的地址
• 根据虚函数表的地址就找到了虚函数表，在虚函数表中以函数名为索引，查找要调用的虚函数的地址
• 根据找到的虚函数的地址调用虚函数

多态机制能够提高程序的开发效率，但也增加了程序运行时的开销

• 虚函数表，各个类对象中包含的4个字节的虚函数表的地址都是空间上额外的开销
• 查虚函数表的过程是时间上的额外开销

父类的构造函数中调用虚函数会发生多态吗

#include <iostream>

using namespace std;

class Parent {
 public:
  Parent() {
    // 父类的构造方法中执行虚函数，会发生多态吗？
    fun();
  }
  virtual void fun() { cout << "父类" << endl; }
};
class Child : public Parent {
 public:
  Child() { fun(); }
  void fun() { cout << "子类" << endl; }
};

int main() {
  Child c;
  return 0;
}

输出：

创建子类对象时，会先创建父类对象，父类构造函数中调用虚函数fun()，执行的是父类的fun()函数，并没有发生多态。

父类构造函数中调用虚函数，不会发生多态，跟虚函数表指针分步初始化有关。

父类
子类

虚函数表指针vptr分步初始化

从上面例子，创建子类对象时，编译器的执行顺序：

• 对象在创建时，由编译器对虚函数表指针进行初始化
• 子类构造函数先调用父类构造函数，这个时候虚函数表指针先指向父类的虚函数表
• 子类构造的时候，虚函数表指针再指向子类的虚函数表
• 对象创建完成之后，虚函数表指针最终的指向才确定

为什么存在继承的时候，析构函数要写成虚函数

构造函数的调用顺序：自上而下

• 当建立一个对象时，首先调用基类的构造函数，然后调用下一个派生类的构造函数，依次类推，直至到达最底层目标派生类的构造函数

析构函数的调用顺序：自下而上

• 当删除一个对象时，首先调用该派生类的析构函数，然后调用上一层基类的析构函数，依次类推，直到到达最顶层的基类析构函数

代码演示

#include <iostream>
using namespace std;
class Base {
 public:
  Base() { cout << "创建Base基类。" << endl; }
  ~Base() { cout << "删除Base基类。" << endl; }
};
class Child : public Base {
 public:
  Child() { cout << "创建Child派生类。" << endl; }
  ~Child() { cout << "删除Child派生类。" << endl; }
};

int main() {
  cout << "*********构造函数调用顺序示例***********" << endl;
  Child *C1 = new Child;//派生类指针指向派生类对象
  cout << "*********析构函数调用顺序示例***********" << endl;
  delete C1;
}

• 输出结果

  创建Base基类。
  创建Child派生类。
  *********析构函数调用顺序示例***********
  删除Child派生类。
  删除Base基类。
  

虚析构函数的作用

通过基类指针来删除派生类对象时，基类的析构函数应该是虚函数

• 在公有继承中，基类对派生类及其对象的操作，只能影响到那些从基类继承下来的成员。如果要用基类对继承成员进行操作，则要把基类的这个成员函数定义为虚函数，析构函数同样需要如此。
• 如果要用基类指针来删除派生类的对象，而这个基类有一个非虚的析构函数。后果是对象的派生部分不会被销毁。然而基类部分被销毁了，将导致内存泄露。

基类析构函数不是虚函数，则析构的时候子类对象没有析构

#include <iostream>
using namespace std;
class Base {
 public:
  Base() { cout << "创建Base基类。" << endl; }
  ~Base() { cout << "删除Base基类。" << endl; }  //析构函数不是虚函数
};
class Child : public Base {
 public:
  Child() { cout << "创建Child派生类。" << endl; }
  ~Child() { cout << "删除Child派生类。" << endl; }
};

int main() {
  cout << "*********构造函数调用顺序示例***********" << endl;
  Base *C1 = new Child;//基类指针指向派生类对象
  cout << "*********析构函数调用顺序示例***********" << endl;
  delete C1;
}

• 输出结果

  *********构造函数调用顺序示例***********
  创建Base基类。
  创建Child派生类。
  *********析构函数调用顺序示例***********
  删除Base基类。
  

基类析构函数是虚函数，子类对象和父类对象都被析构

#include <iostream>
using namespace std;
class Base {
 public:
  Base() { cout << "创建Base基类。" << endl; }
  virtual ~Base() { cout << "删除Base基类。" << endl; }  //虚析构函数
};
class Child : public Base {
 public:
  Child() { cout << "创建Child派生类。" << endl; }
  ~Child() { cout << "删除Child派生类。" << endl; }
};

int main() {
  cout << "*********构造函数调用顺序示例***********" << endl;
  Base *C1 = new Child;
  cout << "*********析构函数调用顺序示例***********" << endl;
  delete C1;
}

• 输出结果

  *********构造函数调用顺序示例***********
  创建Base基类。
  创建Child派生类。
  *********析构函数调用顺序示例***********
  删除Child派生类。
  删除Base基类。