【C++进阶之路】第二篇：多态 & 抽象类 & 单继承和多继承关系中的虚函数表

最新推荐文章于 2024-09-29 20:57:53 发布

Captain-Lin

最新推荐文章于 2024-09-29 20:57:53 发布

阅读量621

点赞数 24

分类专栏： C++学习与应用文章标签： pandas 机器学习 c++ 开发语言

本文链接：https://blog.csdn.net/Captain_ldx/article/details/130004228

版权

C++学习与应用专栏收录该内容

41 篇文章 15 订阅

订阅专栏

🌟hello，各位读者大大们你们好呀🌟
🍭🍭系列专栏：【C++学习与应用】
✒️✒️本篇内容：多态的概念，多态的构成条件，虚函数重写，C++11final和overrid，重载、重写、隐藏的对比，抽象类，虚函数表，多态原理，动静态绑定，单多继承下的虚函数表理解，继承和多态常见面试题
🚢🚢作者简介：计算机海洋的新进船长一枚，请多多指教( •̀֊•́ ) ̖́-

（1）当父类虚函数带有virtual时，子类虚函数可以不加virtual

（2）协变(基类与派生类虚函数返回值类型不同)

（3）析构函数的重写(基类与派生类析构函数的名字不同)

（4）继承隐藏和多态虚函数重写之间的关系

4.C++11 override 和 final

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

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

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

三、抽象类

1.概念

2.接口继承和实现继承

四、虚函数表 & 多态的原理 & 动态绑定和静态绑定

前言

之前的文章中，我向大家介绍了继承的相关知识，如果说继承让代码实现了可复用，那么多态就是就是在继承的基础上，为不同的类函数的实现提供了统一的接口，使不同的对象可以就同一接口实现出不同的结果。

需要声明的，本篇文章中的代码及解释都是在vs2022下的x86程序中，涉及的指针都是4bytes。如果要其他平台下，部分代码需要改动。比如：如果是x64程序，则需要考虑指针是8bytes问题等等。

一、多态的概念

多态的概念：多态（英语：polymorphism）指为不同数据类型的实体提供统一的接口。通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举一个简单的例子，在高铁站买票的时候，就买票这个统一的行为来说，普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

二.多态的实现和定义

1.多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了
Person。Person对象买票全价，Student对象买票半价。

在继承中要构成多态有两个条件：

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

这里我们先见一见多态大致是怎样的，后面我们会深入讲解

2.虚函数

我们知道虚函数重写是构成多态的重要条件之一，那么虚函数究竟是什么呢？实际上，通过上面的图示我们不难猜出，虚函数：即被virtual修饰的类成员函数称为虚函数

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

3.虚函数的重写

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

这里还有四个需要特别注意的知识点

当父类虚函数带有virtual时，子类虚函数可以不加virtual（建议：父类子类虚函数都加上）
协变(基类与派生类虚函数返回值类型不同)
析构函数的重写(基类与派生类析构函数的名字不同)
继承隐藏和多态虚函数重写之间的关系

接下来我们对虚函数重写的四个特殊知识点分别进行演示

（1）当父类虚函数带有virtual时，子类虚函数可以不加virtual

#include<iostream>
using namespace std;

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

// 1、虚函数的重写（三同：函数名、参数、返回值）
// （1）子类虚函数可以不加virtual  （建议：父类子类虚函数都加上）
class Student : public Person
{
public:
	void BuyTicket() { cout << "Student--买票-半价" << endl; }
};

class Soldier: public Person
{
public:
	void BuyTicket() { cout << "Soldier--买票-优先" << endl; }
};

// 多态的条件：
// 1、虚函数重写
// 2、父类的指针或者引用去调用虚函数

void Func(Person& p)//2、父类的指针或者引用去调用虚函数，这里用的是Person的引用调用
{
	p.BuyTicket();
}

int main()
{
	Person pn;
	Student st;
	Soldier sd;

	Func(pn);
	Func(st);
	Func(sd);

	return 0;
}

这里我们补充一下普通函数调用与多态调用的区别

普通调用：跟调用对象类型有关
多态调用：指针/引用--指向的对象有关

普通调用代码示例

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


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

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


void Func(Person p)//这里没有&，只和p的类型有关，所以会调用三次Person中的BuyTicket函数
{
	p.BuyTicket();
}

int main()
{
	Person pn;
	Student st;
	Soldier sd;

	Func(pn);
	Func(st);
	Func(sd);

	return 0;
}

代码最后会输出三行 Person--买票-全价。

多态调用代码示例

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


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

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


void Func(Person p)//这里有&，和引用的对象有关，会调用三个不同类的BuyTicket函数
{
	p.BuyTicket();
}

int main()
{
	Person pn;
	Student st;
	Soldier sd;

	Func(pn);
	Func(st);
	Func(sd);

	return 0;
}

代码会输出三种不同的情况。

（2）协变(基类与派生类虚函数返回值类型不同)

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。通俗来讲，就是三同中，返回值可以不同，但是要求返回值必须是一个父子类关系的指针或者引用（了解即可）

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

（3）析构函数的重写(基类与派生类析构函数的名字不同)

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，即使基类与派生类析构函数名字不同，都与基类的析构函数构成重写。

虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor（析构函数）。

class Person
{
public:
	virtual ~Person()
	{
		cout << "Person delete:" << _p << endl;
		delete[] _p;
	}
protected:
	int* _p = new int[10];
};

class Student : public Person
{
public:
	~Student()
	{
		cout << "Student delete:" << _s << endl;
		delete[] _s;
	}
protected:
	int* _s = new int[20];
};

int main()
{
	//Person p;
	//Student s;

    // 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函
    // 数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
	Person* ptr1 = new Person;
	Person* ptr2 = new Student;
	
	delete ptr1;
	delete ptr2;

	return 0;
}

运行结构如下，先析构Person的 _p，再析构student的 _s，再析构student的 _p，共析构三次。

我们可以思考一下为什么析构函数也要构成重写呢？那是因为，delete是通过指针调用析构函数的！是什么类型就调用什么类型的析构函数，如果析构函数不构成重写，那么上面的代码就只会调用两次 Person delete（因为ptr1、ptr2都是Person类型），造成内存泄漏。

我们期望我们的 delete是一个多态调用，那么就需要我们基类的析构函数为虚函数。

（4）继承隐藏和多态虚函数重写之间的关系

我们知道，在继承中，父类和子类函数中的某个函数名相同，就构成了隐藏。而虚函数重写，实际上就是在此基础上增加了虚函数进行修饰和三同（函数名、参数、返回值）的条件限制罢了。所以隐藏和重写是包含与被包含的关系。

4.C++11 override 和 final

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

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

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

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

知识补充：如何实现一个不能被继承的类？

构造私有（C++98）
类定义时加final（ C++98）

下述代码是私有构造的示例（代码会运行失败，因为无法完成A的构造）

class A
{
private:
	A()
	{}
};

class B : public A
{};

int main()
{
	B bb;
	B* ptr = new B;

	return 0;
}

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

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

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

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

三、抽象类

1.概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

#include<iostream>
using namespace std;

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

int main()
{
	Car* pBenz = new Benz;
	pBenz->Drive();

	Car* pBMW = new BMW;
	pBMW->Drive();

	return 0;
}

2.接口继承和实现继承

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

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

总结：虚函数继承只继承了接口（包括函数名、类型参数），没有继承实现（函数内容），目的是为了派生类的函数重写。

四、虚函数表 & 多态的原理 & 动态绑定和静态绑定

【C++】虚函数表 & 多态的原理 & 动态绑定和静态绑定https://blog.csdn.net/Captain_ldx/article/details/130009820

五、单继承和多继承关系的虚函数表

在第四节我们已经学习过了基类的虚表模型，下面我们去关注的是派生类对象的虚表模型

1.单继承中的虚函数表

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

通过运行调试上述代码，我们获得了监视窗口的信息如下。

观察图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个bug。那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数。

int main()
{
	Base b;
	Derive d;

	// 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数
	//指针的指针数组，这个数组最后面放了一个nullptr
		// 1.先取b的地址，强转成一个int*的指针
		// 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
		// 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
		// 4.虚表指针传递给PrintVTable进行打印虚表
		// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最
		//后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再
		//编译就好了。
	VFPTR * vTableb = (VFPTR*)(*(int*)&b);
	PrintVTable(vTableb);

	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
	PrintVTable(vTabled);

	return 0;
}

2.多继承中的虚函数表

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

观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中，具体的储存关系我们可以参考下图右下角部分的数据分布小图理解。