多态（C++）

已于 2023-04-28 12:00:49 修改
阅读量338 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-04-06 21:38:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68006585/article/details/129936667
版权

多态

多态的概念

概念

多态即多种形态，当不同对象去执行同一个行为时，会产生不同的状态

多态的定义及实现

多态的构成条件

  1. 必须通过基类的指针/引用去调用虚函数（ virtual所修饰）
  2. 被调用的函数必须是虚函数，并且派生类必须对基类的虚函数进行重写

在这里插入图片描述

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

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

//多态调用
void Display(Person& p)
{
	p.Buyticket();
}

int main()
{
	Person pn;
	Display(pn);

	Student st;
	Display(st);
	return 0;
}

在这里插入图片描述

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

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

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

//普通调用
void Display(Person p)
{
	p.Buyticket();
}

int main()
{
	Person pn;
	Display(pn);
	Student st;
	Display(st);
	return 0;
}

在这里插入图片描述

虚函数

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

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

虚函数的重写

虚函数的重写：派生类中有一个和基类完全相同的虚函数，称派生类的虚函数重写了基类的虚函数

虚函数重写的两个例外

  1. 协变（基类与派生类虚函数返回值类型不同）
    派生类重写基类虚函数时，与基类虚函数返回值类型不同。也就是基类虚函数返回基类对象的指针/引用，派生类虚函数返回派生类对象的指针/引用
class Person
{
public:
	~Person()
	{
		cout << "~Person()" << endl;
		delete[] _p;
	}
protected:
	int* _p = new int[10];
};

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

int main()
{
	Person pn;
	Student st;
	return 0;
}

在这里插入图片描述

  1. 析构函数的重写（基类与派生类析构函数名不同）
    先观察如果析构函数不设置为虚函数
class Person
{
public:
	~Person()
	{
		cout << "~Person()" <<endl;
		delete[] _p;
	}
protected:
	int* _p = new int[10];
};

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

int main()
{
	Person pn;
	Student st;
	return 0;
}

在这里插入图片描述

运行起来似乎没有什么问题，做如下修改，结果又是如何

int main()
{
	Person* ptr1 = new Person;
	Person* ptr2 = new Student;

	delete ptr1;
	delete ptr2;
	return 0;
}

在这里插入图片描述

由运行结果可知，发生了内存泄漏，Student的资源并没有释放；delete的行为是：使用指针调用析构函数，由于是普通调用，函数与调用对象的类型有关，所以造成了内存泄漏；如果将函数设置为虚函数结构会怎么样呢？

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

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

在这里插入图片描述

内存泄漏的问题完美地解决

虽然函数名不同，这里其实是构成了虚函数的重写，编译器对析构函数的名称做了处理，编译后的析构函数的名称统一处理成 destructor

  1. 子类虚函数可以不加 virtual修饰（不推荐）

C++11override和final

  1. final：修饰虚函数，表示该虚函数不能被重写
  2. override：检查派生类虚函数是否重写了某类的某个虚函数，如果没有重写编译报错

重载，覆盖，隐藏的对比

在这里插入图片描述

抽象类

概念

在虚函数的后面加上=0，称这个函数为纯虚函数，包含纯虚函数的类称作抽象类，抽象类不能实例化对象；派生类继承后也不能实例化对象，只有重写纯虚函数，派生类才能实例化对象；纯虚函数规定了派生类必须重写

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

int main()
{
	Car c;
	return 0;
}

在这里插入图片描述

纯虚函数不可以实例化

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

class NIO : public Car
{
public:
	virtual void Drive()
	{
		cout << "安全驾驶" << endl;
	}
};

int main()
{
	NIO et7;
	et7.Drive();
	return 0;
}

在这里插入图片描述

接口继承和实现继承

普通函数的继承是是实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现；虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，构造多态，继承的是接口

多态的原理

虚函数表

class Base
{
public:
	virtual void Test()
	{
		cout << "Test()" << endl;
	}
private:
	int _a = 0;
};

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

按照以往的方式计算 Base类的大小：类中成员变量只有 int类型大小四个字节，成员函数 Test不占空间，所以类的大小应该是四个字节

运行结果如下

在这里插入图片描述

运行结果和预算的结果不一样，这是怎么回事呢？难道是成员函数也要计算大小吗？接下来，通过监视一探究竟

在这里插入图片描述

原来对象类中除了成员变量之外，还有_vfptr，也就是接下来要学习的虚函数表指针，想要学习指针，就先来了解虚函数表

虚函数表：用来存放虚函数，就如上面[0]中存放的就是Test的地址；本质就是函数指针数组

在这里插入图片描述

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

	virtual void Test2()
	{
		cout << "Car:Test2()" << endl;
	}
private:
	int _a = 0;
};

class NIO : public Car
{
public:
	virtual void Test1()
	{
		cout << "NIO:Test1()" << endl;
	}

private:
	int _b = 0;
};

int main()
{
	Car c;
	NIO et7;
	return 0;
}

在这里插入图片描述

完成重写的虚函数，表函数表对应位置覆盖成重写的虚函数

多态的原理

int main()
{
	Car c;
	NIO et7;
    
    //多态调用
	Car* ptr = &c;
	ptr->Test1();
	ptr = &et7;
	ptr->Test1();

    //普通调用
	ptr = &c;
	ptr->Test2();
	ptr = &et7;
	ptr->Test2();
	return 0;
}

运行结果如下

在这里插入图片描述

普通调用由调用对象类型决定：Test2()函数不是虚函数，调用类型是Car；多态调用由指针/引用指向的对象决定：Test1()函数是虚函数，两次调用指向的对象都不同

再通过汇编进行观察

在这里插入图片描述

普通调用在编译时就确定好的（静态）；多态调用在编译时是不确定的（动态）运行之后在，根据调用对象指向的类型，在表函数表中找到对应的函数进行调用

在这里插入图片描述

动态绑定与静态绑定

  1. 静态绑定，在程序编译期间就已经确定程序的行为，也称静态多态
  2. 动态绑定，在程序运行期间，根据具体的类型确定程序具体的行为，调用具体的函数，也称动态多态

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

单继承中的虚函数表

观察下列代码

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

	virtual void test2()
	{
		cout << "Car test2()" << endl;
	}

private:
	int _a;
};

class NIO:public Car
{
public:
	virtual void test1()
	{
		cout << "NIO test1()" << endl;
	}

	virtual void test3()
	{
		cout << "NIO test3()" << endl;
	}
	
private:
	int _b;
};

int main()
{
	Car c;
	NIO et7;
	return 0;
}

在这里插入图片描述

通过监视窗口能够发现：在派生类对象et7中重写了test1，继承了test2，但是本身的test3却没有，在内存窗口看到一个未知的地址，可以猜测是test3函数，现在就是想办法将其打印出来进行验证

上面了解到虚函数表本质是函数指针数组，接下来通过函数指针数组将虚函数表打印出来

typedef void(*_vfptr)();

void Print_vfptr(_vfptr vft[])
{
	for (int i = 0; vft[i] != nullptr; i++)
	{
		printf("[%d]:%p->", i, vft[i]);
		vft[i]();
	}
	cout << endl;
}

通过将对象进行取址再强转 int*获取前四个字节，在类型转换 _vfptr*传递给函数进行打印

	Print_vfptr((_vfptr*)*(int*)&c);
	Print_vfptr((_vfptr*)*(int*)&et7);

完整代码如下

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

	virtual void test2()
	{
		cout << "Car test2()" << endl;
	}

private:
	int _a;
};

class NIO:public Car
{
public:
	virtual void test1()
	{
		cout << "NIO test1()" << endl;
	}

	virtual void test3()
	{
		cout << "NIO test3()" << endl;
	}

private:
	int _b;
};

typedef void(*_vfptr)();

void Print_vfptr(_vfptr vft[])
{
	for (int i = 0; vft[i] != nullptr; i++)
	{
		printf("[%d]:%p->", i, vft[i]);
		vft[i]();
	}
	cout << endl;
}

int main()
{
	Car c;
	Print_vfptr((_vfptr*)*(int*)&c);

	NIO et7;
	Print_vfptr((_vfptr*)*(int*)&et7);

	return 0;
}

在这里插入图片描述

打印结果和预期一致

在这里插入图片描述

多继承中的虚函数表

class NIO
{
public:
	virtual void test1()
	{
		cout << "NIO test1()" << endl;
	}

	virtual void test2()
	{
		cout << "NIO test2()" << endl;
	}

private:
	int _a;
};

class XPENG
{
public:
	virtual void test1()
	{
		cout << "XPENG test1()" << endl;
	}

	virtual void test2()
	{
		cout << "XPENG test2()" << endl;
	}

private:
	int _b;
};

class NEA :public NIO, public XPENG
{
public:
	virtual void test1()
	{
		cout << "NEA test1()" << endl;
	}

	virtual void test3()
	{
		cout << "NEA test3()" << endl;
	}

private:
	int _c;
};

int main()
{
	NIO et7;
	XPENG p7;
	NEA car;
	return 0;
}

在这里插入图片描述

通过监视会发现与上面类似的疑问，派生类 NEA对象本身的虚函数存放在第一个基类 NIO中还是第二个基类 XPENG中呢？

接下来再次通过函数指针数组进行验证

typedef void(*_vfptr)();

void Print_vfptr(_vfptr vft[])
{
	for (int i = 0; vft[i] != nullptr; i++)
	{
		printf("[%d]:%p->", i, vft[i]);
		vft[i]();
	}
	cout << endl;
}

class NIO
{
public:
	virtual void test1()
	{
		cout << "NIO test1()" << endl;
	}

	virtual void test2()
	{
		cout << "NIO test2()" << endl;
	}

private:
	int _a;
};

class XPENG
{
public:
	virtual void test1()
	{
		cout << "XPENG test1()" << endl;
	}

	virtual void test2()
	{
		cout << "XPENG test2()" << endl;
	}

private:
	int _b;
};

class NEA :public NIO, public XPENG
{
public:
	virtual void test1()
	{
		cout << "NEA test1()" << endl;
	}

	virtual void test3()
	{
		cout << "NEA test3()" << endl;
	}

private:
	int _c;
};

int main()
{
	NIO et7;
	Print_vfptr((_vfptr*)*(int*)&et7);
	XPENG p7;
	Print_vfptr((_vfptr*)*(int*)&p7);
    
	NEA car;
	//NIO虚函数表
	Print_vfptr((_vfptr*)*(int*)&car);
	XPENG* ptr = &p7;
	//XPENG虚函数表
	Print_vfptr((_vfptr*)*(int*)ptr);
	return 0;
}

在这里插入图片描述

打印结果显示：派生类本身的虚函数是存放在第一个基类的虚函数表中的

在这里插入图片描述

“初生”
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于多态C++的职工管理系统.zip
12-22
包括全套的设计文档和教程
多态
qq_61434514的博客
10-29 976
重定义。
什么是多态？如何实现？
最新发布
AE_BD的博客
02-26 1092
继承重写当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。// 以 Cat 对象调用 show 方法// 以 Dog 对象调用 show 方法// 向上转型a.eat();// 调用的是 Cat 的 eat// 向下转型c.work();// 调用的是 Cat 的 worka.eat();// 类型判断。
多态（超详细）
qq_45794252的博客
07-28 150
java 多态 向上转型 向下转型 instanceof关键字
【C++】多态
weixin_51983604的博客
05-21 6694
文章目录概念一、多态的定义及实现1.多态的构成条件2.virtual关键字和虚函数3.虚函数重写4.虚函数重写的三个例外（1）协变（2）析构函数重写①不需要重写虚构函数②需要重写析构函数（3）子类的虚函数可以不用virtual修饰5.final6.override二、抽象类1.概念2.接口继承和实现继承2.读入数据总结 概念 通俗来说就是多种形态，具体一些就是对于某个行为，当不同的对象去完成时会产生出不同的状态。 再进一步到C++中，就是函数调用的多种形态，这一特性可以让我们在调用函数时更加灵活。 多态又
多态（polymorphic）
weixin_67807492的博客
11-13 1万+
多态是Java三大基本特征中最抽象也是最重要的特征。多态是建立在封装和继承衍生之上的。
继承+多态 C++职工管理系统，很好的学习案例
05-04
简单的课程设计作业。 员工分类boss manager employee，熟悉C++的继承以及多态的使用。
CPP.rar_多态 .cpp_继承与多态_继承与多态C++
09-23
本代码中有：“包含与继承”、“虚函数与多态”、“模板”程序例子
C++ 上课/复习ppt多态.pptx
09-30
C++ 上课/复习ppt多态.pptx
c++多态总结
08-30
c++多态总结，vptr总结，多态原理探究
多态的应用
03-05
此代码通过一个实例详细描述了多态的实现过程
多态（详解）
qq_51389068的博客
07-05 154
多态（详解）
多态的详解
m0_53677355的博客
09-06 425
在代码编译时，编译器无法知道基类的引用到底引用哪个类的对象，因此编译时无法确定要调用哪个类的方法，只有等到程序运行起来之后，才知道应该调用哪个类的方法。① 构造方法不能被重写：构造方法特殊，构造方法作用在调用对象时，由编译器调用，将对象中的成员初始化完整，只有对象真正创建好之后，才可以用其调用其他的方法实现多态，而对象真正创建好之后，构造方法已经调用完了 ，不可能再在构造方法上实现多态。例外：协变：被重写的方法返回值类型可以不同，返回值有要求：基类方法返回基类的引用，子类方法返回子类的引用。
Java中的多态
热门推荐
z972065491的博客
10-09 4万+
Java中的多态
面向对象-----多态
qq_46652775的博客
12-18 5661
1、多态的概念 （1）多态是面向对象的一个重要特征，指同一类事物同时具有多种形态，即同一类事物，在不同时刻，代表的对象不一样，指的是对象的多种形态。比如，对于笔记本电脑，它可以是苹果笔记本、华硕笔记本、弘基笔记本、神州笔记本。 （2）多态就是同一个行为具有多个不同表现形式或形态的能力，指的就是行为的多态。比如鸟类的飞行行为,鸽子,燕子,老鹰它们各自的飞行方式是不同的，再比如动物都有吃这个功能，但是它们吃的食物是不同的,老虎吃肉,牛吃草,猫吃猫粮,狗吃狗粮。 （3）多态就是同一个接口...
什么是多态?
buhuisuanfa的博客
08-14 1万+
多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作。
多态（polymorphism）
此后如竟没有炬火我便是唯一的光
08-19 767
多态 多态：不同的对象调用同一个方法可能会产生不同的行为 package com.chenxingen; class Pet{ String name;//宠物名 public Pet() { } public Pet(String name) { this.name = name; } public void eat(){ System.out.println("吃东西..."); } } class Cat e
什么是多态
qq_41348629的博客
02-09 3547
文字是复制的百度的，代码是自己敲的，便于理解。黑体字需要重点考虑。 可以理解一下文字之后，看我敲得代码。 这是多态的网址 多态首先是建立在继承的基础上的，先有继承才能有多态。多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法，即父类同一个方法，在继承的子类中表现出不同的形式。多态成立的另一个条件是在创建子类时候必须使用父类new子类的方式。 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述
面向对象的多态 C++
09-27
在C++中，实现多态的关键是通过使用虚函数（virtual function）。通过将基类中的函数声明为虚函数，子类可以重写这些函数以实现自己的特定行为。当通过基类的指针或引用调用这些函数时，会根据实际指向的对象类型来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值