【C++】多态

最新推荐文章于 2024-07-04 11:10:43 发布
最新推荐文章于 2024-07-04 11:10:43 发布
阅读量708 收藏 21
点赞数 30
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73614724/article/details/136700286
版权

文章目录

1. 多态

1.1 多态的概念

多态：字面意思就是多种形态。不同对象做不同事情时所产生的不同状态。

1.2 多态的定义及实现

1.2.1 多态的实现

实现多态需要两个条件：

  1. 被调用的函数是虚函数，并且派生类的虚函数是重写的虚函数。
  2. 通过基类的指针或者引用调用虚函数。
#define _CRT_SECURE_NO_WARNINGS

#include<iostream>

using namespace std;

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

class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "学生票半价" << endl;
	}
};
//多态实现条件：
//1.派生类和基类的成员函数都是虚函数，而且三同（函数名，参数列表，返回值类型）
//2.调用时必须是基类的指针或者引用
void CheckTicket(Person& p)//普通对象就会调用本身的成员函数
{
	p.BuyTicket();
}

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

1.2.2 虚函数的定义

虚函数：在返回值类型前加了virtual的类成员函数。

class Person
{
public:
    virtual void BuyTicket()//虚函数
    {
        cout << "全价" << endl;
    }
}

1.2.3 虚函数的重写（覆盖）

虚函数的重写（覆盖）：在基类与派生类的关系中，基类的虚函数与派生类的虚函数 函数名、返回值类型和参数列表相同，这样才完成了虚函数的重写。

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

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

重写的两种特殊情况：1. 协变 2. 析构函数的重写

协变：协变的特殊在返回值可以不同，基类的返回类型必须是基类指针或者引用，派生类的返回类型必须是派生类指针或者引用（基类于派生类指针与指针对应，引用与引用对应）。

#include<iostream>

using namespace std;

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

class Student : public Person
{
public:
	Student* BuyTicket()
	{
		cout << "学生票半价" << endl;
		return 0;
	}
};

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

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

析构函数的重写

阅读以下代码：

#include<iostream>

using namespace std;

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

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

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

在这里插入图片描述

阅读以下代码：

#include<iostream>

using namespace std;

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

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

void Destructor(Person& p)
{
	p.~Person();
}

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

在这里插入图片描述

解释：在运行时，析构函数被处理成函数名为Destructor的函数，所以基类和派生类的析构函数符合重写。

**说明：**在写多态时，推荐将析构函数重写，因为有一些情况需要调用自己类的析构函数！

1.2.4 C++11中的override和final

override：检查某个类的成员函数是否完成了虚函数的重写，没有重写编译时会报错。

#include<iostream>

using namespace std;

class Person
{
public:
    //BuyTicket不是虚函数
	void BuyTicket()
	{
		cout << "全价" << endl;
	}
};

class Student : public Person
{
public:
	virtual void BuyTicket() override//没有完成重写就会报错
	{
		cout << "学生票半价" << endl;
	}
};

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

在这里插入图片描述

final：可以让虚函数不能被重写，也可以让类不能被继承。

#include<iostream>

using namespace std;

class Person final //让这个类不能被继承
{
public:
	virtual void BuyTicket() final //让这个虚函数不能被重写
	{
		cout << "全价" << endl;
	}
};

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

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

在这里插入图片描述

在这里插入图片描述

1.2.5 函数重载，虚函数的重写（覆盖），函数的重定义

在这里插入图片描述

2. 多态的原理

2.1 虚函数表

#include<iostream>

using namespace std;

class Person 
{
public:
	virtual void BuyTicket() 
	{
		cout << "全价" << endl;
	}
private:
	int _a = 0;
};

class Student : public Person
{
public:
	virtual void BuyTicket() 
	{
		cout << "学生票半价" << endl;
	}
private:
	int _b = 1;
};

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

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

1

通过监视发现对象p和对象s中，各有一个_vfptr在成员变量前（不同编译器可能不同）。

这个_vfptr我们称之为虚函数表指针（virtual function ptr）（应该加一个table）。

一个具有虚函数的类中至少有一个虚函数表，虚函数的地址存在虚函数表中，虚函数表简称虚表。

#include<iostream>

using namespace std;
class Person 
{
public:
	virtual void BuyTicket() 
	{
		cout << "全价" << endl;
	}
	virtual void Func1()
	{
		cout << "Person::Func1" << endl;
	}
private:
	int _a = 0;
};

class Student : public Person
{
public:
	virtual void BuyTicket() 
	{
		cout << "学生票半价" << endl;
	}
private:
	int _b = 1;
};

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

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

在这里插入图片描述

根据以上代码和监视我们可以发现：

  1. 两个对象创建时会产生两个虚表。其中BuyTicket函数完成了重写，所以两个虚表中BuyTicket函数地址不相同，而Func1函数没有完成重写，所以s对象直接从p对象继承了Func1函数。
  2. 实际上虚表是一个指针数组，一般来说这个数组最后面放了一个nullptr。
  3. 虚表称为虚函数表。虚表存的是虚函数指针，虚函数存在代码段中（常量区），对象存的是虚表指针。
  4. 派生类的虚表：先将基类的虚表拷贝一份到派生类中，然后发现派生类对其中的虚函数进行了重写，所以就会覆盖基类的虚函数。派生类自己的虚函数按照声明序列依次增加到虚表的最后。

2.2 多态的原理

那么为什么学生买票就是半价？普通人买票就是全价？多态的原理是什么？

#include<iostream>

using namespace std;

class Person 
{
public:
	virtual void BuyTicket() 
	{
		cout << "全价" << endl;
	}
	virtual void Func1()
	{
		cout << "Person::Func1" << endl;
	}
private:
	int _a = 0;
};

class Student : public Person
{
public:
	virtual void BuyTicket() 
	{
		cout << "学生票半价" << endl;
	}
private:
	int _b = 1;
};

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

int main()
{
	Person p;
	Student s;
	CheckTicket(p);
	CheckTicket(s);//会发生切片
	return 0;
}

理解了虚函数表，我们就知道：将s对象传递给p引用时会发生切片，所以s的虚表会覆盖Person对象的虚表。

**注意：**满足多态的函数调用是在运行时确定的，不满足多态的函数调用是在编译时确定的。

2.3 动态绑定与静态绑定

动态绑定：动态绑定又称为后期绑定（晚绑定），是指**在程序运行时就确定了程序的行为**，也称动态多态。如：多态。

静态绑定：静态绑定又称为前期绑定（早绑定），是指**在程序编译时就确定了程序的行为**，也成为静态多态。如：函数重载。

3. 单继承和多继承的虚函数表

3.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 _b = 0;
};

class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
	//Func3函数属于虚函数，为什么在监视窗口中看不到呢？
	//如何看到Func3函数呢？可以通过内存看到。
	virtual void Func3()
	{
		cout << "Derive::Func3()" << endl;
	}
private:
	int _d = 1;
};

//打印虚表地址
typedef void (*VFTPTR) ();
void PrintVFT(VFTPTR vft_ptr[], int a)
{
	for (int i = 0; i < a; ++i)
	{
		printf("[%d]: %p", i, vft_ptr[i]);
		VFTPTR f = vft_ptr[i];
		f();
		cout <<endl;
	}
	cout << endl;
}


int main()
{
	Base b1;
	Derive d1;
	VFTPTR* table_b1 = (VFTPTR*)(*(long long*) & b1);
	PrintVFT(table_b1, 2);
	VFTPTR* table_d1 = (VFTPTR*)(*(long long*) & d1);
	PrintVFT(table_d1, 3);
	return 0;
}

在这里插入图片描述

通过监视发现：

  1. Func1函数完成了重写，所以基类和派生类的Func1函数地址不一样。
  2. b1的Func2函数是虚函数，但是d2并没有进行重写，所以直接继承Func2函数。
  3. d1的Func3函数是虚函数，但是没有在虚表中，这是编译器的问题。我们可以在内存中找到Func3的地址，并且打印出来。

在这里插入图片描述

3.2 多继承的虚函数表

#include<iostream>

using namespace std;

class A
{
public:
	virtual void Func1()
	{
		cout << "A::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "A::Func2()" << endl;
	}
};

class B
{
public:
	virtual void Func1()
	{
		cout << "B::Func1()" << endl;
	}
	virtual void Func3()
	{
		cout << "B::Fun3()" << endl;
	}
};

class C : public A, B
{
public:
	virtual void Func1()
	{
		cout << "C::Func1()" << endl;
	}
	virtual void Func4()
	{
		cout << "C::Fun4()" << endl;
	}
};

int main()
{
	A a;
	B b;
	C c;
	return 0;
}

在这里插入图片描述

在这里插入图片描述

如上，我们发现a1对象和b1对象打印的函数一样。

那为什么在监视窗口中Func1函数地址不一样呢？我们需要在汇编中观察。

在这里插入图片描述

分析：

  1. a1调用Func1函数时，直接根据地址找到了Func1函数。
  2. b1调用Func1函数时，是绕了一个弯再减8个字节才找到了Func1函数。
  3. 为什么要减8？A类只有一个虚表指针，大小为8个字节。所以b1减8个字节所以就找到了Func1函数。
  4. 为什么不直接将B类中的Func1函数地址弄成A类中一样？不知道。

3.3 菱形继承、菱形虚拟继承的虚函数表

菱形继承、菱形虚拟继承的虚函数表很麻烦，现实中用的很少。这里就不介绍了。想了解的小伙伴可以点击下面两个链接。

C++ 虚函数表解析 | 酷 壳 - CoolShell

C++ 对象的内存布局 | 酷 壳 - CoolShell

4. 抽象类

4.1 概念

阅读以下代码：

#include<iostream>

using namespace std;

class A
{
public:
	virtual void Func1() = 0;//在虚函数后面加=0，这个虚函数称为纯虚函数。
};

int main()
{
	A a;//error C2259: “A”: 无法实例化抽象类
	return 0;
}

抽象类：在虚函数后面加上=0，这个函数称为纯虚函数。具有纯虚函数的类称为抽象类。抽象类不能实例化出对象。

#include<iostream>

using namespace std;

class A
{
public:
	virtual void Func1() = 0;
	virtual void Func2()
	{
		cout << "A::Func2()" << endl;
	}
};

class B : public A
{
public:
    //只有对基类的纯虚函数进行重写才能实例化出对象
    //virtual void Func1()
    //{
  	//	cout << "B::Func1()" << endl;      
	//}
	virtual void Func2()
	{
		cout << "B::Func2()" << endl;
	}
};

int main()
{
	B b; //error C2259 : “B”: 无法实例化抽象类
	return 0;
}

派生类继承后也不能实例化出对象。只有对这个纯虚函数进行重写才能实例化出对象。如上注释代码。

4.2 接口继承和实现继承

接口继承：虚函数是一个接口继承，派生类继承的是基类的虚函数接口，重写了内容，实现了多态。如：抽象类是一个接口继承。

实现继承：普通函数的继承是实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现

时间的光线
关注
  • 30
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++多态
weixin_50569901的博客
04-20 1万+
C++中的多态分为静态多态和动态多态两种，其中： 静态多态在编译阶段实现，其原理是由函数重载实现，通过不同的实参调用其相应的同名函数。 动态多态通过虚函数实现，以下着重介绍 动态多态的两个必要条件： 必须通过基类的指针或者引用调用 被调用的必须是虚函数，且在派生类中实现了该虚函数的重写 以下解释何为通过基类的指针或者引用调用 int main() { Person p; student s; Person &tmp1 = p; Person &tmp2 = s;//tm
c++多态总结
08-30
c++多态总结，vptr总结，多态原理探究
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++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
C++ 多态
jun8086的博客
10-31 570
c++ 多态
c++多态 详解
qq_39117115的博客
03-09 952
综上：如果满足多态，看指向对象的类型，调用这个类型的成员函数如果不满足多态， 看调用者类型，调用这个类型的成员函数解释：满足多态的情况下，我们定义Parent * p= new student，这个会调用Student的发生重写的函数我们定义Parent *p =new Parent ，这个会调用Parent中被重写的函数不满足多态的情况下，我们定义Student *s =new Student，这个会调用Student的函数。
C++多态详解
米莱虾
10-12 896
目录 多态的概念 多态的实现 虚函数的定义要遵循以下重要规则： 多态的概念 多态现在一般的用法，就是拿一个父类的指针去调用子类中被重写的方法。 那为什么要用多态呢，我们直接在子类中写一个同名的成员函数，从而隐藏父类的函数不是也可以吗? -------- 这是不可以的。下面我们用一个例子来解释为什么要用多态： 将父类比喻为电脑的外设接口，子类比喻为外设，现在我有移动硬盘、U盘以及MP3，它们3个都是可以作为存储但各不相同。在写驱动的时候，用个父类表示外设接口，然后在子类中重写父类那个读取设备..
c++ 多态详解
不倒翁.
05-02 5442
c++多态详解
c++ 多态
RSH的博客
07-24 355
1、多态 多态的基本概念 多态是C++面向对象三大特性之一 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 虚函数表存放的是虚函数的入口地址，当子类重写了虚函数后，子类会把继承于父类的虚函数表进行覆盖，所以当用父类指针或引用指向子类对象的时候，由于本身还是子类，所以当调用公共接口时，它会从子类去
C++多态的底层原理
分享学习的知识，记录我的技术成长道路
04-27 2772
要了解C++多态的底层原理需要我们对C指针有着深入的了解，这个在打印虚表的时候就可以见功底，理解了多态的本质我们才能记忆的更牢，使用起来更加得心应手。
C++多态（超级详细版）
kkbca的博客
10-28 9661
在继承中要构成多态还有两个条件：1. 必须通过基类的指针或者引用调用虚函数2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写public:virtual void BuyTicket() { cout
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
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...
C++ 多态和虚函数 高清PDF
08-15
多态性（在C + +中用虚函数实现）是面向对象程序设计语言继数据抽象和继承之后的第三个基本特征。 它提供了与具体实现相隔离的另一类接口，即把“ w h a t”从“h o w”分离开来。多态性提高了代码的组织性和可读性...
详解C++ 多态的实现及原理
01-20
C++的多态性用一句话概括就是：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用...
c++习题08-计算星期几
码到成龚的博客
07-03 594
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 627
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
关键路径——C语言（理论）
2302_80790488的博客
06-28 861
关键路径，是项目网络中从起始事件到终止事件的最长路径，决定了项目的最短完成时间。 关键路径中的任务没有任何可调整的余地，如果任何一个任务被延迟，整个项目的完成时间也会被延迟。
Android 开发中 C++ 和Java 日志调试
最新发布
小羊子的技术专栏
07-04 912
Android 开发中 C++ 和Java 日志调试方法小结

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值