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

时间：2024-03-14 18:18:37



快乐的流畅：个人主页


个人专栏：《C语言》《数据结构世界》《进击的C++》

远方有一堆篝火，在为久候之人燃烧！

文章目录

  • 一、虚函数与重写
    • 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 菱形虚拟继承下的虚函数表

一、虚函数与重写

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 重写的特例

  1. 派生类要重写的虚函数，可以不用加virtual关键字（不推荐使用）
class Person
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

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

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

  1. 协变
    派生类和基类虚函数返回值类型不同，即基类虚函数返回基类对象的指针或引用，派生类返回派生类对象的指针或引用。
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;}
};
  1. 析构函数的重写
    如果基类的析构函数为虚函数，那么只要派生类的析构函数定义，便构成重写。
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）

  1. final：可以修饰变量、函数和类。
    对于变量，确保初始化后不能被修改
    对于函数，确保不能被子类重写
    对于类，确保不能被继承
class Car
{
public:
	virtual void Drive() final {}
};

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

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

  1. 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对象买票半价。

构成多态需要两个条件：

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

三、抽象类

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;
}

细节：

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

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

int main()
{
	Base b;
	Derive d;

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

	return 0;
}

细节：

  1. 利用性质：虚表指针在对象的开头（vs平台）
  2. 取出对象地址，再强转为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;
};

运行结果：

综上三种情况：

  1. 基类的虚函数表，（按照声明顺序）存储基类中的虚函数指针。
  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;
}

运行结果：

结论：

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

4.5 多态的原理

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

  1. 为什么要使用父类的指针或引用来调用？因为子类的虚表存储在继承的父类部分，这样才能统一调用父类子类各自的虚表。

  2. 为什么被调用的虚函数必须重写？因为这是一种接口继承，也是你要实现多态的根本目的。在重写了虚函数的实现后，调用时在父类子类各自的虚表查找各自不同实现的虚函数，才能构成多态。

4.6 静态绑定与动态绑定

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

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

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;
}

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

虚基表：存储偏移量


细节：

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

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


真诚点赞，手有余香

相关文章