多态（C++）

最新推荐文章于 2024-06-09 20:18:37 发布

浅碎时光807

最新推荐文章于 2024-06-09 20:18:37 发布

阅读量508

点赞数 21

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2302_78639896/article/details/138742924

版权

C++语法专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

一.多态的概念
二.重载,覆写（重写），隐藏（重定义）的对比
三.底层
- 虚函数存在哪？
四.单继承和多继承关系的虚函数表
- 单继承中的虚函数表
- 多继承中的虚函数表
五.抽象类
- 接口继承和实现继承
六.菱形继承、菱形虚拟继承

一.多态的概念

举个简单的例子：买火车票，学生，军人，儿童都是买票，但价格不一样。
同样干一件事情，不同类的对象，差别挺大的
代码：传的都是同一个函数，但效果不一样

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 ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

在这里插入图片描述

虚函数

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

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

虚函数的重写

虚函数重写需要三同：函数名，参数，返回值
也称子类的虚函数重写了父类的虚函数

构成多态的两个条件

1.父子类完成虚函数的重写
2.父类的指针或者引用取调用虚函数
如果不是指针和引用，那就不是多态了：
在这里插入图片描述
但又有两个例外：

协变：

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

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

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

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

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

这里调用自己的指针也行：

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

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

在这里插入图片描述

析构函数的重写

引例：

class Person
{
public:
	Person()
	{
		cout << "Person()" << endl;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
};

class Student : public Person
{
public:
	Student()
	{
		cout << "Student()" << endl;
	}
	~Student()
	{
		cout << "~Student()" << endl;
	}
};

int main()
{
	Person* ps = new Person;
	Person* st = new Student;
	delete ps;
	delete st;
	return 0;
}

运行会发现，st调用的是Person的析构，并且Person的析构掉了两次，但构造函数调用了三次
在这里插入图片描述
看似没问题，如果st是这样的，那么调不到st的析构就会产生内存泄漏

class Student : public Person
{
public:
	~Student()
	{
		delete[] _ptr;
		cout << "~Student" << endl;
	}
private:
	int* _ptr = new int[10];
};

画个图：
在这里插入图片描述
我们所期望的是父类调用父类的析构函数，子类调用子类的析构函数，次数一样
编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。所以构成重写，变成了：
ps->destructor + operator delete(ps);
st->destructor + operator delete(st);

class Person
{
public:
	//destructor
	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}
};

class Student : public Person
{
public:
	//destructor
	virtual ~Student()
	{
		delete[] _ptr;
		cout << "~Student" << endl;
	}
private:
	int* _ptr = new int[10];
};

在这里插入图片描述

所以在写继承函数的析构时，最好加上virtual
其实还有第三个例外，子类不写virtual也可以重写

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

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

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

在这里插入图片描述
一个题：
以下程序会输出什么：A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

#include <iostream>

using namespace std;

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

这里选B
在这里插入图片描述
首先父类和子类的函数名，参数，返回值相同，所以构成虚函数重写，跟缺省参数无关
然后这里test的this指针是A的，继承只是一个说法，实践中不会把A(父类)的函数直接弄下来，先在B(子类)查找，后在A(父类)查找，这也是函数同名构成隐藏的原因，体会一下。
在这里插入图片描述
之后this->func()明显的构成多态，因为this是父类指针，同时func()构成重写,调用的B的func()
最后构成多态重写的实现，缺省值不动，函数的结构部分(函数名参数返回值等)用的是父类

不建议缺省值这么写，要么一样，要么不写

override 和 final

final

如果不想一个类被继承的话，加个final
在这里插入图片描述
上面这个final用法不常用
如何让一个类不能被继承
C++98的方法：父类的构造函数私有，子类的构造无法生成和实现，导致子类对象无法实例化

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

class Benz : public Car
{
public:
	virtual void Dirve() { cout << "Benz" << endl; }
};

C++11的方法是用final修饰的类叫做最终类，不能被继承

class Car final
{
public:
	Car()
	{}
};

class Benz : public Car
{
public:
	virtual void Dirve() { cout << "Benz" << endl; }
};

override

检查子类虚函数是否重写了父类某个虚函数，如果没有重写编译就报错
例子：
在这里插入图片描述
把父类的virtual也会报错

二.重载,覆写（重写），隐藏（重定义）的对比

在这里插入图片描述

三.底层

引例：下面代码会输出多少，在x86的环境下

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

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

是12
在这里插入图片描述
实例化一个对象，通过调试看以下
有个指针，叫做虚函数表指针，简称虚表指针（只要有虚函数就有这个）

以下面这串代码为例

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

在这里插入图片描述
通过调试我们可以看出

这个东西是用来实现多态的
接下来以这串代码来讲解如何实现多态

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

在这里插入图片描述
画个图

同类型的对象虚表共用的是一个。

虚函数存在哪？

虚函数跟普通函数一样，都是存在代码段，不是存在虚表的
虚表中存的仅仅是虚函数地址
那虚表存在哪个区域的？（栈、堆、常量区、静态区）
首先进程运行中只关心指令
进程->指令
类->实例化对象->指令
函数->指令
肯定不是栈，栈用完就删
通过以下代码对比一下：

int main()
{
	int i = 0;
	static int j = 1;
	int* p1 = new int;
	const char* p2 = "xxxxxxxx";
	printf("栈:%p\n", &i);
	printf("静态区:%p\n", &j);
	printf("堆:%p\n", p1);
	printf("常量区:%p\n", p2);

	Person p;
	Student s;
	Person* p3 = &p;
	Student* p4 = &s;

	printf("Person虚表地址:%p\n", *(int*)p3);
	printf("Student虚表地址:%p\n", *(int*)p4);

	return 0;
}

发现跟常量区的地址很相近
在这里插入图片描述

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

单继承中的虚函数表

例子：

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

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

通过监视窗口就会发现b是正常的,d只有b继承过来的
在这里插入图片描述
这是VS的工程师故意的应该，看内存就能看见其余两个虚函数的地址

那么如何确定后面两个指针分别对应的是func3，func4
打印虚表的程序：
虚函数表本质是一个函数指针数组

//函数指针
void (*p)();
//函数指针数组
void (*p[10])();

太长了，typedef一下：

typedef void(*VFPTR)();
//函数指针
VFPTR p1;
//函数指针数组
VFPTR p2[10];

那么还有一个问题，如何拿到虚函数表第一个地址
强转：

Derive d;
VFPTR* prt = (VFPTR*)(*(int*)&d);

这就是成品：

void PrintVFT(VFPTR* ptr)
{
	for (size_t i = 0;i<4;i++)
	{
		printf("%p\n",ptr[i]);
	}
}

int main()
{
	Base b;
	Derive d;
	VFPTR* ptr = (VFPTR*)(*(int*)&d);
	PrintVFT(ptr);
	return 0;
}

在这里插入图片描述
除了打印指针还能调用函数

再个a一个1，b一个2的值，就能清楚看出其的储存方式

多继承中的虚函数表

引例：以下代码会输出什么，sizeof(Derive)多大

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

class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2 = 2;
};

class Derive :public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1 = 3;
};

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

答案是20
在这里插入图片描述
它是这样的

那么子类中的func1与func3存在哪里
用以下代码查看：

typedef void(*VFPTR)();
void PrintVTable(VFPTR vTable[])
{
	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%p,->", 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)));
	//切片也可以搞出第二个虚函数表的地址
	//VFPTR* vTableb2 = (VFPTR*)(*(int*)ptr);
	PrintVTable(vTableb2);
	return 0;
}

在这里插入图片描述
看出func3放进来第一个虚函数表中

五.抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。
在这里插入图片描述
继承了也实例化不出对象

有什么意义呢？
就是强制子类完成重写

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

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

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

抽象类与override的区别是
抽象类是强制子类重写虚函数
override已经重写，在语法上检查是否有错误

接口继承和实现继承

就做个了解：
普通函数的继承是一种实现继承，子类继承了父类函数，可以使用函数，继承的是函数的实现。
虚函数的继承是一种接口继承，子类继承的是父类虚函数的接口，目的是为了重写，达成多态，继承的是接口。
所以如果不实现多态，不要把函数定义成虚函数。
在这里插入图片描述
这里区分一下虚表和虚基表
虚表：虚函数表，存的虚函数，目标实现多态
虚基表：存的当前位置距离虚基类部分的偏移量，解决菱形继承数据冗余和二义性

六.菱形继承、菱形虚拟继承

引例：先以菱形继承为例，以下代码多少个字节

class A
{
public:

	virtual void func1() { cout << "A::func1" << endl; }

	int _a;
};

class B : public A
{
public:
	virtual void func2() { cout << "B::func2" << endl; }

	int _b;
};

class C : public A
{
public:
	virtual void func3() { cout << "C::func3" << endl; }

	int _c;
};

class D : public B, public C
{
public:
	virtual void func4() { cout << "D::func4" << endl; }

	int _d;
};

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

28个字节
在这里插入图片描述
画个图：

菱形虚拟继承：
以下代码输出的多少？

class A
{
public:

	virtual void func1() { cout << "A::func1" << endl; }

	int _a;
};

class B : virtual public A
{
public:
	virtual void func2() { cout << "B::func2" << endl; }

	int _b;
};

class C : virtual public A
{
public:
	virtual void func3() { cout << "C::func3" << endl; }

	int _c;
};

class D : public B, public C
{
public:
	virtual void func4() { cout << "D::func4" << endl; }

	int _d;
};

int main()
{
	D d;
	cout << sizeof(d) << endl;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

36个字节
在这里插入图片描述

虚基类A是共享的
以上了解以下即可

浅碎时光807

关注

21
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
0
评论
多态（C++）

引例：下面代码会输出多少，在x86的环境下class Basepublic:private:int _b = 1;是12实例化一个对象，通过调试看以下有个指针，叫做虚函数表指针，简称虚表指针（只要有虚函数就有这个）以下面这串代码为例class Basepublic:private:int _b = 1;return 0;通过调试我们可以看出这个东西是用来实现多态的。
复制链接

扫一扫