【C++】多态

前言：
本文我们将学习C++三大特性之一的多态。多态使得C++拥有更多强大的功能，是一柄强大的武器，同样意味着它拥有更加复杂的语法与规范。多态不仅仅在学习与工作中占着重要位置，同样也是笔试面试中的热门考题，希望本文能对你有所帮助~

一.多态的定义及实现

本章所谈到的多态是建立在继承的基础上的。多态指在不同继承关系的类对象去调用同一函数时，产生了不同的行为。比如Student类继承了Person类。Person类对象买票全价，Student类对象买票半价。

构成多态的两个必要条件（非常重要！！！）

• 必须通过基类的指针或者引用调用虚函数
  • 虚函数：即被virtual修饰的类成员函数称为虚函数
• 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
  • 只有虚函数才存在重写
  • 注意重写不同于上一章中所学的隐藏

示例——多态

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

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

void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person p;
	Student s;
	Func(p);
	Func(s);
	return 0;
}

如图所示，Person和Student的对象同样是去买票，但是产生了不同的结果。为了更好的理解多态，我们来看看若是不构成多态，结果该如何~

示例——非多态

class Person {
public:
	// 注意这里不是虚函数，无法构成多态
	void BuyTicket() { cout << "买票-全价" << endl; }
};

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

void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person p;
	Student s;
	Func(p);
	Func(s);
	return 0;
}

如图所示，此时由于不满足构成多态的条件（虚函数），所以调用函数是只看调用者的类型，而非它指向的类型。

1.虚函数重写

• 虚函数的重写（或覆盖）：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数

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

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

注意

• 在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写（因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性），但是该种写法不是很规范，不建议这样使用。

2.虚函数重写的两个例外

（1）协变

• 派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

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

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

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

3.c++11 override和final关键字

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

（1）final

• 修饰虚函数，表示该虚函数不能再被重写

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

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

（2）override

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

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

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

4.重载、覆盖（重写）、隐藏（重定义）的对比

二. 抽象类

抽象类，类如其名，确实非常抽象…

• 包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象

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

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

1.纯虚函数

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

class Person {
public:
	virtual void BuyTicket() = 0; // 纯虚函数
};

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

void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Student s;
	Func(s);
	return 0;
}

2.接口继承和实现继承

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

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

三. 多态的原理

1.引例

请判断sizeof(Base)的结果是多少？（32位平台下）

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

按照一般的判断逻辑，Base类中只包含一个int类型的成员变量，结果应该是4。但结果却是8：

出于好奇，我们创建一个Base类的对象b，通过监视窗口看看b中究竟包含哪些成员吧。

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

通过观察测试我们发现b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)。

对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。它指向一张表，表中存放的是虚函数的地址。

• 一个含有虚函数的类中都至少有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

2.虚函数表

我们在Base中继续增加两个函数，一个是虚函数Func2，一个是普通函数Func3。并让Derive类继承Base类。

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
{
private:
	int _d = 2;
};

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

通过监视窗口观察两个对象中分别包含哪些内容：

通过观察我们发现，派生类对象d中也有一个虚表指针，且内容与基类对象相同。

但如果我们在子类中将Func1进行重写，结果又该如何呢？

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

通过上图我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1`。

• 所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。

总结

通过上述两个例子，我们能得出以下结论：

• 子类会继承父类的成员。若类中有虚函数，则该类对象会生成一个虚函数表指针，存放虚函数的地址
• 普通函数的地址不会放入虚表中
• 当子类对父类的某个虚函数进行了重写，子类对象中的虚表会被修改，将原来存放的虚函数地址修正为重写后的虚函数地址
• 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr

派生类的虚表生成

1. 先将基类中的虚表内容拷贝一份到派生类虚表中
2. 如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
3. 派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后

重点难点

1. 虚函数存在哪？
   • 虚函数与普通函数一样，存在代码段
2. 虚表是在什么阶段生成？
   • 虚表在编译阶段生成
3. 对象中虚表指针在什么时候初始化？
   • 在构造函数中初始化
4. 虚表存在哪里？
   • 虚表存在常量区

3.多态的原理

还记得这里Func函数传Person调用的是Person::BuyTicket，传Student调用的是Student::BuyTicket吗？

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person Mike;
	Func(Mike);
	Student Johnson;
	Func(Johnson);
	return 0;
}

• 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
• 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
• 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

四. 动态多态与静态多态

多态是一个广泛的概念，不仅仅指的是本章学习的多态。我们之前所学过的函数重载其实也是一种多态的思想。但我们更喜欢称函数重载为静态多态，而重写是一种动态多态。

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

五.打印虚函数表

class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a;
};
class Derive :public Base {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
private:
	int b;
};

按照前面的知识总结，我们知道d对象的虚表中应该包含4个虚函数地址（父类中继承的虚函数+自己定义的虚函数），但在监视窗口中，我们只能看到2个（如下图），这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。

那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数地址。

typedef void(*VFPTR) ();

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;
}
int main()
{
	Base b;
	Derive d;
	VFPTR* vTableb = (VFPTR*)(*(int*)&b);
	PrintVTable(vTableb);
	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
	PrintVTable(vTabled);
	return 0;
}

代码解释

思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。

1. 先取b的地址，强转成一个int*的指针

2. 再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针

3. 再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组

4. 虚表指针传递给PrintVTable进行打印虚表

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

六.多继承中的虚函数表

学会了如何打印虚表，我们可以尝试在多继承中，打印子类的虚表

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) ();
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;
}
int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
	return 0;
}

如图所示我们发现

• 多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

七.菱形继承中的多态

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。

八.总结

1. 什么是多态？

   • 多态指多种形态。不同的对象完成同一件事情，但是结果不同。例如公交刷卡行为：成人刷卡全价，学生刷卡半价。亦或是不同的客户来消费，金卡会员8折，银卡会员9折，普通会员无折扣。

2. 重载、重写（覆盖）、重定义（隐藏）的区别？

   • 函数重载：

     1. 两个函数在同一作用域
     2. 函数名相同，参数列表不同，返回值没有要求

   • 重写：

     1. 两个函数必须位于子类和父类中
     2. 函数名、参数列表、返回值必须相同(协变除外)
     3. 两个函数均为虚函数

   • 隐藏：

     1. 两个函数必须位于子类和父类中
     2. 函数名相同
     3. 不构成重写，就构成隐藏。

3. 多态的实现原理？

   • 对于多态的实现原理，必须先从构成多态的条件说起：
     1. 必须通过父类对象的引用或指针当做形参调用虚函数。
     2. 子类必须完成对父类虚函数的重写且被调用的函数是虚函数。
   • 子类和父类的虚函数表指针、虚函数表、重写的虚函数的地址均不相同，我们传入一个父类对象，它使用的是源自父类的虚函数，传入一个从子类切片而来的父类对象，这个对象中的虚函数是子类重写的虚函数。虽说这两个都是父类对象，但是对象体内的虚函数并不是同一个，所以会产生不同的行为，这便是多态的原理。

4. inline可以是虚函数吗？

   • inline可以是虚函数。调用时，如果不构成多态，这个函数就保持inline属性。如果构成多态，就不具备inline属性，因为多态是要在运行时去对象的虚函数表里面找虚函数，所以在编译时，不能使用inline进行展开。

5. 静态成员可以是虚函数吗？

   • 静态成员不能是虚函数。因为静态成员没有this指针，在外部可以直接使用类名::成员函数的方式对静态成员函数进行调用，但是调用虚函数需要通过对象才能找到虚函数表，所以静态成员不能是虚函数。

6. 构造函数可以是虚函数吗？

   • 构造函数不能是虚函数。因为对象的虚函数表指针是在构造函数的初始化列表中进行初始化。（先有鸡还是先有蛋的问题）

7. 析构函数可以是虚函数吗？

   • 析构函数可以是虚函数，用于处理子类对象交给父类的指针管理的情况。

8. 对象调用普通成员函数快还是虚函数快？

   • 如果不构成多态，即使是虚函数，也是在编译阶段确定调用地址，速度一样快；但是一旦构成多态，编译器在运行时通过对象去虚函数表中确定虚函数的调用地址，这个时候就是普通函数快了。

9. 什么是抽象类？抽象类的作用？

   • 抽象类又称接口类。包含纯虚函数的类被称为抽象类，在虚函数后边加个 =0，这个虚函数就被叫做纯虚函数。抽象类不能实例化出对象。在现实世界中没有对应的实物，就可以定义为抽象类。例如职能类、Person类等。

   • 抽象类体现接口继承的关系。子类继承抽象类后，也变成了抽象类。这就强制用户对纯虚函数进行重写，对虚函数的重写是一种接口继承，子类会继承虚函数的函数名及缺省值，但不会继承实现。

---

本文到此结束，码文不易，还请多多支持哦！！！