1. AI技术聚合首页
  2. IT

【C++】多态

扎眼的阳光 • • IT • 阅读 34

个人主页 ： zxctscl
如有转载请先通知

文章目录

  • 1. 多态的概念
  • 2. 多态的定义及实现
    • 2.1多态的构成条件
    • 2.2 虚函数
    • 2.3 虚函数的重写
    • 2.4 笔试题
    • 2.5 C++11 override 和 final
    • 2.6 重载、覆盖(重写)、隐藏(重定义)的对比
  • 3. 多态的原理
    • 3.1 虚函数表
    • 3.2 多态的原理
  • 4. 单继承和多继承关系的虚函数表
    • 4.1 单继承中的虚函数表
    • 4.2 多继承中的虚函数表
  • 5. 抽象类

1. 多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。



举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。
再举个栗子： 最近为了争夺在线支付市场，支付宝年底经常会做诱人的扫红包-支付-给奖励金的
活动。那么大家想想为什么有人扫的红包又大又新鲜8块、10块…，而有人扫的红包都是1毛，5
毛…。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如
你没有经常支付宝支付等等，那么你需要被鼓励使用支付宝，那么就你扫码金额 =random()%99；比如你经常使用支付宝支付或者支付宝账户中常年没钱，那么就不需要太鼓励你去使用支付宝，那么就你扫码金额 = random()%1；总结一下：同样是扫码动作，不同的用户扫得到的不一样的红包，这也是一种多态行为。ps：支付宝红包问题纯属瞎编，大家仅供娱乐。

2. 多态的定义及实现

2.1多态的构成条件

不同的人做同一件事情，多种形态，结果是不一样的。

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了
Person。Person对象买票全价，Student对象买票半价。
那么在继承中要构成多态还有两个条件：

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写(要求三同，三同指的是：函数名、参数、返回值)
#include<iostream>
using namespace std;

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

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


void Func(Person& p)
{
	
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);
	return 0;
}

2.2 虚函数

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

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

2.3 虚函数的重写

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

多态要满足的两个条件：

  1. 虚函数的重写（父子类虚函数，要求三同）
  2. 父类的指针或者引用去调用。

虚函数重写的两个例外：

  1. 协变(基类与派生类虚函数返回值类型不同)
    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
#include<iostream>
using namespace std;

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

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


void Func(Person& p)
{
	
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);
	return 0;
}

如果不是多态结果显示的都是全价，是多态一个全价一个半价：

如果没有继承关系是不行的：


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

#include<iostream>
using namespace std;

class A {};
class B : public A {};

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

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

	virtual ~Student() 	{ cout << "~Student()" << endl;}
};


void Func(Person& p)
{	
	p.BuyTicket();
}

int main()
{
	Person p;
	Student s;
	return 0;
}

先调用子类的析构，子类的析构完了会自动调用父类，先子后父。

但是有关场景：
Person的指针既可以指向父类也可以指向子类。

#include<iostream>
using namespace std;

class A {};
class B : public A {};

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

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

	 ~Student() 	{ cout << "~Student()" << endl;}
};


void Func(Person& p)
{	
	p.BuyTicket();
}

int main()
{	
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;

	return 0;
}

这里就没有调到子类的析构：
不符合多态的时候调用：析构+operator delete(p1)，p1和p2是什么类型的就掉什么类型的。

怎么写的话，如果子类中的对象就没有被析构，只调了父类的：

但我们想要的是指针指向父类调父类析构，指向子类调子类析构，而多态就可以做到，所以要满足虚函数的重新，底层的析构就都改成了destructor，加上virtual就构成了重写：

#include<iostream>
using namespace std;

class A {};
class B : public A {};

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

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

	virtual ~Student()
	 {
		cout << "delete[]" << _ptr<<endl;
		 delete[] _ptr;
		 cout << "~Student()" << endl;
	 }

private:
	int* _ptr = new int[10];
};


void Func(Person& p)
{	
	p.BuyTicket();
}

int main()
{	
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;

	return 0;
}


建议把析构函数写出虚函数，防止发生内存泄漏。

析构函数的名称统一处理成destructor，就是为了让子类函数构成重写。

  1. 派生类重写的虚函数可以不加virtual。建议都写上
    继承的是父类的函数里面已经有virtual，重写的是实现。
class A {};
class B : public A {};

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


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

	 ~Student()
	 {
		cout << "delete[]" << _ptr<<endl;
		 delete[] _ptr;
		 cout << "~Student()" << endl;
	 }

private:
	int* _ptr = new int[10];
};


void Func(Person& p)
{	
	p.BuyTicket();
}

int main()
{	
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;

	return 0;
}

2.4 笔试题

来看看有几道道就是关于虚函数的题目：

  1. 下面代码执行的结果：
    A: A->0 B : B->1 C : A->1 D : B->0 E : 编译出错 F : 以上都不正确
class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }

	virtual void test() { func(); }
};

class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();

	return 0;
}

来看一下运行结果：

fun函数构成重写：

这里test()的指针是A*，继承是一种形象的说法，实践中不会弄到子类中。派生类调用test的时候先去派生类查找，派生类中没有test,然后去父类查找，有就调用，没有就报错。·

这里符合多态的调用，A*是父类的指针，也有虚函数，

多态就是指向谁调用谁，这里就是调用子类的fun()：

但是这里调用子类的时候这里的val没有用子类的缺省参数而是父类的，原因在于：当构成多态调用的时候，重写的是函数体实现，函数的结构部分（函数名、参数、返回值）用的是父类的。


2. 多继承中指针偏移问题？下面说法正确的是( )
A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };

int main() {
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;

	return 0;
}

结果选C

把这个代码做个变化：

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base2, public Base1 { public: int _d; };

int main() {
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;

	return 0;
}

此时：
p2和p3的地址就是相同的：

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

  1. override: 加到子类虚函数的重写，检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错
class Car {
public:
	virtual void Drive() {}
};
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

可以快速的检查：

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

3. 多态的原理

3.1 虚函数表

这里常考一道笔试题：sizeof(Base)是多少？

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
	char _ch = 'x';
};

int main()
{
	cout << sizeof(Base) << endl;
	return 0;
 }


除了_b成员，还多一个_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。
只要有虚函数就有虚函数指针。

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

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

虚函数表，所有虚函数的指针都往里放。

  1. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
  2. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

3.2 多态的原理

那么是如何实现传父类调用的父类，传子类调用的子类？


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

private:
	int _i = 1;
};

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


	int _j = 2;
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person Mike;
	Func(Mike);
	Student Johnson;
	Func(Johnson);
	return 0;
}

Person:

Student:指向父类对象会发生切片，把父类的那一部分给切出来

从fun的角度看到的都是 BuyTicket()


如果满足多态条件：那么这里就调用生成的指令，就会去指向对象的虚表中找对应虚函数进行调用。
指向父类，在虚函数表里面就找到父类的虚函数。如果指向子类，就在子类中找到被重写的虚函数。最终达到的目的就是执行谁调用谁，运行去虚表中找对应的虚函数调用，指向父类调用父类的虚函数，指向子类调用子类的虚函数。


p中存的是mike对象的指针，将p移动到eax中。
[eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx。
[edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax。
call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象的中取找的。

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

private:
	int _i = 1;
};

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


	int _j = 2;
};
void Func(Person* p)
{
	p->BuyTicket();
}

不满足多态，编译链接根据调用的对象类型，确定调用的函数，确定函数的地址，通过类型就确定是父类就在父类中找，是子类就在子类中找。

4. 单继承和多继承关系的虚函数表

4.1 单继承中的虚函数表

class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a=1;
};

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

观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。
但在内存窗口中发现：内存中疑似有但是又不能确认


为了验证，写一个程序打印一下虚表。
虚函数表本质是一个函数指针数组，

class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a=1;
};

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


// 打印对象虚表
typedef void(*VFPTR)();

// 打印函数指针数组
// virtual function table
//void PrintVFT(VFPTR vft[])
void PrintVFT(VFPTR* vft)
{
	for (size_t i = 0; i < 4; i++)
	{
		printf("%p->", vft[i]);

		VFPTR pf = vft[i];
		(*pf)();
		//pf();
	}
}

int main()
{
	Base b;
	Derive d;

	//int ptr = (int)d; // 不支持转换，只有有关联的类型才能互相转
	VFPTR* ptr = (VFPTR*)(*((int*)&d));
	PrintVFT(ptr);

	// 函数指针
	void (*p1)();
	VFPTR p2;

	// 函数指针数组
	void (*pa1[10])();
	VFPTR pa2[10];


	return 0;
}

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

观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中：

5. 抽象类

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

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

	return 0;

}

抽象类不能示例化出对象，间接强制派生类重写虚函数。
override已经重写了，帮助检查语法是否有问题。

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

有问题请指出，大家一起进步！！！

版权声明：本文为博主作者：zxctscl原创文章，版权归属原作者，如果侵权，请联系我们删除！

原文链接：https://blog.csdn.net/zxctsclrjjjcph/article/details/137884010

共计人评分，平均分

到目前为止还没有投票！成为第一位评论此文章。

赞 (0)
扎眼的阳光的头像扎眼的阳光普通用户
0
上一篇 2024年5月6日
下一篇 2024年5月6日

相关推荐