【C++练级之路】【Lv.13】多态（你真的了解虚函数和虚函数表吗？）-阿里云开发者社区

一、虚函数与重写

1.1 虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数。

class Person
{
public:
  virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

1.2 虚函数的重写

虚函数的重写，又称覆盖。派生类有一个函数名、参数、返回值与基类虚函数相同的虚函数，则称派生类的虚函数重写了基类的虚函数。

class Person
{
public:
  virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

class Student : public Person
{
public:
  virtual void BuyTicket() { cout << "买票-半价" << endl; }
}

同时，虚函数重写，其意义在于继承函数接口，重写函数定义。

1.3 重写的特例

派生类要重写的虚函数，可以不用加virtual关键字（不推荐使用）

class Person
{
public:
  virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

class Student : public Person
{
public:
  void BuyTicket() { cout << "买票-半价" << endl; }
}

原因：由于继承，派生类的同名函数继承了基类虚函数的特性。

协变
派生类和基类虚函数返回值类型不同，即基类虚函数返回基类对象的指针或引用，派生类返回派生类对象的指针或引用。

class A{};
class B : public A {};

class Person
{
public:
  virtual A* f() {return new A;}
};
class Student : public Person
{
public:
  virtual B* f() {return new B;}
};

析构函数的重写
如果基类的析构函数为虚函数，那么只要派生类的析构函数定义，便构成重写。

class Person
{
public:
  virtual ~Person() {cout << "~Person()" << endl;}
};

class Student : public Person
{
public:
  virtual ~Student() { cout << "~Student()" << endl; }
};

原因：编译器此时做了特殊处理，将基类和派生类的析构函数名，都改为destructor，因此构成重写。

那么为什么要这么处理呢？请看下面代码：

int main()
{
  Person* p1 = new Person;
  Person* p2 = new Student;
  
  delete p1;
  delete p2;
  return 0;
}

原因：只有这样处理，构成多态，才能正确调用各自的析构函数。

1.4 final和override（C++11）

final：可以修饰变量、函数和类。
对于变量，确保初始化后不能被修改
对于函数，确保不能被子类重写
对于类，确保不能被继承

class Car
{
public:
  virtual void Drive() final {}
};

class Benz :public Car
{
public:
  virtual void Drive() {cout << "Benz-舒适" << endl;}
};

加上final，以上代码会编译报错。

override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class Car
{
public:
  virtual void Drive() {}
};

class Benz :public Car
{
public:
  virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

1.5 重载、重写(覆盖)、重定义(隐藏)的对比

二、多态的概念及定义

2.1 多态的概念

多态，顾名思义，即多种形态。具体来说，就是不同对象执行同一行为而产生不同的结果。

比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

2.2 多态的定义

多态，是在不同继承关系的类对象，去调用同一函数，产生不同的行为。

比如：Student继承了Person。Person对象买票全价，Student对象买票半价。

构成多态需要两个条件：

通过父类的指针或引用调用
被调用的必须是虚函数，并且虚函数必须重写

三、抽象类

3.1 纯虚函数

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。

class Car
{
public:
  virtual void Drive() = 0;
};

3.2 抽象类的概念

包含纯虚函数的类叫做抽象类，也叫接口类。

抽象类不能实例化出对象，派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。

class Car
{
public:
  virtual void Drive() = 0;
};

class Benz :public Car
{
public:
  virtual void Drive()
  {
    cout << "Benz-舒适" << endl;
  }
};

class BMW :public Car
{
public:
  virtual void Drive()
  {
    cout << "BMW-操控" << endl;
  }
};

void Test()
{
  Car* pBenz = new Benz;
  pBenz->Drive();
  Car* pBMW = new BMW;
  pBMW->Drive();
}

意义：纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

3.3 接口继承与实现继承

普通函数的继承，是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。

虚函数的继承，是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。

综上所述，虚函数就是为多态而生的，如果不实现多态，不要把函数定义成虚函数。

四、多态的原理

4.1 虚函数表

先来看一道题：32位平台下，sizeof(Base)是多少？

class Base
{
public:
  virtual void Func1()
  {
    cout << "Func1()" << endl;
  }
private:
  int _b = 1;
};

正确答案是8byte！是不是很诧异？

其实，Base类里面还有一个隐藏的指针，称为虚函数表指针（简称虚表指针）。

经过观察发现，其类型为void**，并且(与平台有关，vs平台下)位于对象的最上方。

而且，这个指针指向了一张表，称为虚函数表（简称虚表）。虚函数表，是一个函数指针数组，里面存储了该类中虚函数的指针。

4.2 虚函数表的打印

由于监视窗口会隐藏一些真实的信息，并且观察起来不太直观和方便，所以我们写一个函数专门打印虚函数表，以便观察和检验。

typedef void(*VFT_PTR)();

void PrintVFTable(VFT_PTR* table)
{
  for (int i = 0; table[i] != nullptr; ++i)
  {
    printf("[%d]: %p-> ", i, table[i]);
    VFT_PTR f = table[i];
    f();
  }
  cout << endl;
}

细节：

由于函数指针不太直观，先typedef重命名一下
传参传入二级指针，也就是虚表指针
这里利用一个性质：虚函数表以nullptr结尾，以作标识（vs平台）

至于如何取出虚表指针，这也是需要一定的技巧。先给出下面分析要用的main函数

int main()
{
  Base b;
  Derive d;

  PrintVFTable(*(VFT_PTR**)&b);
  PrintVFTable(*(VFT_PTR**)&d);

  return 0;
}

细节：

利用性质：虚表指针在对象的开头（vs平台）
取出对象地址，再强转为VFT_PTR**，这样解引用就可以直接获取虚表指针大小的内容

需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了。

4.3 单继承下的虚函数表

4.3.1 一对一

class Base
{
public:
  virtual void Func1()
  {
    cout << "Base::Func1()" << endl;
  }
private:
  int _b = 1;
};

class Derive : public Base
{
public:
  virtual void Func1()
  {
    cout << "Derive::Func1()" << endl;
  }
private:
  int _d = 2;
};

运行结果：

4.3.2 多对一

class Base
{
public:
  virtual void Func1()
  {
    cout << "Base::Func1()" << endl;
  }
  virtual void Func2()
  {
    cout << "Base::Func2()" << endl;
  }
private:
  int _b = 1;
};

class Derive : public Base
{
public:
  virtual void Func1()
  {
    cout << "Derive::Func1()" << endl;
  }
private:
  int _d = 2;
};

运行结果：

4.3.3 一对多

class Base
{
public:
  virtual void Func1()
  {
    cout << "Base::Func1()" << endl;
  }
private:
  int _b = 1;
};

class Derive : public Base
{
public:
  virtual void Func1()
  {
    cout << "Derive::Func1()" << endl;
  }
  virtual void Func4()
  {
    cout << "Derive::Func4()" << endl;
  }
private:
  int _d = 2;
};

运行结果：

综上三种情况：

基类的虚函数表，（按照声明顺序）存储基类中的虚函数指针。
派生类的虚函数表，先将基类的虚函数表拷贝过来，再对被重写的虚函数覆盖为派生类的虚函数，最后在末尾加上派生类新增的虚函数。

这里也体现了为什么重写又称覆盖，重写是语法层的叫法，覆盖是原理层的叫法。

4.4 多继承下的虚函数表

那么，有了上面单继承下的虚函数表的基础，我们再来看看多继承虚函数表有哪些变化吧。

class Base1
{
public:
  virtual void func1()
  {
    cout << "Base1:func1()" << endl;
  }
  virtual void func2()
  {
    cout << "Base1:func2()" << endl;
  }
private:
  int _b1;
};

class Base2
{
public:
  virtual void func1()
  {
    cout << "Base2:func1()" << endl;
  }
  virtual void func2()
  {
    cout << "Base2:func2()" << endl;
  }
private:
  int _b2;
};

class Derive :public Base1, public Base2
{
public:
  virtual void func1()
  {
    cout << "Derive::func1()" << endl;
  }
  virtual void func3()
  {
    cout << "Derive::func3()" << endl;
  }
private:
  int _d1;
};

我们先来看看监视窗口：

我们可以发现，多继承下的派生类对象，将两个基类的虚表都继承了过来，所以后续打印时要注意打印两份虚表。

这里需要找到派生类对象中两个虚表指针的位置，可以用到切片的技巧，实现指针自动定位。

int main()
{
  Base1 b1;
  Base2 b2;

  Derive d;
  Base1* p1 = &d;
  Base2* p2 = &d;

  PrintVFTable(*(VFT_PTR**)&b1);
  PrintVFTable(*(VFT_PTR**)&b2);
  PrintVFTable(*(VFT_PTR**)p1);
  PrintVFTable(*(VFT_PTR**)p2);

  return 0;
}

运行结果：

结论：

派生类分别将各个基类的虚表拷贝过来，再对被重写的虚函数进行覆盖。
唯一不同的，是派生类新增的虚函数，是放在第一个继承的基类部分虚表的最后。

4.5 多态的原理

讲了这么多虚函数表的内容，所以这跟多态的原理有什么关系呢？我们再来回看一开始这张多态调用分析图：

为什么要使用父类的指针或引用来调用？因为子类的虚表存储在继承的父类部分，这样才能统一调用父类子类各自的虚表。
为什么被调用的虚函数必须重写？因为这是一种接口继承，也是你要实现多态的根本目的。在重写了虚函数的实现后，调用时在父类子类各自的虚表查找各自不同实现的虚函数，才能构成多态。

4.6 静态绑定与动态绑定

静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载。
动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

所以，满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

4.7 菱形虚拟继承下的虚函数表

这里已经属于考试不考，实际中不常用的范围了，有兴趣可以看看~

class A
{
public:
  virtual void func1()
  {}
  int _a;
};

class B :virtual public A
{
public:
  virtual void func1()
  {}
  virtual void func2()
  {}
  int _b;
};

class C :virtual public A
{
public:
  virtual void func1()
  {}
  virtual void func3()
  {}
  int _c;
};

class D :public B, public C
{
public:
  virtual void func1()
  {}
  virtual void func4()
  {}
  int _d;
};

int main()
{
  D d;
  d._b = 1;
  d._c = 2;
  d._d = 3;
  d._a = 4;
  return 0;
}

虚表（虚函数表）：存储虚函数地址

虚基表：存储偏移量

细节：

D类中必须重写func1，避免B和C类多重继承时重写的歧义性
虚拟继承中，重写的func1位于A部分虚表，而B和C类中未重写的虚函数，分别位于B和C部分的虚表
D类中新增的虚函数，放在第一个继承类部分的虚表（即B部分虚表）
虚基表中（总共两个位置），第一位置记录距离虚表指针的偏移量，第二位置记录距离A部分的偏移量

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。

真诚点赞，手有余香

【C++练级之路】【Lv.13】多态（你真的了解虚函数和虚函数表吗？）

一、虚函数与重写

1.1 虚函数

1.2 虚函数的重写

1.3 重写的特例

1.4 final和override（C++11）

1.5 重载、重写(覆盖)、重定义(隐藏)的对比

二、多态的概念及定义

2.1 多态的概念

2.2 多态的定义

三、抽象类

3.1 纯虚函数

3.2 抽象类的概念

3.3 接口继承与实现继承

四、多态的原理

4.1 虚函数表

4.2 虚函数表的打印

4.3 单继承下的虚函数表

4.3.1 一对一

4.3.2 多对一

4.3.3 一对多

4.4 多继承下的虚函数表

4.5 多态的原理

4.6 静态绑定与动态绑定

4.7 菱形虚拟继承下的虚函数表

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【C++练级之路】【Lv.13】多态（你真的了解虚函数和虚函数表吗？）

一、虚函数与重写

1.1 虚函数

1.2 虚函数的重写

1.3 重写的特例

1.4 final和override（C++11）

1.5 重载、重写(覆盖)、重定义(隐藏)的对比

二、多态的概念及定义

2.1 多态的概念

2.2 多态的定义

三、抽象类

3.1 纯虚函数

3.2 抽象类的概念

3.3 接口继承与实现继承

四、多态的原理

4.1 虚函数表

4.2 虚函数表的打印

4.3 单继承下的虚函数表

4.3.1 一对一

4.3.2 多对一

4.3.3 一对多

4.4 多继承下的虚函数表

4.5 多态的原理

4.6 静态绑定与动态绑定

4.7 菱形虚拟继承下的虚函数表

热门文章

最新文章

相关课程

相关电子书