带你深入了解多态——C++

这篇具有很好参考价值的文章主要介绍了带你深入了解多态——C++。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

带你深入了解多态——C++

💐专栏导读

🌸作者简介：花想云，在读本科生一枚，致力于 C/C++、Linux 学习。

🌸本文收录于 C++系列，本专栏主要内容为 C++ 初阶、C++ 进阶、STL 详解等，专为大学生打造全套 C++ 学习教程，持续更新！

🌸相关专栏推荐：C语言初阶系列 、C语言进阶系列 、数据结构与算法、Linux从入门到精通

💐文章导读

本章我们将学习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;
}

带你深入了解多态——C++

如图所示，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;
}

带你深入了解多态——C++

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

🌺虚函数的重写

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

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

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

🍁注意

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

🌺虚函数重写的两个例外

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

带你深入了解多态——C++

🌺C++11 override 和 final关键字

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

🏵️final

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

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

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

带你深入了解多态——C++

🏵️override

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

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

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

带你深入了解多态——C++

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

带你深入了解多态——C++
（注：图中有一处错误——重载的函数名相同，参数不同）

🌷抽象类

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

包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。
派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。

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

🌺纯虚函数

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

带你深入了解多态——C++

🌺理解接口继承和实现继承

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

🌷多态的原理

🌺引例

请判断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：

带你深入了解多态——C++
出于好奇，我们创建一个Base类的对象b，通过监视窗口看看b中究竟包含哪些成员吧。

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

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

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

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

🌺虚函数表

我们在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;
}

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

带你深入了解多态——C++

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

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

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

带你深入了解多态——C++
通过上图我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1。

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

🍁总结

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

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

🍁派生类的虚表生成：

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

🍁重点难点

虚函数存在哪？
- 虚函数与普通函数一样，存在代码段；
虚表是在什么阶段生成？
- 虚表在编译阶段生成；
对象中虚表指针在什么时候初始化？
- 在构造函数中初始化；
虚表存在哪里？
- 虚表存在代码段；

🌺多态的原理

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

带你深入了解多态——C++

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。
这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

带你深入了解多态——C++

🌷动态多态与静态多态

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

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

🌷如何手动打印出虚表

有如下代码——

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的虚表呢？下面我们使用代码打印出虚表中的函数地址。
带你深入了解多态——C++

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，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了；

带你深入了解多态——C++

🌷多继承中的虚函数表

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

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