C++难点十一：多态

已于 2022-02-28 12:00:52 修改
阅读量370 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 后端
于 2022-02-27 18:47:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43737395/article/details/123158164
版权

多态

多态的基本语法

静态多态

  • 函数重载、运算符重载
  • 表现出来的现象：函数地址早绑定（在编译阶段就确定了地址），如：
#include <iostream>
using namespace std;
class Animal
{
public:
   void Speak()
   {
       cout<<"动物在说话"<<endl;
   }
};

class Cat:public Animal
{
public:
   void Speak()
   {
       cout<<"小猫在说话"<<endl;
   }
};

void doSpeak(Animal &animal)
{
   animal.Speak();
}

int main()
{
   Cat cat;
   doSpeak(cat);
}

运行结果是“动物在说话”。

动态多态

  • 条件：
    -1.父类和子类中有同名函数（且是“重写”，而不是“重载”，也即参数列表都一样，只是父类中的同名函数加了个virtual）；
    -2.调用的时候是用父类的指针或者引用来接收子类对象。
  • 表现出来的现象：函数地址晚绑定，如：
#include <iostream>
using namespace std;
class Animal
{
public:
    virtual void Speak()
    {
        cout<<"动物在说话"<<endl;
    }
};

class Cat:public Animal
{
public:
    void Speak()
    {
        cout<<"小猫在说话"<<endl;
    }
};

void doSpeak(Animal &animal)
{
    animal.Speak();
}

int main()
{
    Cat cat;
    doSpeak(cat);
}

仅仅在父类函数中加了一个virtual，但这就实现了地址晚绑定。

多态的原理剖析

只对Animal类的函数先做一个分析

class Animal
{
public:
    void Speak()
    {
        cout<<"动物在说话"<<endl;
    }
};


int main()
{
    cout<<sizeof(Animal)<<endl;
}
  • 结果是1，因为Speak()函数不是静态函数，所以不属于Animal类，因此Animal类只占一个字节（只要用一个字节，知道这存了一个类就行。）
  • 但是，如果Speak()函数前加一个virtual，结果变为4（32位平台下）或8（64位平台下）。因为，此时class中存的实际上是一个指针vfptr，这个vfptr指向一个vftable，vftable里装的是虚函数的地址，如上面这个例子，记录的就是&Animal::Speak()。
  • 更清晰的图示说明如下：
    在这里插入图片描述

加上一个继承的子类之后

如果这个子类里暂时还没有重写父类的函数

子类中的虚函数表就是父类中的虚函数表。
在这里插入图片描述

如果这个子类里重写了父类的函数

子类中的虚函数表内部会替换成子类的虚函数地址。
在这里插入图片描述
当用父类指针或引用调用子类对象时，发生多态，也即

Animal &animal = cat;
animal.speak;

此时cat会找到&Cat::Speak()。

多态示例

#include <iostream>
using namespace std;

class VirtualCalculator
{
public:
    virtual int calculate()
    {
        return 0;
    }
    int a;
    int b;
};

class SubCalculator:public VirtualCalculator
{
public:
    virtual int calculate()
    {
        return a-b;
    }
};

class MultiplyCalculator:public VirtualCalculator
{
public:
    virtual int calculate()
    {
        return a*b;
    }
};

class DivideCalculator:public VirtualCalculator
{
public:
    virtual int calculate()
    {
        return a/b;
    }
};

class AddCalculator:public VirtualCalculator
{
public:
    virtual int calculate()
    {
        return a+b;
    }
};

int main()
{
    VirtualCalculator* ptr = new AddCalculator;
    ptr->a=1;
    ptr->b=2;
    cout<<ptr->calculate();
    
    delete ptr;
    return 0;
}

虽然代码量加大了，但是组织结构清晰，易于定位维护，可读性强。

纯虚函数和抽象类

纯虚函数

在多态中，通常父类中虚函数的实现是无意义的，主要都是调用子类重写的内容。
因此，可以将虚函数改成纯虚函数，即：
virtual 返回值类型函数名(参数列表) = 0;

抽象类

如果一个类中有纯虚函数，那么它就是抽象类。

抽象类的特点

  1. 无法实例化对象，即不能Point p;（堆区、栈区都是不行的）
  2. 子类必须重写抽象类中的纯虚函数，不然也会是抽象类

抽象类示例

#include <iostream>
using namespace std;

class VirtualCalculator
{
public:
    virtual int calculate() = 0;
};

class Calculator:public VirtualCalculator
{
public:
    virtual int calculate()
    {
        cout<<"子类函数"<<endl;
        return 0;
    }
    
};

int main()
{
    VirtualCalculator* ptr= new Calculator;
    ptr->calculate();
    return 0;
}

虚析构与纯虚析构

多态中，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。

问题的根源剖析

#include <iostream>
#include <string.h>
using namespace std;

class Animal
{
public:
    Animal(){cout<<"Animal的构造函数"<<endl;}
    ~Animal(){cout<<"Animal的析构函数"<<endl;}
    virtual void Speak()=0;
};

class Cat:public Animal
{
public:
    Cat(string name)
    {
        cout<<"Cat的构造函数"<<endl;
        M_name = new string(name);
    }
    void Speak()
    {
        cout<<*M_name<<"小猫在说话"<<endl;
    }
    string* M_name;
    ~Cat()
    {
        if(M_name != NULL)
        {
            cout<<"Cat析构函数调用"<<endl;
            delete M_name;
            M_name = NULL;
        }
    }
};

void test01()
{
    Animal* ptr = new Cat("Tom");//实现“多态”：父类指针或引用来创建子类对象
    ptr->Speak();
    delete ptr;
}

int main()
{
    test01();
    return 0;
}

在这里插入图片描述
可以发现，在Animal的析构函数前缺失了Cat的析构函数。
这是因为父类指针在析构的时候，不会调用子类中的析构函数，导致子类如果有堆区属性，会造成内存泄漏。
为了解决这一问题，需要将父类中的析构函数也改成虚析构或纯虚析构。

虚析构语法

在父类中将析构函数前加一个virtual即可。
如：

virtual ~Animal()
{
cout<<"Animal析构函数调用"<<endl;
}

此时输出结果反映，目前的析构是符合我们的释放内存的期望的。
在这里插入图片描述

纯虚析构的语法

父类内声明，父类外具体实现：

class Animal
{
public:
    Animal(){cout<<"Animal的构造函数"<<endl;}
    virtual ~Animal()=0;//这一句√
    virtual void Speak()=0;
};
Animal::~Animal(){cout<<"Animal的析构函数"<<endl;}//别忘了这一句√

注：这里就体现出纯虚函数与纯虚析构函数的不同了，只有纯虚析构一定要有具体实现。

虚析构与纯虚析构的共性

  • 都能解决父类指针释放子类对象的问题
  • 都需要有具体的函数实现

虚析构与纯虚析构的不同点

纯虚析构所在的类为抽象类，无法实例化对象

一个例子

#include <iostream>
#include <string.h>
using namespace std;

class CPU
{
public:
    virtual void calculate()=0;
};

class GPU
{
public:   
    virtual void display()=0;
};

class Memory
{
public:    
    virtual void storage()=0;
};

class Computer
{
public:
    Computer(CPU* cpu,GPU* gpu,Memory* memory)
    {
        m_cpu=cpu;
        m_gpu=gpu;
        m_memory=memory;
    }
    
    void work()
    {
        m_cpu->calculate();
        m_gpu->display();
        m_memory->storage();
    }
    
    ~Computer()
    {
        if(m_cpu!=NULL)
        {
            delete m_cpu;
            m_cpu=NULL;
        }
        if(m_gpu!=NULL)
        {
            delete m_gpu;
            m_gpu=NULL;
        }
        if(m_memory!=NULL)
        {
            delete m_memory;
            m_memory=NULL;
        }
    }
private:
    CPU* m_cpu;
    GPU* m_gpu;
    Memory* m_memory;
};

class IntelCPU:public CPU
{
    virtual void calculate()
    {
        cout<<"Intel的cpu开始计算了~"<<endl;
    }
};

class IntelGPU:public GPU
{
    virtual void display()
    {
        cout<<"Intel的gpu开始显示了~"<<endl;
    }
};

class IntelMemory:public Memory
{
    virtual void storage()
    {
        cout<<"Intel的memory开始存储了~"<<endl;
    }
};

class LenovoCPU:public CPU
{
    virtual void calculate()
    {
        cout<<"Lenovo的cpu开始计算了~"<<endl;
    }
};

class LenovoGPU:public GPU
{
    virtual void display()
    {
        cout<<"Lenovo的gpu开始显示了~"<<endl;
    }
};

class LenovoMemory:public Memory
{
    virtual void storage()
    {
        cout<<"Lenovo的memory开始存储了~"<<endl;
    }
};

void test01()
{
  //配三台电脑 
  cout<<"第一台电脑："<<endl;
  //第一台电脑的零件
  CPU* intelCPU = new IntelCPU;
  GPU* intelGPU = new IntelGPU;
  Memory* intelMemory = new IntelMemory;
  //创建第一台电脑
  Computer* computer1 = new Computer(intelCPU,intelGPU,intelMemory);
  computer1->work();
  delete computer1;
  
   cout<<"第二台电脑："<<endl;
  //创建第二台电脑，可以不用创建再赋值，直接就在参数列表new
  Computer* computer2 = new Computer(new IntelCPU,new LenovoGPU,new LenovoMemory);
  computer2->work();
  delete computer2;
  
  cout<<"第三台电脑："<<endl;
  //创建第三台电脑
  Computer* computer3 = new Computer(new LenovoCPU,new IntelGPU,new IntelMemory);
  computer3->work();
  delete computer3;
  
}

int main()
{
    test01();
    return 0;
}

在这里插入图片描述
参考：
bilibili 黑马程序员C++课程 P142

PUdd
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
1.2：多态与重写.pdf
08-20
用数组输出两个show，多态 Person[] persons = new Person[2]; Student stu = new Student("aaa", 20, true); Teacher t = new Teacher("aa", 12, false); persons[0] = stu; persons[1] = t; for (int i = 0;...
C语言:多态（多继承实现）
04-23
C语言:多态（多继承实现）
C++11 类的多态
LilyNothing的博客
10-17 577
c++中类的三大特性是：继承，封装，多态。 因为近期写代码用到了类的多态性，所以在这里再总结一下。 一、多态的定义 关于多态的定义，我是参考大佬的文章再加上自己的理解得到以下内容的，大佬链接在此。 1.1 多态的定义 多态性可以简单地概括为“一个接口，多种方法”，虽然在c++中没有接口（interface）这个关键字的存在，但是可以通过多态来实现，多态的目的就是为了接口重用。C++多态性是通过...
C++11 —— 多态
weixin_37840904的博客
04-26 366
C++11 —— 多态C++多态示例一、通过基类指针调用派生类或基类成员函数示例二、通过派生类对象调用基类或派生类方法小结 C++多态 引用或指针类型的静态类型与动态类型不一致是C++语言支持多态性的根本原因。 （动态绑定只有在我们通过指针或引用调用虚函数时才会发生） 示例一、通过基类指针调用派生类或基类成员函数 #include <iostream> class BaseA { p...
【C++】十一、多态
zzzylo的博客
02-12 113
多态
C++语言基础(11)-多态
weixin_34161032的博客
06-27 72
  一.产生背景 先看下面的例子： #include &lt;iostream&gt; using namespace std; //基类People class People{ public: People(char *name, int age); void display(); protected: char *m_name; ...
C++学习笔记11——多态篇
等等waiting
02-14 169
RTTI——运行时类型识别 RTTI：Run-Time Type Identification typeid <——> denamic_cast 举例说明： Bird类继承了Flyable类，就要实现takeoff()和land()，自己特有foraging() Plane类继承了Flyable类，要实现takeoff()和land()，自己特有carry() 参数是Flyab...
Python程序基础：多态.pptx
06-06
多态指的是一类事物有多种形态，如一个父类有多个子类。 在面向对象方法中一般是这样描述多态性的：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。 例：多态实例。 #定义父类 class ...
C++:基于多态的职工管理系统
04-22
1、增加重复员工编号的判定 2、增加清除文件时输入错误的错误提示 3、解决员工岗位输入错误导致的程序崩溃
实验报告五：多态的源码文件
最新发布
11-10
实验报告五：多态的源码文件
C++ 11 类与对象(多态)
darren_pty
03-23 562
C++
C++快速入门--11--多态原理
qq_25956141的博客
03-15 259
多态实现原理图解 多态如此的神奇，我们站在C语言角度来探究多态实现原理。我们先前探究过this指针的实现原理，事实，多态也是有一个指针，当我们定义了一系列虚函数之后，编译器会产生一个虚函数表，然后再通过这个指针指向这个虚函数表，而我们知道，多态需要有继承才能实现，所以这时候，编译器会产生两个表，一个是父类的需函数表，一个是子类的虚函数表，当我们使用某个虚函数的时候，编译器根本不用关心你传过...
C++多态(十一)
qq_35496811的博客
12-31 236
多态的好处：扩展性强、组织结构清晰、代码可读性强 示例 #include<iostream> using namespace std; class make_drink { public: virtual void boil() = 0; virtual void brew() = 0; virtual void inCup() = 0; virtual void putSomething() = 0; void makedrink() { boil(); brew().
C++语言学习（十一）——多态
m0_43426943的博客
08-05 103
C++语言学习（十一）——多态 文章来源：https://blog.51cto.com/9291927/2147905 一、多态简介 C++中的多态(polymorphism)是指由继承而产生的相关的不同的类，其对象对同一消息会作出不同的响应。 多态性是面向对象程序设计的一个重要特征，能增加程序的灵活性。可以减轻系统升级，维护，调试的工作量和复杂度。 多态是一种不同层次分类下的重要联系，是一种跨层操作。 二、多态实现的前提 赋值兼容规则是指在需要基类对象的任何地方都可以使用公有派生类的对象来替代。 赋值兼容
C++学习11：多态性
雅痞的博客
08-09 131
多态：即一个事物有多种形态。在C++程序设计中，多态性是指不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同功能的函数。 关于多态性：函数重载，运算符重载。  ...
C++primer读书笔记11-多态
eskimoer的专栏
07-26 1458
多态也是C++中的一个重要的方面，多态和动态类型，虚函数本质上是指相同的事情。 1 虚函数 类中的成员函数原型前面加上virtual 表面这个函数是个虚函数。虚函数的目的是为了在继承它的派生类中重新定义这个函数，以便于通过基类的指针或引用在运行时对派生类的函数进行调用。 2 派生类和虚函数 派生类一般情况下要重定义所继承的虚函数，有几个注意事项。 虚函数的声明必须和基类中
黑马C++ 02 核心7 —— 类和对象_多态_文件操作(重难点)
qq_42731062的博客
09-05 643
C++多态和文件
C++难题之多态性详细解释
物联网小镇的博客
12-18 141
C++的多态性是C++实现面向对象技术的基础。具体的说，通过一个指向基类的指针调用虚成员函数的时候，将能够根据指针所指向的实际对象调用成员函数。 #include "stdafx.h" class father { public: void duotai() { printf("调用的是父函数\n"); } virtual void fun() { printf("调用...
c++ day 11多态 联编
qq_42031243的博客
05-05 121
多态 字面意思就是多种形态，一般出现在继承中重写同名函数上，在 调用成员函数时，会根据调用函数的对象的类型来执行不同的函数 静态多态 静态多态是编译器在编译期间完成的，编译器会根据实参类型来选择调用合适的函数，如果有合适的函数可以调用就调，没有的话就会发出警告或者报错 动态多态 它是在程序运行时根据父类的引用（指针）指向的对象来确定自己具体该调用哪一个类的虚函数。 如在类的继承的时候 子类重写了父...
第3关：多态的理解和使用 - 阿猫阿狗
06-28
多态是面向对象编程中的一个重要概念，它指的是同一个方法或者同一个类在不同的情况下表现出不同的行为。在实际编程中，我们可以通过继承、接口等方式来实现多态。通过多态，我们可以提高代码的可复用性和可扩展性，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值