您当前的位置:首页 > 电脑百科 > 程序开发 > 语言 > C/C++/C#

C++ 一篇搞懂多态的实现原理

时间:2020-02-02 14:09:31  来源:  作者:

虚函数和多态

01 虚函数

virtualvirtual
class Base {    virtual int Fun() ; // 虚函数};int Base::Fun() // virtual 字段不用在函数体时定义{ }

02 多态的表现形式一

  • 「派生类的指针」可以赋给「基类指针」;
  • 通过基类指针调用基类和派生类中的同名「虚函数」时:若该指针指向一个基类的对象,那么被调用是基类的虚函数;若该指针指向一个派生类的对象,那么被调用的是派生类的虚函数。

这种机制就叫做“多态”,说白点就是 调用哪个虚函数,取决于指针对象指向哪种类型的对象 。

// 基类class CFather {public:    virtual void Fun() { } // 虚函数};// 派生类class CSon : public CFather { public :    virtual void Fun() { }};int main() {    CSon son;    CFather *p = &son;    p->Fun(); //调用哪个虚函数取决于 p 指向哪种类型的对象    return 0;}

上例子中的 p 指针对象指向的是 CSon 类对象,所以 p->Fun() 调用的是 CSon 类里的 Fun 成员函数。

03 多态的表现形式二

  • 派生类的对象可以赋给基类「引用」
  • 通过基类引用调用基类和派生类中的同名「虚函数」时:若该引用引用的是一个基类的对象,那么被调用是基类的虚函数;若该引用引用的是一个派生类的对象,那么被调用的是派生类的虚函数。

这种机制也叫做“多态”,说白点就是 调用哪个虚函数,取决于引用的对象是哪种类型的对象 。

// 基类class CFather {public:    virtual void Fun() { } // 虚函数};// 派生类class CSon : public CFather { public :    virtual void Fun() { }};int main() {    CSon son;    CFather &r = son;    r.Fun(); //调用哪个虚函数取决于 r 引用哪种类型的对象    return 0;}}

上例子中的 r 引用的对象是 CSon 类对象,所以 r.Fun() 调用的是 CSon 类里的 Fun 成员函数。

04 多态的简单示例

class A {public :    virtual void Print() { cout << "A::Print"<<endl ; }};// 继承A类class B: public A {public :    virtual void Print() { cout << "B::Print" <<endl; }};// 继承A类class D: public A {public:    virtual void Print() { cout << "D::Print" << endl ; }};// 继承B类class E: public B {    virtual void Print() { cout << "E::Print" << endl ; }};

A类、B类、E类、D类的关系如下图:

C++ 一篇搞懂多态的实现原理

 

int main() {    A a; B b; E e; D d;        A * pa = &a;     B * pb = &b;    D * pd = &d;     E * pe = &e;        pa->Print();  // a.Print()被调用,输出:A::Print        pa = pb;    pa -> Print(); // b.Print()被调用,输出:B::Print        pa = pd;    pa -> Print(); // d.Print()被调用,输出:D::Print        pa = pe;    pa -> Print(); // e.Print()被调用,输出:E::Print        return 0;}

05 多态作用

在面向对象的程序设计中使用「多态」,能够增强程序的 可扩充性 ,即程序需要修改或增加功能的时候,需要 改动和增加的代码较少 。

LOL 英雄联盟游戏例子

下面我们用设计 LOL 英雄联盟游戏的英雄的例子,说明多态为什么可以在修改或增加功能的时候,可以较少的改动代码。

LOL 英雄联盟是 5v5 竞技游戏,游戏中有很多英雄,每种英雄都有一个「类」与之对应,每个英雄就是一个「对象」。

英雄之间能够互相攻击,攻击敌人和被攻击时都有相应的动作,动作是通过对象的成员函数实现的。

下面挑了五个英雄:

  • 探险家 CEzreal
  • 盖楼 CGaren
  • 盲僧 CLeesin
  • 无极剑圣 CYi
  • 瑞兹 CRyze
C++ 一篇搞懂多态的实现原理

 

基本思路:

  1. 为每个英雄类编写 Attack 、 FightBack 和 Hurted 成员函数。
AttackFightBackHurted
  1. 设置基类 CHero ,每个英雄类都继承此基类
C++ 一篇搞懂多态的实现原理

 

02 非多态的实现方法

// 基类class CHero {protected:      int m_nPower ; //代表攻击力    int m_nLifeValue ; //代表生命值};// 无极剑圣类class CYi : public CHero {public:    // 攻击盖伦的攻击函数    void Attack(CGaren * pGaren)     {        .... // 表现攻击动作的代码        pGaren->Hurted(m_nPower);        pGaren->FightBack(this);    }    // 攻击瑞兹的攻击函数    void Attack(CRyze * pRyze)     {        .... // 表现攻击动作的代码        pRyze->Hurted(m_nPower);        pRyze->FightBack( this);    }        // 减少自身生命值    void Hurted(int nPower)     {        ... // 表现受伤动作的代码        m_nLifeValue -= nPower;    }        // 反击盖伦的反击函数    void FightBack(CGaren * pGaren)     {        ....// 表现反击动作的代码        pGaren->Hurted(m_nPower/2);    }        // 反击瑞兹的反击函数    void FightBack(CRyze * pRyze)     {        ....// 表现反击动作的代码        pRyze->Hurted(m_nPower/2);    }};

有 n 种英雄, CYi 类中就会有 n 个 Attack 成员函数,以及 n 个 FightBack成员函数。对于其他类也如此。

如果游戏版本升级,增加了新的英雄寒冰艾希 CAshe ,则程序改动较大。所有的类都需要增加两个成员函数:

void Attack(CAshe * pAshe);void FightBack(CAshe * pAshe);

这样工作量是非常大的!!非常的不人性,所以这种设计方式是非常的不好!

03 多态的实现方式

用多态的方式去实现,就能得知多态的优势了,那么上面的栗子改成多态的方式如下:

// 基类class CHero {public:    virtual void Attack(CHero *pHero){}    virtual voidFightBack(CHero *pHero){}    virtual void Hurted(int nPower){}protected:      int m_nPower ; //代表攻击力    int m_nLifeValue ; //代表生命值};// 派生类 CYi:class CYi : public CHero {public:    // 攻击函数    void Attack(CHero * pHero)     {        .... // 表现攻击动作的代码        pHero->Hurted(m_nPower); // 多态        pHero->FightBack(this);  // 多态    }        // 减少自身生命值    void Hurted(int nPower)     {        ... // 表现受伤动作的代码        m_nLifeValue -= nPower;    }        // 反击函数    void FightBack(CHero * pHero)     {        ....// 表现反击动作的代码        pHero->Hurted(m_nPower/2); // 多态    }};

如果增加了新的英雄寒冰艾希 CAshe ,只需要编写新类 CAshe ,不再需要在已有的类里专门为新英雄增加:

void Attack( CAshe * pAshe) ;void FightBack(CAshe * pAshe) ;

所以已有的类可以原封不动,那么使用多态的特性新增英雄的时候,可见改动量是非常少的。

多态使用方式:

void CYi::Attack(CHero * pHero) {    pHero->Hurted(m_nPower); // 多态    pHero->FightBack(this);  // 多态}CYi yi; CGaren garen; CLeesin leesin; CEzreal ezreal;yi.Attack( &garen );  //(1)yi.Attack( &leesin ); //(2)yi.Attack( &ezreal ); //(3)

根据多态的规则,上面的(1),(2),(3)进入到 CYi::Attack 函数后

,分别调用:

CGaren::HurtedCLeesin::HurtedCEzreal::Hurted

多态的又一例子

出一道题考考大家,看大家是否理解到了多态的特性,下面的代码, pBase->fun1() 输出结果是什么呢?

class Base {public:    void fun1()     {         fun2();     }        virtual void fun2()  // 虚函数    {         cout << "Base::fun2()" << endl;     }};class Derived : public Base {public:    virtual void fun2()  // 虚函数    {         cout << "Derived:fun2()" << endl;     }};int main() {    Derived d;    Base * pBase = & d;    pBase->fun1();    return 0;}

是不是大家觉得 pBase 指针对象虽然指向的是派生类对象,但是派生类里没有 fun1 成员函数,则就调用基类的 fun1 成员函数, Base::fun1() 里又会调用基类的 fun2 成员函数,所以输出结果是 Base::fun2() ?

假设我把上面的代码转换一下, 大家还觉得输出的是 Base::fun2() 吗?

class Base {public:    void fun1()     {         this->fun2();  // this是基类指针,fun2是虚函数,所以是多态    }}

this 指针的作用就是指向成员函数所作用的对象, 所以非静态成员函数中可以直接使用 this 来代表指向该函数作用的对象的指针。

pBase 指针对象指向的是派生类对象,派生类里没有 fun1 成员函数,所以就会调用基类的 fun1 成员函数,在 Base::fun1() 成员函数体里执行 this->fun2() 时,实际上指向的是派生类对象的 fun2 成员函数。

所以正确的输出结果是:

Derived:fun2()

所以我们需要注意:

在非构造函数,非析构函数的成员函数中调用「虚函数」,是多态!!!

构造函数和析构函数中存在多态吗?

在构造函数和析构函数中调用「虚函数」,不是多态。编译时即可确定,调用的函数是 自己的类或基类 中定义的函数,不会等到运行时才决定调用自己的还是派生类的函数。

我们看如下的代码例子,来说明:

// 基类class CFather {public:    virtual void hello() // 虚函数    {        cout<<"hello from father"<<endl;     }        virtual void bye() // 虚函数    {        cout<<"bye from father"<<endl;     }};// 派生类class CSon : public CFather{ public:    CSon() // 构造函数    {         hello();     }        ~CSon()  // 析构函数    {         bye();    }    virtual void hello() // 虚函数    {         cout<<"hello from son"<<endl;    }};int main(){    CSon son;    CFather *pfather;    pfather = & son;    pfather->hello(); //多态    return 0;}

输出结果:

hello from son  // 构造son对象时执行的构造函数hello from son  // 多态bye from father // son对象析构时,由于CSon类没有bye成员函数,所以调用了基类的bye成员函数

多态的实现原理

「多态」的关键在于通过 基类指针或引用 调用一个 虚函数 时,编译时不能确定到底调用的是基类还是派生类的函数,运行时才能确定。

我们用 sizeof 来运算有有虚函数的类和没虚函数的类的大小,会是什么结果呢?

class A {public:    int i;    virtual void Print() { } // 虚函数};class B{public:    int n;    void Print() { } };int main() {    cout << sizeof(A) << ","<< sizeof(B);    return 0;}

在64位机子,执行的结果:

16,4

从上面的结果,可以发现有虚函数的类,多出了 8 个字节,在 64 位机子上指针类型大小正好是 8 个字节,这多出 8 个字节的指针有什么作用呢?

01 虚函数表

每一个有「虚函数」的类(或有虚函数的类的派生类)都有一个「虚函数表」,该类的任何对象中都放着 虚函数表的指针 。「虚函数表」中列出了该类的「虚函数」地址。

多出来的 8 个字节就是用来放「虚函数表」的地址。

// 基类class Base {public:    int i;    virtual void Print() { } // 虚函数};// 派生类class Derived : public Base{public:    int n;    virtual void Print() { } // 虚函数};

上面 Derived 类继承了 Base类,两个类都有「虚函数」,那么它「虚函数表」的形式可以理解成下图:

C++ 一篇搞懂多态的实现原理

 

多态的函数调用语句被编译成一系列根据基类指针所指向的(或基类引用所引用的)对象中 存放的虚函数表的地址 ,在虚函数表中查找虚函数地址,并调用虚函数的指令。

02 证明虚函数表指针的作用

在上面我们用 sizeof 运算符计算了有虚函数的类的大小,发现是多出了 8 字节大小(64位系统),这多出来的 8 个字节就是指向「虚函数表的指针」。「虚函数表」中列出了该类的「虚函数」地址。

下面用代码的例子,来证明「虚函数表指针」的作用:

// 基类class A {public:     virtual void Func()  // 虚函数    {         cout << "A::Func" << endl;     }};// 派生类class B : public A {public:     virtual void Func()  // 虚函数    {         cout << "B::Func" << endl;    }};int main() {    A a;        A * pa = new B();    pa->Func(); // 多态        // 64位程序指针为8字节    int * p1 = (int *) & a;    int * p2 = (int *) pa;        * p2 = * p1;    pa->Func();        return 0;}

输出结果:

B::FuncA::Func
  • 第 25-26 行代码中的 pa 指针指向的是 B 类对象,所以 pa->Func() 调用的是 B 类对象的虚函数 Func() ,输出内容是 B::Func ;
  • 第 29-30 行代码的目的是把 A 类的头 8 个字节的「虚函数表指针」存放到 p1 指针和把 B 类的头 8 个字节的「虚函数表指针」存放到 p2 指针;
  • 第 32 行代码目的是把 A 类的「虚函数表指针」 赋值给 B 类的「虚函数表指针」,所以相当于把 B 类的「虚函数表指针」 替换 成了 A 类的「虚函数表指针」;
  • 由于第 32 行的作用,把 B 类的「虚函数表指针」 替换 成了 A 类的「虚函数表指针」,所以第 33 行调用的是 A 类的虚函数 Func() ,输出内容是 A::Func

通过上述的代码和讲解,可以有效的证明了「虚函数表的指针」的作用,「虚函数表的指针」指向的是「虚函数表」,「虚函数表」里存放的是类里的「虚函数」地址,那么在调用过程中,就能实现多态的特性。

虚析构函数

析构函数是在删除对象或退出程序的时候,自动调用的函数,其目的是做一些资源释放。

那么在多态的情景下,通过基类的指针删除派生类对象时,通常情况下只调用基类的析构函数,这就会存在派生类对象的析构函数没有调用到,存在资源泄露的情况。

看如下的例子:

// 基类class A {public:     A()  // 构造函数    {        cout << "construct A" << endl;    }        ~A() // 析构函数    {        cout << "Destructor A" << endl;    }};// 派生类class B : public A {public:     B()  // 构造函数    {        cout << "construct B" << endl;    }        ~B()// 析构函数    {        cout << "Destructor B" << endl;    }};int main() {    A *pa = new B();    delete pa;        return 0;}

输出结果:

construct Aconstruct BDestructor A

从上面的输出结果可以看到,在删除 pa 指针对象时, B 类的析构函数没有被调用。

解决办法:把基类的析构函数声明为virtual

  • 派生类的析构函数可以 virtual 不进行声明;
  • 通过基类的指针删除派生类对象时,首先调用派生类的析构函数,然后调用基类的析构函数,还是遵循「先构造,后虚构」的规则。

将上述的代码中的基类的析构函数,定义成「虚析构函数」:

// 基类class A {public:     A()      {        cout << "construct A" << endl;    }        virtual ~A() // 虚析构函数    {        cout << "Destructor A" << endl;    }};

输出结果:

construct Aconstruct BDestructor BDestructor A

所以要养成好习惯:

  • 一个类如果定义了虚函数,则应该将析构函数也定义成虚函数;
  • 或者,一个类打算作为基类使用,也应该将析构函数定义成虚函数。
  • 注意:不允许构造函数不能定义成虚构造函数。

纯虚函数和抽象类

纯虚函数: 没有函数体的虚函数

class A {public:    virtual void Print( ) = 0 ; //纯虚函数private:     int a;};

包含纯虚函数的类叫抽象类

  • 抽象类只能作为基类来派生新类使用,不能创建抽象类的对象
  • 抽象类的指针和引用可以指向由抽象类派生出来的类的对象
A a;         // 错,A 是抽象类,不能创建对象A * pa ;     // ok,可以定义抽象类的指针和引用pa = new A ; // 错误, A 是抽象类,不能创建对象


Tags:C++   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,如有任何标注错误或版权侵犯请与我们联系(Email:2595517585@qq.com),我们将及时更正、删除,谢谢。
▌相关推荐
一、编程语言1.根据熟悉的语言,谈谈两种语言的区别?主要浅谈下C/C++和PHP语言的区别:1)PHP弱类型语言,一种脚本语言,对数据的类型不要求过多,较多的应用于Web应用开发,现在好多互...【详细内容】
2021-12-15  Tags: C++  点击:(17)  评论:(0)  加入收藏
函数调用约定(Calling Convention),是一个重要的基础概念,用来规定调用者和被调用者是如何传递参数的,既调用者如何将参数按照什么样的规范传递给被调用者。在参数传递中,有两个很...【详细内容】
2021-11-30  Tags: C++  点击:(19)  评论:(0)  加入收藏
一、为什么需要使用内存池在C/C++中我们通常使用malloc,free或new,delete来动态分配内存。一方面,因为这些函数涉及到了系统调用,所以频繁的调用必然会导致程序性能的损耗;另一...【详细内容】
2021-11-17  Tags: C++  点击:(38)  评论:(0)  加入收藏
C++编程中,你是否有为 我到底该写个struct还是class 而苦恼过?如果你到现在还不知道该如何选择,那么请求继续阅读,下文或许能给你些建议。问题的产生C++语言继承了 C语言的 stru...【详细内容】
2021-10-18  Tags: C++  点击:(63)  评论:(0)  加入收藏
C++在C的面向过程概念的基础上提供了面向对象和模板(泛型编程)的语法功能。下面以一个简单实例(动态数组的简单封装,包括下标的值可以是任意正数值,并提供边界检查)来说明C++是如...【详细内容】
2021-10-18  Tags: C++  点击:(50)  评论:(0)  加入收藏
0 前言Hello,大家好,欢迎来到『自由技艺』的 C++ 系列专题。代码重用,尽可能避免冗余代码是程序员的一项必备技能,今天就来给大家介绍其中一种:函数装饰器。在设计模式中,与它对应...【详细内容】
2021-09-28  Tags: C++  点击:(75)  评论:(0)  加入收藏
今天我们就来聊一聊 C++ 中的异常机制吧。在学校期间,我们很少会用得上异常机制。然而,工作之后,很多时候却不得不引入异常机制。因为一般情况下,使用函数的返回值来确定函数的...【详细内容】
2021-09-26  Tags: C++  点击:(182)  评论:(0)  加入收藏
一、内存泄漏(memory leak)内存泄漏(memory leak)是指由于疏忽或错误造成了程序未能释放掉不再使用的内存的情况。内存泄漏并非指内存在物理上的消失,而是应用程序分配某段内存...【详细内容】
2021-09-03  Tags: C++  点击:(105)  评论:(0)  加入收藏
stack容器#include <iostream>using namespace std;#include <stack>//容器头文件void test(){stack<int>p;p.push(100);p.push(1000);p.push(100);while(!p.empty()){cout<...【详细内容】
2021-08-17  Tags: C++  点击:(81)  评论:(0)  加入收藏
stl 常用遍历算法(for_each transform)示例代码(结论在结尾!!!!)#include<iostream>using namespace std;#include"vector"#include"map"#include"string"#include"list"#in...【详细内容】
2021-08-13  Tags: C++  点击:(89)  评论:(0)  加入收藏
▌简易百科推荐
一、简介很多时候我们都需要用到一些验证的方法,有时候需要用正则表达式校验数据时,往往需要到网上找很久,结果找到的还不是很符合自己想要的。所以我把自己整理的校验帮助类分...【详细内容】
2021-12-27  中年农码工    Tags:C#   点击:(2)  评论:(0)  加入收藏
引言在学习C语言或者其他编程语言的时候,我们编写的一个程序代码,基本都是在屏幕上打印出 hello world ,开始步入编程世(深)界(坑)的。C 语言版本的 hello world 代码:#include <std...【详细内容】
2021-12-21  一起学嵌入式    Tags:C 语言   点击:(11)  评论:(0)  加入收藏
读取SQLite数据库,就是读取一个路径\\192.168.100.**\position\db.sqlite下的文件<startup useLegacyV2RuntimeActivationPolicy="true"> <supportedRuntime version="v4.0"/...【详细内容】
2021-12-16  今朝我的奋斗    Tags:c#   点击:(21)  评论:(0)  加入收藏
什么是shellshell是c语言编写的程序,它在用户和操作系统之间架起了一座桥梁,用户可以通过这个桥梁访问操作系统内核服务。 它既是一种命令语言,同时也是一种程序设计语言,你可以...【详细内容】
2021-12-16  梦回故里归来    Tags:shell脚本   点击:(18)  评论:(0)  加入收藏
一、编程语言1.根据熟悉的语言,谈谈两种语言的区别?主要浅谈下C/C++和PHP语言的区别:1)PHP弱类型语言,一种脚本语言,对数据的类型不要求过多,较多的应用于Web应用开发,现在好多互...【详细内容】
2021-12-15  linux上的码农    Tags:c/c++   点击:(17)  评论:(0)  加入收藏
1.字符串数组+初始化char s1[]="array"; //字符数组char s2[6]="array"; //数组长度=字符串长度+1,因为字符串末尾会自动添&lsquo;\0&lsquo;printf("%s,%c\n",s1,s2[2]);...【详细内容】
2021-12-08  灯-灯灯    Tags:C语言   点击:(47)  评论:(0)  加入收藏
函数调用约定(Calling Convention),是一个重要的基础概念,用来规定调用者和被调用者是如何传递参数的,既调用者如何将参数按照什么样的规范传递给被调用者。在参数传递中,有两个很...【详细内容】
2021-11-30  小智雅汇    Tags:函数   点击:(19)  评论:(0)  加入收藏
一、问题提出问题:把m个苹果放入n个盘子中,允许有的盘子为空,共有多少种方法?注:5,1,1和1 5 1属同一种方法m,n均小于10二、算法分析设f(m,n) 为m个苹果,n个盘子的放法数目,则先对...【详细内容】
2021-11-17  C语言编程    Tags:C语言   点击:(49)  评论:(0)  加入收藏
一、为什么需要使用内存池在C/C++中我们通常使用malloc,free或new,delete来动态分配内存。一方面,因为这些函数涉及到了系统调用,所以频繁的调用必然会导致程序性能的损耗;另一...【详细内容】
2021-11-17  深度Linux    Tags:C++   点击:(38)  评论:(0)  加入收藏
OpenCV(Open Source Computer Vision Library)是一个(开源免费)发行的跨平台计算机视觉库,可以运行在Linux、Windows、Android、ios等操作系统上,它轻量级而且高效---由一系列...【详细内容】
2021-11-11  zls315    Tags:C#   点击:(50)  评论:(0)  加入收藏
最新更新
栏目热门
栏目头条