08.多态与虚函数

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量639 收藏 24
点赞数 18
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75755844/article/details/142267082
版权

1.多态的概念

编译时多态(静态多态）：函数重载、函数模版
运行时多态(动态多态)：函数接收不同对象时完成不同的行为

2.多态的定义和实现

(1)多态的构成条件

  1. 两个类存在继承关系
  2. 必须指针或引用调用虚函数
    • 并且是基类的指针或者引用
    • 虚函数必须被子类重写或者覆盖
  • 被调用函数必须是虚函数
    代码示例：
#include<iostream>
using namespace std;

class Person{
public:
    virtual void BuyTicket(){
        cout << "全价购买" << endl;
    }
};
class Student:public Person{
public:
    virtual void BuyTicket(){//[1]
        cout << "半价购买" << endl;
    }
};

void fun(Person* ptr){
    ptr->BuyTicket();
}
int main(){
    Person person;
    Student stu;
    fun(&person);
    fun(&stu);
    return 0；
}

运行结果：

全价购买
半价购买

从代码中可以看出，ptr指针调用BuyTicket函数时并没有因为它是Person类的指针而直接调用Person类的函数，而是在运行时调用了ptr所指向的stu对象的BuyTicket函数，而这就建立在满足所有动态的构成条件。

注意：子类的在重写父累；类的虚函数时可以不写"virtual"如 [1]可以写做void BuyTicket

多态场景的一个习题
以下程序输出结果是什么（）
A:A->0B:B->1C:A->1D:B->0E:编译出错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;
}

这道题的答案选B，首先p是指向B的一个B指针，然后调用test()函数，但因为class B没有重写这个函数，故会调用A类中的函数，又因为这里将指向B类的地址传给了test()的this指针，这样就满足了多态构成条件——父类指针指向子类对象，所以又调用了B中的func()，但调用后会发现，行参是0，为啥输出的是1，这是因为，虚函数的重写只会重写父类的函数体，等于这里val实际的行参是1，故输出了B->1

与其他虚函数的定义不同的是基类的析构函数为虚函数，此时派⽣类析构函数只要定义，⽆论是否加virtual关键字，都与基类的析构函数构成重写，这里并不关心基类的虚函数是否与子类的虚函数的函数是否相同，基类的析构函数为虚函数，此时派⽣类析构函数只要定义，⽆论是否加virtual关键字，都与基类的析构函数构成重写。
代码示例

class Person{
public:
    virtual void BuyTicket(){
        cout << "全价购买" << endl;
    }
     ~Person(){
        cout << "~Person()" << endl;
    }
};
class Student:public Person{
public:
    virtual void BuyTicket(){
        cout << "半价购买" << endl;
    }
    ~Student(){
        cout << "~Student()" << endl;
        delete[] ptr;
    }

private:
    int *ptr = new int[10];
};
int main(){
    Person* person =new Person;
    Student* stu =new Student;
    delete person;
    delete stu;
}

运行结果：

~Person()
~Student()
~Person()

运行结果表示Person的析构函数被调用了两次，这是因为Student类被调用后会自动在调一次父类析构函数，确保属于父类的成员变量被析构。
如果去掉父类的virtual关键字呢？
那么只会调⽤的A的析构函数，没有调⽤B的析构函数，就会导致内存泄漏问题，因为~B()中在释放资源。
注意：这就是为啥基类中的析构函数建议设计为虚函数。

(3)override和final关键字

override :用于帮助⽤⼾检测是否重写。
final:禁止派生类重写这个虚函数。
代码示例：

class Car {
public:
	virtual void Dirve()
	{}
};
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{
	return 0;
}

class Car {
public:
	virtual void Dirve()
	{}
};
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{
	return 0;
}

(3)重载/重写/隐藏的对⽐

重载：在一个作用域里，函数名相同，参数不同，参数类型或者个数不同，返回值可以相同也可以不相同。
重写/覆盖：两个虚函数在处于继承关系的不同作用域里，函数名参数返回值相同，协变和析构函数除外。
隐藏：两个函数分别在处于继承关系的父类和子类的不同作用域中，函数名相同，没有构成重写就是隐藏，除函数外父子类的成员变量也构成隐藏。

3.纯虚函数和抽象类

定义：纯虚函数是不需要被父类定义的函数，存在的意义只是为了让子类重写。抽象类是成员函数中包括纯虚函数的类，抽象类无法实例化对象。同样的，如果只是继承抽象类而不对抽象类中的抽象函数进行重写，那子类也只是抽象类，不能进行实例化。

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()
{
	// 编译报错：error C2259: “Car”: ⽆法实例化抽象类
	Car car;
	Car* pBenz = new Benz;
	pBenz->Drive();
	Car* pBMW = new BMW;
	pBMW->Drive();
	return 0;
}

4.多态的原理

(1)虚函数的指针

下⾯编译为32位程序的运⾏结果是什么（）
A.编译报错B.运⾏报错C.8D.12

class Base
{ 
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
protected:
	int _b = 1;
	char _ch = 'x';
};
int main()
{
	Base b;
	cout << sizeof(b) << endl;
	return 0;
}

结果是12
因为除了存储_b和_ch,还需要存储虚函数表，这个虚函数表用于存储对应虚函数的地址。
多态2

那么什么是虚函数表呢？

(2)虚函数表

#include<iostream>
using namespace std;

class Person {
public:
    virtual void BuyTicket() {
        cout << "全价购买" << endl;
    }
protected:
    string _name;
};
class Student :public Person {
public:
    virtual void BuyTicket() {
        cout << "半价购买" << endl;
    }
private:
    int _id;
};
class Solider :public Person {
public:
    virtual void BuyTicket() {
        cout << "优先购买" << endl;
    }
private:
    string _codename;
};

void fun(Person* ptr) {
    ptr->BuyTicket();
}
int main() {
    Person pe;
    Student st;
    Solider so;
}

多态3

当把student类的虚函数删除结果会有什么不同吗？

#include<iostream>
using namespace std;

class Person {
public:
    virtual void BuyTicket() {
        cout << "全价购买" << endl;
    }
protected:
    string _name;
};
class Student :public Person {
private:
    int _id;
};
class Solider :public Person {
public:
    virtual void BuyTicket() {
        cout << "优先购买" << endl;
    }
private:
    string _codename;
};

void fun(Person* ptr) {
    ptr->BuyTicket();
}
int main() {
    Person pe;
    Student st;
    Solider so;
}

多态4

从第一张图可以看出,当每个子类都对父类的虚函数进行重写，对应的子类对象中都会存放一个二级指针，而二级指针所指向的函数地址也不同。从第二张图可以看出，当子类对象直接继承父类的虚函数时，二级指针所指向函数地址也与父类相同。
而这个二级指针所指向的就是虚函数表，用来存储虚函数的地址。
虚函数表的总结如下：

  • 基类对象的虚函数表中存放基类所有虚函数的地址
  • 派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表指针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独立的。
  • 派⽣类中重写的基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的虚函数地址。
  • 派⽣类的虚函数表中包含，基类的虚函数地址，派⽣类重写的虚函数地址，派⽣类⾃⼰的虚函数地址三个部分。通过下面的示例说明。
class Base {
public:
    virtual void func1() { cout << "Base::func1" << endl; }
    virtual void func2() { cout << "Base::func2" << endl; }
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
};
class Derive : public Base
{
public :
    // 重写基类的func1
    virtual void func1() { cout << "Derive::func1" << endl; }
    virtual void func3() { cout << "Derive::func1" << endl; }
    void func4() { cout << "Derive::func4" << endl; }
protected:
    int b = 2;
};
int main()
{
    Base b;
    Derive d;
    return 0;
}

多态5

如图所示，派生类d的虚函数表有存储了三个虚函数地址，func1是重写的父类的func1，func2是继承的父类的func2，而d自己的func3只能通过内存查看。
在了解了虚函数表之后，就能知道多态到底是如何实现了。

(3)多态是如何实现的

还是Student和Person的例子

 class Person{
 public:
     virtual void BuyTicket(){
         cout << "全价购买" << endl;
     }
     string name;
 };
 class Student:public Person{
 public:
     virtual void BuyTicket() {
         cout << "半价购买" << endl;
     }

 private:
     int id;
 };

 void fun(Person* ptr){
     ptr->BuyTicket();
 }
 int main(){
     Person pe;
     Student st;
     fun(&pe);
     fun(&st);
 }

在这里插入图片描述

在这里插入图片描述
从图可以看出满⾜多态条件后，底层不再是编译时通过调⽤对象确定函数的地址，⽽是运⾏时到指向的对象的虚表中确定对应的虚函数的地址，这样就实现了指针或引⽤指向基类就调⽤基类的虚函数，指向派⽣类就调⽤派⽣类对应的虚函数。第⼀张图，ptr指向的Person对象，调⽤的是Person的虚函数；第⼆张图，ptr指向的Student对象，调⽤的是Student的虚函数。

(4)动态绑定和静态绑定
  • 对不满⾜多态条件(指针或者引⽤+调⽤虚函数)的函数调⽤是在编译时绑定，也就是编译时确定调⽤函数的地址，叫做静态绑定。
  • 满⾜多态条件的函数调⽤是在运⾏时绑定，也就是在运⾏时到指向对象的虚函数表中找到调⽤函数的地址，也就做动态绑定。
xpery
关注
专栏目录
class.cpp多态虚函数的演示课设
02-07
多态虚函数的运行演示
C++知识点总结：5.多态和虚函数（自用）
目前涉及领域：目标检测，语义分割以及数字图像处理
08-08 787
通过学习"C语言中文网"中第五章多态和虚函数的内容，来总结的C++知识点。
C++ 多态与虚函数
e我所欲也的博客
06-06 1030
文章目录1. 多态的概念多态的性质多态的分类2. 虚函数实现动态多态性多态的构成条件虚函数虚函数重写的两个例外（不是特定规则）C++11 override 和 final3.纯虚函数与抽象类纯虚函数：抽象类接口继承和实现继承4.多态的原理虚函数表动态绑定与静态绑定（关联）5.单继承和多继承关系中的虚函数表 多态的概念 多态的定义及实现 抽象类 多态的原理 单继承和多继承关系中的虚函数表 继承和多态常见的面试问题 1. 多态的概念 多态的性质 多态性是面向对象程序设计的一个重要特性。 多态本意：一个事物有
C++程序设计【六】之 多态与虚函数
吴小迪的博客
02-28 1629
感谢内容提供者：金牛区吴迪软件开发工作室 文章目录第六章：多态与虚函数一、多态的基本概念1.多态2.虚函数3.通过基类指针实现多态4.通过基类引用实现多态5.多态的实现原理二、多态实例三、多态的使用四、虚析构函数五、纯虚函数和抽象类1.纯虚函数2.抽象类3.虚基类 第六章：多态与虚函数 一、多态的基本概念 1.多态 2.虚函数 3.通过基类指针实现多态 #include<iostream> using namespace std; class A { public: v.
C++：多态与虚函数,纯虚函数
a2998658795的博客
07-28 716
C++：多态与虚函数,纯虚函数
C++:虚函数与多态
2301_79959126的博客
07-26 724
本文介绍了C++中的虚函数与多态的概念，并介绍了虚函数与多态的实现原理。
多态与虚函数
Hustle Everyday
03-07 963
一、什么是多态 多态就是向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为。也就是说，每个对象可以用自己的方式去响应共同的消息。使用相同的代码实现不同的动作，体现了面向对象编程的优越性。 在C++中，多态就是利用基类指针指向子类实例，通过基类指针调用子类（虚）函数从而实现“一个接口，多种形态”的效果。 简单的说就是，实现了一个函数会根据传入参数的不同有不同的功能，比如： vo...
c++复习之多态与虚函数
guangod的博客
07-05 400
多态与虚函数多态概念使用普通成员函数实现多态虚函数使用虚析构函数纯虚函数和抽象类抽象类虚基类 多态 面向对象3种机制之一（封装、继承、多态），提高程序的可读性，可扩展性和可重用性。 概念 不同对象可以调用相同名称的函数，但可导致完全不同的行为的现象。 多态实现的是接口的复用。不论传递过来是哪个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。 使用 编译时多态（静态多态）：即函数重载，在编译时就能绑定调用语句与调用函数入口地址。 运行时多态（动态多态）函数调用与代码入口地址的绑定需要在运行时刻
C++多态与虚函数
qq_41854911的博客
08-04 1578
文章目录C++多态和虚函数快速入门教程借助引用也可以实现多态多态的用途C++虚函数注意事项以及构成多态的条件构成多态的条件什么时候声明虚函数C++虚析构函数的必要性C++纯虚函数和抽象类详解关于纯虚函数的几点说明C++虚函数表精讲教程，直戳多态的实现机制C++ typeid运算符：获取类型信息1) 原型：const char* name() const;2) 原型：bool before (const type_info& rhs) const;3) 原型：bool operator== (cons
【C++】动态多态与虚函数
m0_65835264的博客
09-30 1414
本文【C++】动态多态与虚函数 主要讲述了C++中的多态、虚函数、刨析了多态的底层实现和做了什么、虚析构、纯虚函数和抽象类。以详细的代码示例和例子，使我们学习相关的知识更加通俗易懂。 有感兴趣的小伙伴可以关注一下噢！
day10.C++多态与虚函数
m0_74161592的博客
02-22 371
74ur78895934593
Part7-多态与虚函数-KEY.docx
03-01
在C++编程语言中，多态性和虚函数是面向对象编程的重要特性，它们允许我们设计出灵活且可扩展的代码结构。多态性允许不同类型的对象以统一的方式进行处理，而虚函数是实现运行时多态性的关键机制。 1. **虚函数**：...
Part7-多态与虚函数-KEY.pdf
03-01
编译时多态主要通过函数重载（overload）实现，而运行时多态则通过虚函数（virtual function）和动态绑定实现。动态联编（dynamic binding）是运行时多态的一种表现形式，它在运行时根据对象的实际类型决定调用哪个...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 166
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 515
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
CF C. Nikita and LCM
qq_74190237的博客
09-13 258
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C和指针：标准函数库
暮色年华的博客
09-11 675
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 477
继续学习头文件的数学函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值