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

什么是多态?

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

虚函数实现多态

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

举例

#include 
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

[C++] 多态机制的实现原理之虚函数表_第1张图片

[C++] 多态机制的实现原理之虚函数表_第2张图片

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

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

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

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

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

#include 

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 
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 
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 
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基类。
    

你可能感兴趣的:(cpp,c++)