C++多态

最新推荐文章于 2024-11-05 13:15:38 发布
最新推荐文章于 2024-11-05 13:15:38 发布
阅读量939 收藏 22
点赞数 18
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63236269/article/details/134856216
版权

多态的概念

        通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会
产生出不同的状态。 举个例子：比如 买票这个行为 ，当 普通人 买票时，是全价买票； 学生 买票时，是半价买票； 军人 买票时是优先买票。

多态的定义及实现

        多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student 继承了
Person 。 Person 对象买票全价， Student 对象买票半价。
在继承中要 构成多态还有两个条件 ：
1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

虚函数和虚函数的重写

        虚函数：即被virtual 修饰的类成员函数称为虚函数。 
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "buy full price ticket" << endl;
	}
};
虚函数的重写 ( 覆盖 ) ： 派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的
返回值类型、函数名字、参数列表完全相同) ， 称子类的虚函数重写了基类的虚函数。 
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "buy full price ticket" << endl;
	}
};
class Student:public Person
{
public:
	virtual void BuyTicket()
	{
		cout<<"Buy at half price ticket"<<endl;
	}
};
void test1(Person&p)
{
	p.BuyTicket();
}
int main()
{
	Person p1;
	test1(p1);

	Student s;
	test1(s);
	return 0;
}

虚函数重写的两个例外

协变
派生类重写基类虚函数时，与基类虚函数返回值类型不同。 即基类虚函数返回基类对象的指
针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。 
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关键字，
都与基类的析构函数构成重写 ，虽然基类与派生类析构函数名字不同。虽然函数名不相同，
看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处
理，编译后析构函数的名称统一处理成 destructor 。 
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;
}

编译后析构函数的名称统一处理成destructor

C++11 override 和 final  

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

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

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

抽象类 

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

接口继承和实现继承  

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

多态的原理  

虚函数表  

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "buy full price ticket" << endl;
	}
	virtual void Func()
	{
		cout << "Func" << endl;
	}
	int a = 0;
};
class Student:public Person
{
public:
	virtual void BuyTicket()
	{
		cout<<"Buy at half price ticket"<<endl;
	}
	int b = 0;
};
void test(Person&p)
{
	p.BuyTicket();
}
int main()
{
	Person p1;
	test(p1);

	Student s1;
	test(s1);
	cout << endl;
	return 0;
}

我们发现对象里面有一个_vfptr，对象中的这个指针我们叫做虚函数表指针(v代 表virtual，f代表function)。

 原理

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "buy full price ticket" << endl;
	}
	virtual void Func()
	{
		cout << "Func" << endl;
	}
	int a = 0;
};
class Student:public Person
{
public:
	virtual void BuyTicket()
	{
		cout<<"Buy at half price ticket"<<endl;
	}
	int b = 0;
};
void test(Person&p)
{
	p.BuyTicket();
}
int main()
{
	Person p1;
	test(p1);

	Student s1;
	test(s1);
	cout << endl;
	return 0;
}

1. 观察图的箭头我们看到，p是指向p1对象时，p->BuyTicket在p1的虚表中找到虚函数是Person::BuyTicket。
2. 观察图的蓝色箭头我们看到，p是指向s1对象时，p->BuyTicket在s1的虚表中 找到虚函数是Student::BuyTicket。
3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。 

看出满足多态以后的函数调用，不是在编译时确定的，是运行 起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

动态绑定与静态绑定  

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

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

单继承中的虚函数表  

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;
	VFPTR * vTableb = (VFPTR*)(*(int*)&b);
	PrintVTable(vTableb);
	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
	PrintVTable(vTabled);
	cout << endl;
	return 0;
}

我们可以通过运行结果得知其结构。

多继承中的虚函数表 

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);
cout << endl;
	return 0;
}

同理：

课后练习 

 1、p1,p2,p3大小关系？

class Base1 
{ 
public:
	int _b1 = 0; 
};
class Base2
{
public:
	int _b2 = 0;
};
class Derive : public Base1, public Base2 
{ public: int _d = 0; };
int main() 
{
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	return 0;
}

 2，下面程序输出结果为？

#include <iostream>
using namespace std;
class A {
public:
	A(char* s) { cout << s << endl; }
	~A() {}
};
class B : virtual public A {
public:
	B(char* s1, char* s2) : A(s1) { cout << s2 << endl; }
};
class C : virtual public A {
public:
	C(char* s1, char* s2) : A(s1) { cout << s2 << endl; }
};
class D : public B, public C {
public:
	
	D(char* s1, char* s2, char* s3, char* s4) :  B(s1, s2), C(s1, s3),A(s1){
		cout << s4 << endl;
	}
};
int main() {
	D* p = new D ("class A", "class B", "class C", "class D");
	delete p;
	return 0;
}

答案 

1，通过监视窗口我们可以观察到如图。

可得出其结构为：

2，

在C++中，当一个类通过虚拟继承另一个类时，最远的基类（在这里是A）会首先被初始化。这是为了确保基类只被初始化一次，以避免数据的冗余和不一致。B和C都是从A虚拟继承而来，D则从B和C继承。因此，当创建D类的对象时，首先会调用A类的构造函数，然后按照声明的顺序（class D : public B, public C）调用B和C的构造函数，最后调用D的构造函数。

L Water
关注
c++中的多态解析
龙跃十二
04-22 817
虚函数和多态 虚函数 定义：类的成员函数前面加virtual关键字，则这个成员函数称为虚函数。 代码示例： 虚函数重写 定义:当在子类的定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写（也称覆盖）了父类的这个虚函数。 代码示例： 多态 定义：一个对象呈现多种形态 代码示例： 虚函数和多态 虚函数 定义：类的成员函数前面加virtual关键字，则...
C++ 多态 超详细讲解
热门推荐
qq_53558968的博客
05-18 5万+
文章目录多态概念引入1、C++中多态的实现1.1 多态的构成条件1.2 虚函数1.3虚函数的重写1.4 C++11 override && final1.5 重载，覆盖(重写)，重定义（隐藏）2、抽象类2.1 抽象类的概念2.2 接口继承和实现继承3、 多态的原理3.1 虚函数表3.2多态的原理3.3动态绑定与静态绑定4 、继承中的虚函数表4.1 单继承中的虚函数表4.2 多继承中的虚函数表other 一些有意思的题目 多态概念引入 多态字面意思就是多种形态。 我们先来想一想在日常生活中
C++ 多态
jun8086的博客
10-31 684
c++ 多态
C++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
C++多态详解
lim6ere的博客
03-29 966
我们知道C++语言的三大特性（封装，继承，多态）在之前的文章中我们已经学习了封装和继承，在这篇文章中我们将会学习到有关多态的相关问题。这两个关键字是c++11新增的🌟重载：同一作用域中，函数名相同，函数参数不同的函数🌟 重定义（隐藏）：父类和子类两个不同的作用域，只要父类和子类的函数名相同就可以。🌟重写（覆盖）：两个函数分别在子类和父类的作用域，两个函数必须是虚函数，这两个函数函数名，参数，返回值相同（有例外，特殊考虑）。🌟如果子类和父类中既满足重写又满足隐藏，重写优先。
c++多态 详解
qq_39117115的博客
03-09 1205
综上：如果满足多态，看指向对象的类型，调用这个类型的成员函数如果不满足多态， 看调用者类型，调用这个类型的成员函数解释：满足多态的情况下，我们定义Parent * p= new student，这个会调用Student的发生重写的函数我们定义Parent *p =new Parent ，这个会调用Parent中被重写的函数不满足多态的情况下，我们定义Student *s =new Student，这个会调用Student的函数。
C++ 多态类型
索命的博客
11-06 539
C++ 多态入门
C++多态的理解
天使之翼
10-09 894
height = b;return 0;
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
C++多态的实现机制深入理解
12-26
在面试过程中C++的多态实现机制经常会被面试官问道。大家清楚多态到底该如何实现吗？下面小编抽空给大家介绍下多态的实现机制。 1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2. 存在虚...
C++ 多态的游戏例程
01-20
1）头文件 game.h #ifndef GAME_H #define GAME_H // base class class CCreature { protected: int m_nLifePower， m_nPower; public: virtual void Attack(CCreature *pCreature){} virtual void Hurted...
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
xcx003的博客
11-02 582
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
C 学习（4）
search7的博客
11-05 535
C语言学习，每个模块来自工作中的？？？
西南科技大学C++作业1——组合依赖关系实验代码
最新发布
m0_74312676的博客
11-05 482
合理设计类与类的组合关系，即一个类要嵌套另一个类的对象作为成员变量，根据问题的需要可以是同一个类的多个对象(可以使用对象数组)，也可以是不同类的多个不同对象。让所设计的功能发挥作用。对学生和图书进行抽象，抽象出应有的成员变量，和基本的初始化，修改等成员函数，学生可以发起借书的操作，这是一种依赖关系，在学生类中将设计相应的成员函数体现这一功能操作，合理即可，可以用输出借书是否成功的结果，有一定示意就可以。其他操作：计算得到正确答案，输入自己的题目的答案，向题库内增加题目，在题库内删除题目，查询题库的题目。
每日OJ题_牛客_排序子序列_模拟_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-02 347
每日OJ题_牛客_排序子序列_模拟_C++_Java（根据题意用指针模拟即可）
C++ -- 模板进阶
zy1215058242的博客
11-02 826
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
c++ 多态
05-25
C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。 C++中的多态性有两种：静态多态和动态多态。 1. 静态多态 静态多态是指在编译时就已经确定了函数的调用，也称为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值