首页 > 编程语言 >【C++】多态 - 含3个案例

【C++】多态 - 含3个案例

时间：2024-08-03 22:53:45浏览次数：17  
标签：函数 void 多态 C++ class 案例 virtual public

目录

一、多态分类

二、多态区别

三、多态基本语法

四、多态原理

五、案例1：计算机类

六、纯虚函数和抽象类

七、案例2：制作饮品

八、虚析构和纯虚析构

九、案例3：电脑组装需求分析及实现

多态是C++面向对象三大特性之一

一、多态分类

①静态多态：函数重载、运算符重载、复用函数名

②动态多态：派生类、虚函数

二、多态区别

①静态多态：函数地址早绑定，编译阶段确定函数地址

②动态多态：函数地址晚绑定，运行阶段确定函数地址

三、多态基本语法
//动物类
class Animal
{
public:
    virtual void speak()
    {
        cout << "动物在讲话" << endl;
    }
};

//猫类
class Cat : public Animal
{
    void speak()
    {
        cout << "小猫在讲话" << endl;
    };
};

//狗类
class Dog : public Animal
{
    void speak()
    {
        cout << "小狗在讲话" << endl;
    };
};

//执行模块
//父类引用指向子类 C++中允许父子之间的类型转换 父类的引用/指针可以直接指向子类对象
//下面的函数属于地址早绑定，在编译阶段确定函数地址
//如果需要子类执行父类中的函数，函数地址不能早绑定，需要利用动态多态动态晚绑定【在父类中的函数前面加上virtual关键字】
void doSpeak(Animal &animal)
{
    animal.speak();
}

void test()
{
    Cat cat;
    doSpeak(cat);

    Dog dog;
    doSpeak(dog);
}

** 动态多态满足条件 **

1、有继承关系

2、子类要重写父类虚函数（函数返回值类型、函数名字、参数列表一样）

** 动态多态的使用 **

父类的指针/引用指向子类的对象

四、多态原理

①当前动物类中只有一个非静态的成员函数（相当于空类），所以当前类的大小为：1

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

②加上virtual关键字后，类的大小为：4，类中多了一个[vfptr]虚函数指针（大小为4个字节）

vfptr会指向vftable（虚函数表），表中会记录着虚函数地址（&Animal ：：speak）

class Animal
{
public:
    virtual void speak()
    {
        cout << "动物在讲话" << endl;
    }
};

当子类重写虚函数的时，vftable中的父类的虚函数地址会被覆盖掉然后变成（&Cat：：speak）

//猫类
class Cat : public Animal
{
    void speak()
    {
        cout << "小猫在讲话" << endl;
    };
};

所以当父类指针或引用指向子类对象时，发生多态

Animal & animal = cat;

animal.speak();

由于指向cat对象，所以编译器会从cat的vftable中找虚函数地址（&Cat：：speak）

五、案例1：计算机类

案例描述：利用普通方法和多态方法实现两个操作数运算的计算机类

多态的优点：

①代码组织结构清晰

②可读性强

③利于前期和后期的扩展及维护

1、普通方法

class Calculator
{
public:
    int getRet(string oper)
    {
        if(oper == "+")
        {
            return m_Num1 + m_Num2;
        }
        else if(oper == "-")
        {
            return m_Num1 - m_Num2;
        }
        else if(oper == "*")
        {
            return m_Num1 * m_Num2;
        }
        
    };

    int m_Num1;
    int m_Num2;
};

void test()
{
    Calculator c;
    c.m_Num1 = 10;
    c.m_Num2 = 10;

    cout << "num1+num2 = " << c.getRet("+") << endl;
    cout << "num1-num2 = " << c.getRet("-") << endl;
    cout << "num1*num2 = " << c.getRet("*") << endl;
}

在企业开发中，不建议使用该普通方法（因为想要扩展新的功能时需要修改源码）不利于维护

提倡使用开闭原则：对扩展进行开放，对修改进行关闭

2、多态方法

** 抽象类关键字：Abstract **

//实现计算器抽象类(基类)
class AbstractCalculator
{
public:
    virtual int getRet(string oper)
    {
       return 0;
    };

    int m_Num1;
    int m_Num2;
};

//加法计算器类
class Add() :public AbstractCalculator
{
public:
    int getRet(string oper)
    {
       return m_Num1 + m_Num2;
    };
};

//减法计算器类
class Sub() :public AbstractCalculator
{
public:
    int getRet(string oper)
    {
       return m_Num1 - m_Num2;
    };
};

//乘法计算器类
class Mul() :public AbstractCalculator
{
public:
    int getRet(string oper)
    {
       return m_Num1 * m_Num2;
    };
};

void test()
{
   //多态使用条件
   //父类指针或引用指向子类对象

   //加法
   AbstractCalculator * abc = new Add;
   abc->m_Num1 = 10;
   abc->m_Num2 = 10;
   cout << "num1 + num2 = " << abc->getRet() << endl;
   //用完后要手动释放堆区数据
   delete abc;
    
   //减法运算
   abc = new Sub;
   abc->m_Num1 = 10;
   abc->m_Num2 = 10;
   cout << "num1 - num2 = " << abc->getRet() << endl;
}
六、纯虚函数和抽象类

1、纯虚函数

①通常父类中虚函数的实现毫无意义，可以将其写为纯虚函数

②语法：virtual 返回值类型 函数名 （参数列表） = 0；

③当类中有了纯虚函数，这个类就是抽象类

2、抽象类

特点：①无法实例化对象 ②子类必须重写抽象类中的纯虚函数，否则也属于抽象类

class Base
{
public:
    virtual void func() = 0;
};

class son :public Base
{
public:
    void func()
    {
        cout << "func函数调用" << endl;
    }
};

void test()
{
    Base * base = new Son;
    base->func();
}

七、案例2：制作饮品

制作流程：煮水 -> 冲泡 -> 倒入杯中 -> 加入材料

class AbstractDrinking
{
public:
    //煮水
    virtual void Boil() = 0;
    
    //冲泡
    virtual void Brew() = 0;
    
    //倒入杯中
    virtual void Pour() = 0;

    //加入材料
    virtual void Put() = 0;

    //制作饮料
    void makeDrink()
    {
        Boil();
        Brew();
        Pour();
        Put();
    }
};

class coffee :public AbstractDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout << "煮百岁山水" << endl;
    }
    
    //冲泡
    virtual void Brew()
    {
        cout << "冲泡咖啡" << endl;
    }
    
    //倒入杯中
    virtual void Pour()
    {
        cout << "倒入纸杯中" << endl;
    }

    //加入材料
    virtual void Put()
    {
        cout << "加入糖浆和奶" << endl;
    }
};

class tea:public AbstractDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout << "煮哇哈哈水" << endl;
    }
    
    //冲泡
    virtual void Brew()
    {
        cout << "冲泡茶水" << endl;
    }
    
    //倒入杯中
    virtual void Pour()
    {
        cout << "倒入陶瓷杯中" << endl;
    }

    //加入材料
    virtual void Put()
    {
        cout << "加入水果片" << endl;
    }
};

void doWork(AbstractDrinking * abs)
{
    abs->makeDrink();
    delete abs;   
}

void test()
{
    doWork(new coffee);

    cout << "-----------------" << endl;

    doWork(new tea);
}

八、虚析构和纯虚析构

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

解决方法：将父类中析构函数改为虚析构或纯虚析构

虚析构和纯虚析构共性：

①可以解决父类指针释放子类对象

②都需要具体的函数实现

虚析构和纯虚析构区别：

如果类中有纯虚析构函数，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名（）{ }；

纯虚析构语法：

virtual ~类名（）= 0；

类名::~类名（）{}

注意：虚析构函数和纯虚析构函数二者选其一即可；纯虚析构函数需要在类内声明类外实现[要保证父类中对象也有函数析构]

class Animal
(
pubulic:
    //纯虚函数
    virtual void speak() = 0;
    
    //构造函数
    Animal()
    {
        cout << "Animal的构造函数调用" << endl;
    }

    //虚析构函数
    //解决父类指针释放子类对象不干净的问题    
    virtual ~Animal()  
    {
        cout << "Animal的虚析构函数调用" << endl;
    }

    //纯虚析构函数
     virtual ~Animal() = 0 ;

);

//纯虚析构
Animal::~Animal()
{
    cout << "Animal的纯虚析构函数调用" << endl;
}

class Cat :public Animal
{
    
    Cat(string name)
    {
        cout << "Cat的构造函数调用" << endl;
        m_Name = new string(name);//让小猫的姓名创建在堆区中   
    }

    void speak()
    {
        cout << *m_Name <<"小猫在说话" << endl;
    }

    ~Cat()
    {
        if(m_Name != NULL)
        {
            cout << "Cat的析构函数调用" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }

    string *m_Name;//创建指针维护 

};

void test()
{
    Animal * animal = new Cat("Tom");
    animal->speak();
    //父类指针在析构时候，不会调用子类中的析构函数。导致子类如果有堆区数据/属性，会出现内存的泄露情况
    //解决问题：将父类析构函数改为虚析构函数
    delete animal;
}

九、案例3：电脑组装需求分析及实现
//写出每一个零件的抽象类

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

class VideoCard //显卡
{
public:
    virtual void display() = 0;
};

class Memory //内存条
{
public:
    virtual void storage() = 0;
};

class Computer
{
public:
    Computer(CPU &cpu, VideoCard &videocard, Memory &memory)
    {
       c = cpu;
       vc = videocard;
       mem = memory;
    }

    //让零件工作起来
    void work()
    {
        c->calculate();
        vc->display();
        mem->storage();
    }

    ~Computer()
    {
        if(c != NULL)
        {
            delete c;
            c = NULL;
        }
        else if(vc != NULL)
        {
            delete vc;
            vc = NULL;
        }
        else if(mem != NULL)
        {
            delete mem;
            mem = NULL;
        }
    }

private:
    
    CPU * c; //cpu零件指针
    VideoCard * vc;
    Memory * mem;
}

//Intel厂商
class IntelCpu :public CPU
{
public:
    void calculate()
    {
        cout << "Intel的CPU开始计算了" << endl;
    } 
}

class IntelVideoCard :public VideoCard 
{
public:
    void display()
    {
        cout << "Intel的显卡开始工作了" << endl;
    } 
}

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

//Lenovo厂商
class LenovoCpu :public CPU
{
public:
    void calculate()
    {
        cout << "Lenovo的CPU开始计算了" << endl;
    } 
}

class LenovoVideoCard :public VideoCard 
{
public:
    void display()
    {
        cout << "Lenovo的显卡开始工作了" << endl;
    } 
}

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

//开始组装电脑
void test()
{
    //第一台电脑的零件
    CPU * intelCPU = new IntelCPU;
    VideoCard * intelCard = new IntelVideoCard;
    Memory * intelMem = new IntelMemory;

    //创建第一台电脑
    cout << "第一台电脑开始工作" << endl;
    Computer * computer1 = new Computer(intelCPU,intelCard,intelMem);
    computer1->work();
    delete computer1;

    //创建第二台电脑
    cout << "-----------------" << endl;
    cout << "第二台电脑开始工作" << endl;
    Computer * computer2 = new Computer(new LenovoCPU,new LenovoCard,new LenovoMem);
    computer2->work();
    delete computer2;

    cout << "-----------------" << endl;
    cout << "第三台电脑开始工作" << endl;
    Computer * computer3 = new Computer(new LenovoCPU,new IntelVideoCard,new LenovoMem);
    computer3->work();
    delete computer3;
}

标签：函数,void,多态,C++,class,案例,virtual,public
From： https://blog.csdn.net/weixin_60546365/article/details/140882665

相关文章

  • C++__位运算符：异或运算符 ^
    目的：     了解异或运算符的定义、性质及用法。定义：    二元运算符，符号为^，与位与、位或不同的是，它在二进制中为相同为0，不同为1。而且它还满足这几种运算规则：        1、任何数^0都等于它本身；    2、两个相同的数异或结果为0；    ......
  • C++自定义接口类设计器之模板代码生成四
    关键代码QStringListmultis=templateStr.split('\n');boolstartConfig=false;boolstartVar=false;boolstartTemplate=false;for(constauto&line:multis){if(startConfig){if(line.trimmed().st......
  • c++__位运算符：位与运算符&
    目的：了解位与运算符并加深对它的运用定义：一种二元运算符，符号为&，运用于二进制数中，特性为有0为0。#include<iostream>usingnamespacestd;intmain(){inta=0b1010;//10intb=0b0110;//6//a&b=0b0010;2cout<<(a&b)<<endl;}应用：1、判断奇偶性......
  • C++实现静态链表
    #include<iostream>usingnamespacestd;//定义静态链表的最大容量constintMAX_SIZE=100;//节点类classNode{public:intdata;//节点存储的数据intnext;//节点指向下一个节点的索引（在数组中的位置）//默认构造函数Node():data(0......
  • Java【案例2-2】 小明都可以买什么
    案例介绍：编写一个智能购物计算小程序，在一家商店有书本、铅笔、橡皮、可乐、零食五种商品，商品价格如下表所示。商品名称价格书本12元铅笔1元橡皮2元可乐3元零食5元假如你带了20元，且必须购买一本书，剩余的钱还可以购买哪种商品，可以购买几件，购买完后又能......
  • c++三国杀
    废话不多说，直接上代码！！！#include<iostream>#include<time.h>#include<stdio.h>#include<stdlib.h>usingnamespacestd;structpai{intpaifu;inthuase;intyanse;intdianshu;intleixing;intchangdu;voidKanpai(){if(paifu==0||paifu==......
  • 「字符串」实现Trie（字典树|前缀树）的功能 / 手撕数据结构（C++）
    概述在浏览器搜索栏里输入几个字，就弹出了以你的输入为开头的一系列句子。浏览器是怎么知道你接下来要输什么的？来看看字典树干了什么。字典树是一种高效记录字符串和查找字符串的数据结构。它以每个字符作为一个节点对字符串进行分割记录，节点形成树状结构，在录入或查找时只......
  • 【leetcode详解】正方形中的最多点数【中等】(C++思路精析)
    思路精析：自定义结构体解读：一个点是否在题给正方形中，只取决于其横纵坐标的最大值，记为dis沟通二位数组points和字符串s的桥梁，就是这个点的序号，记为idx由此自定义结构体，储存dis和idx//其中booloperator部分的功能：重载小于操作符“<”,使sort(vc.begin(),vc.end());按dis......
  • 整数二分（c++）
    1、什么是整数二分：即可以看做成找数字那个游戏在一百个数字中找到指定的数字(66)A出题B：50A50太小了B:(50+100)/2=75A75太大了B：(50+75)/2=62…所以也可以知道一个结论：有单调性，一定可以二分。可以二分的题目，不一定有单调性。2、代码思路：1、寻找到满足......
  • 【C++BFS】802. 找到最终的安全状态
    本文涉及知识点C++BFS算法LeetCode802.找到最终的安全状态有一个有n个节点的有向图，节点按0到n-1编号。图由一个索引从0开始的2D整数数组graph表示，graph[i]是与节点i相邻的节点的整数数组，这意味着从节点i到graph[i]中的每个节点都有一条边。如果一......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99