【C++】有关多态

前言

  在我们上一篇文章《有关继承》里面，我们提到了面向对象三大特性之一的继承，接下来我们来讲第二个特性——多态。需要声明的是，本文中的代码都是在VS2022下的x86程序中，涉及的指针都是4bytes。

一、理解多态

  现实生活中有很多行为是存在多态性的，如在某路APP订购火车票，当普通人去买票时，是全价买票；当学生去买票时，是半价买票。此时就引发了一个问题，程序该如何实现不同类型的人产生不同的行为？这里就运用了多态的特性。

• 通俗地来说，多态就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

二、多态的定义及实现

2.1 多态的构成条件

  多态的形成首先需要在继承体系中，除此之外还有两个条件：

1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

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

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

2.2 虚函数的重写

• 定义：派生类中有一个和基类几乎完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型、函数名、参数列表完全相同），称派生类的虚函数重写了基类的虚函数。

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

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

注意：派生类的重写虚函数不加virtual关键字也可以构成重写，可以认为虚函数重写的是函数体，函数头是继承自基类。

虚函数重写的两个例外：

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

2. 析构函数的重写
  如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;

	delete p1;
	delete p2;
	return 0;
}

2.3 C++11 override和final

1. final：修饰虚函数，表示该虚函数不能再被重写

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

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

值得注意的是，final关键字还可以用来修饰类，被修饰过的类不能被继承

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

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

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

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

三、抽象类

3.1 概念

在虚函数的后面写上 =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();
}

现实生活中有种抽象的类型我们是不希望它实例化出对象的，比如：人、动物、植物这种词，我们可以把他们定义为抽象类，只允许它们派生出重写虚函数的类，才能实例化出对象。

3.2 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

四、多态的原理

4.1 虚函数表

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

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

int main()
{
	Base b;
	Derive d;
	return 0;
}

观察内存对象模型：

1. 含虚函数的对象模型中都有一个_vfptr指针放在类的其它成员前面，这个指针我们叫做虚函数表指针(虚表指针)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

2. 派生类对象d也有一个虚表指针，d对象由两部分构成，一部分是基类继承下来的成员，也包含虚表指针，另一部分则是自己的成员。

3. 仔细观察d对象当中的虚表，会发现与b对象中的虚表不一致，这是因为d对象重写了Func1函数，所以d的虚表中存的是重写的Derive::Func1。

4. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。

5. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
   

6. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

7. 注意：虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是它的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。
   捋一下顺序，对象中存虚表指针->虚表指针指向一份虚函数表->虚函数表中存虚函数的指针->指针指向各个虚函数

4.2 多态的原理

讲了虚函数表是什么，我们再来谈谈由虚函数形成的多态的工作原理。

1. 类定义和虚表构建：

• 编译器在类定义时为每个包含虚函数的类生成一个虚表。
• 基类和派生类的虚表指针分别指向各自的虚表。

2. 对象创建：

• 当创建一个对象时，编译器会将该对象的虚表指针初始化为指向相应类的虚表。

3. 虚函数调用：

• 当通过基类指针或引用调用虚函数时，编译器生成代码来通过对象的虚表指针(vfptr)查找实际的虚表。
• 然后通过虚表查找到对应的函数地址，并进行调用。

4.3 动态多态与静态多态

1. 通过函数重载和运算符重载实现，在程序编译期间确定了程序的行为（调用哪个函数），被称为静态多态。
2. 通过虚函数和继承实现，在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，称为动态多态。