C++:多态

最新推荐文章于 2025-03-22 19:31:32 发布

爱心天使的守护

最新推荐文章于 2025-03-22 19:31:32 发布

阅读量1.3k

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/aixintianshideshouhu/article/details/88727084

一、多态的概念

1 概念
多态的概念：通俗来说，具体的就是去完成某个任务，当不同的对象去完成时会产生不同的状态。

1.1 举例：
比如买票这个行为，当普通人买票时，是买全价票；当学生买票时，是半价票；军人买票时是优先买票。
在比如：最近为了抢夺在线支付市场，支付宝在年底经常会做一些活动，比如扫红包-支付-给奖励金的活动。那么我们可以发现，不同的人扫出来的红包是不一样的。
其实这背后也是一个多态行为，支付宝首先会分析你的支付数据，比如你是新用户或者你没有经常使用支付宝，那么你就要鼓励你使用，你的扫码金额=random()%99, 在比如你经常使用支付宝支付或你的支付宝账户中常年没钱，那么就不太需要鼓励你去使用支付宝，那么你就扫码金额= random()%1。总结一下：同样是扫码动作，不同的用户扫到不一样的红包，这也是一种多态行为。

二、多态的定义和实现

2.1 多态定义和构成条件
多态是在不同的继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person.Person对象买全票，Student对象买半票.

在继承中要构成多态有两个条件：
1.调用函数的对象必须是指针或者引用
2.被调用的函数必须是虚函数，且完成了虚函数的重写。
在这里插入图片描述
什么是虚函数
虚函数：就是在类的成员函数的前面加virtual关键字。

class Person
{
public:
	virtual void BuyTicket()
	{
		cout<<"买票全价"<<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;
	}
};

不过范的重写行为
在派生类中重写的成员函数可以不加virtual关键字，也是构成重写的，因为继承后基类的虚函数别继承下来了在派生类依旧保持虚函数的属性，我们只是重写了它，但是这是非常不规范的.

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

析构函数的重写问题
基类中的析构函数如果是虚函数，那么派生类的析构函数就重写了基类的析构函数，这里它们的函数名不同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后的析构函数的名称统一处理为destructor，这也说明基类的析构函数最好写为虚函数。

基类的析构函数为什么要被定义为虚函数？
1，为了实现析构函数的多态。
2、因为一个父类的指针会指向一个子类对象，此时若父类的析构函数不是虚函数(根据类型调用析构函数）就会调用父类的析构函数，完成资源的清理和释放.

#include<iostream>
using namespace std;

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

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

重载、覆盖(重写)、隐藏(重定义)的对比
在这里插入图片描述

三、抽象类

在虚函数后面写上=0，则这个虚函数为纯虚函数，包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体出了接口继承。
纯虚函数只声明不实现
在继承的子类中重写
纯虚函数的作用:实现抽象类、体现接口继承、实现强制重写。

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

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

class BWM : public Car
{
public:
	virtual void Drive()
	{
		cout<<"BWM-操控"<<endl;
	}
};

void Test()
{
	Car* pBenz = new Benz;
	pBenz->Drive();

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

在这里插入图片描述

四、C++ overrride 和final

C++11提供override和final来修饰虚函数
实际中，建议多使用纯虚函数+override的方式来强制重写虚函数，因为虚函数的意义就是实现多态，如果没有重写，虚函数就没有意义。

//1、final修饰基类的虚函数不能被派生类重写
#include<iostream>
using namespace std;

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

运行上面的代码：报错：“Car::Drive”: 声明为“final”的函数无法被“Benz::Drive”重写

//2、override修饰派生类虚函数强制完成重写，如果没有重写会报错
class Car
{
public:
	virtual void Drive() {}
};
class Benz : public Car
{
public:
	virtual void Drive() override
	{
		cout << "Benz-舒适" << endl;
	}
};

五、多态的原理

5.1虚函数表

#include<iostream>
using namespace std;
//这里sizeof(Base)是多少？
class Base
{
public:
	virtual void Func()
	{
		cout << "Func()" << endl;
	}
private:
	int _b = 1;
};
int main()
{
	cout << sizeof(Base) << endl;
	system("pause");
	return 0;
}

运行上面的程序得到的结果是8.
通过观察测试我们发现b对象是8bytes，除了_b成员，还有一个_vdptr放在对象的前面(注意有些平台可能会放在对象的后面，这个和平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual)，f代表(function)，一个含有虚函数的类中都至少有一个虚函数指针，因为虚函数的地址要被放在虚函数表中，虚函数表也简称虚表，那么派生类中这个表放了些什么，我们继续往下分析。
在这里插入图片描述
针对上面的代码，我们做出改造
1、增加一个派生类Derive去继承Base
2、Drive中重写Func1
3、Base在增加一个虚函数Func2和一个普通函数Func3

#include<iostream>
using namespace std;
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
{
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};

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

在这里插入图片描述
通过观察和测试我们可以发现：
1、派生类对象d中也有一个虚表指针，d对象又两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分成员。
2、基类b对象和派生类d对象虚函数表是不一样的，这里我们可以发现Func1也完成了重写，所以d的虚表中存的是重写的Derive::Func1,所以虚函数的重写也叫做覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
3、另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但不是虚函数，所以不会放进虚表.
4、虚函数表本质是一个存虚函数指针的数组，这个数组最后放了一个nullptr
5、总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中。b.如果派生类重写了基类中的某个虚函数，用派生类自己的虚函数表中基类的虚函数。c.派生类自己增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
6、这里还有一个容易搞混的问题：虚函数存在哪？虚表存在哪？嗯，虚函数存在虚表，虚表存在对象中，注意这样的回答是错的。
虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样，都是存在代码段的，只是他的指针存到了虚表中，另外，对象中存的不是虚表，存的是虚表指针。那么虚表在哪呢？我们可以实际验证一下，我们可以发现vs下是存在代码段的。
在这里插入图片描述
通过上面的不同的区的地址可以发现，虚函数Func1的地址比静态成员的地址还低一些，而虚函数又不是数据，所以不应该放在数据段，应该放在代码段。

5.2多态的原理
上面分析了半天那么多态的原理到底是什么？还记的这里Func函数传Person::BuyTicket,传Studentl::调用的是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;
}

在这里插入图片描述
1、观察上图的红色箭头我们看到，p是指向Mike对象的，p->BuyTicket在Mike的虚表中找到的虚函数是Person::BuyTicket。
2、观察上图的蓝色箭头我们看到，p是指向Johnson对象的，p->BuyTicket在Johnson的虚表中找到的虚函数是Student::BuyTicket
3、这样就实现出了不同的对象去完成同一行为时，展现出不同的形态。
4、反过来思考，我们要达到多态，有两个条件：1、虚函数覆盖 2、一个是对象的指针或引用调用虚函数。
5、在通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是在运行起来以后到对象中去找的，不满足多态的函数调用是在编译是确认好的。

// 以下汇编代码中跟你这个问题不相关的都被去掉了
void Func(Person* p)
{
...
 p->BuyTicket();
// p中存的是mike对象的指针，将p移动到eax中
001940DE mov eax,dword ptr [p]
// [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
001940E1 mov edx,dword ptr [eax]
// [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
00B823EE mov eax,dword ptr [edx]
// call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象的
中取找的。
001940EA call eax 
00头1940EC cmp esi,esp 
}
int main()
{
// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调用转换成地址
时，是在编译时已经从符号表确认了函数的地址，直接call 地址
 mike.BuyTicket();
00195182 lea ecx,[mike]
00195185 call Person::BuyTicket (01914F6h) 
... 
}

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

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

嗯，在单继承和多继承关系中，我们关注的是派生类对象的虚表模型，因为基类的虚表模型前面已经研究过了。

6.1单继承中的虚函数表

#include<iostream>
using namespace std;

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的虚表呢，下面我们使用代码打印出虚表中的函数。
在这里插入图片描述

#include<iostream>
using namespace std;

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

	VFPTR* vTabled = (VFPTR*)*(int*)(&d);
	PrintVTable(vTabled);
	system("pause");
	return 0;
}

在这里插入图片描述

6.2：多继承中的虚函数表

#include<iostream>
using namespace std;

class Base1
{
public:
	virtual void func1()
	{
		cout << "Base1::func1()" << endl;
	}
	virtual void func2()
	{
		cout << "Base2::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();
	}
}
int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);

	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
	system("pause");
	return 0;
}

在这里插入图片描述
6.3：菱形继承，菱形虚拟继承
实际中我们不建议设计出菱形继承以及菱形虚拟继承，一方面态复杂，另一方面这样的模型，访问基类成员有一定的性能损耗.
C++ 虚函数表解析:https://coolshell.cn/articles/12165.html
C++ 对象的内存布局:https://coolshell.cn/articles/12176.html

七多态常见的面试题

1、什么是多态？
2、什么是重载，重写(覆盖)、重定义(隐藏)
3、多态的实现原理
4、inline函数可以是虚函数吗？不能，因为inline函数没有地址，无法把地址放在虚函数表中
5、静态成员函数可以是虚函数吗？不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
6、构造函数可以是虚函数吗? 不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
7、析构函数可以是虚函数吗？什么场景下析构函数时虚函数? 打答：可以，最好把基类的析构函数定义成虚函数。
8、对象访问普通函数块还是虚函数快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
9、虚函数表在什么阶段生成的，存在哪？答：虚函数是在编译阶段就生成的，一般情况下存在代码段(常量区)
10、C++菱形继承的问题？虚继承的原理？不要把虚函数表和虚基表搞混。
11、什么是抽象类？抽象类的作用？作用：强制重写虚函数，体现接口继承的关系。