---

📄前言

面向对象语言中多态是必不可少的一种特性，多态可用于实现代码复用，提高代码的扩展性。

虚函数

概念

虚函数是为了实现多态而实现的功能，被virtual所修饰的成员函数就被称为虚函数。

class A {
	virtual void func() { cout << "A::func()" << endl; }
};

虚函数重写

重写又名覆盖，当派生类又一个更基类完全相同的虚函数，则称子类的虚函数重写了基类的虚函数。重写可以实现使用基类指针/引用指向子类时调用子类的同名虚函数。

class A {
	virtual void func() { cout << "A::func()" << endl; }
};

class B {	//派生类可加virtual也可不加
	virtual void func() { cout << "B::func()" << 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 void BuyTicket(){
		cout << "买票全价" << endl;
	}
};

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

void func(person& peo) {
	peo.BuyTicket();
}

抽象类

在虚函数的后面写 = 0，则这个函数就为纯虚函数，包含纯虚函数的类叫做抽象类，抽象类不能实例化对象，派生类必须在重写了纯虚函数后才能实例化出对象。

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

多态的原理

虚函数表

在拥有虚函数的对象里面会存放着一个指向虚函数表的指针，虚表指针。

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

class Derive : public Base
{
public:
	virtual void Func1()
 	{
 		cout << "Derive::Func1()" << endl;
 	}
};

我们可以看到基类对象的虚表指针全是指向自己的，而派生类对象重写的虚函数覆盖了虚函数表中父类的虚函数所在位置。

多继承中的虚函数表

我们已经知道单继承中虚函数表的样子，现在来看看多继承中的虚函数表吧。

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

typedef void(*VFPTR) ();
typedef long long* pointer;

void PrintVTable(VFPTR vTable[])
{
	// 打印虚表的函数地址并调用它
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
	 	VFPTR f = vTable[i];
		f();
	}
 	cout << endl;
}

Derive d;
VFPTR* vtb1 = (VFPTR*)(*(pointer)&d);
PrintVTable(vtb1);
//强转成父类的指针会使其指向其内存中父类的位置。
PrintVTable((VFPTR*)(*(pointer)(Base2*)&d);

我们可以从结果看出，多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。

📓总结

多态调用需要使用基类指针或引用去指向派生类的对象，拥有虚函数的对象都会有一个虚表指针来指向其虚表。

📜博客主页：主页
📫我的专栏：C++
📱我的github：github