【c++自学笔记 核心编程篇（五）多态】

已于 2022-10-24 16:45:24 修改
阅读量276 收藏
点赞数
分类专栏： c++笔记 文章标签： c++ 开发语言 1024程序员节
于 2022-10-10 23:15:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54549527/article/details/127248604
版权

文章目录

4.7 多态

4.7.1 多态的基本概念

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

多态分为两类：

  • 静态多态：函数重载和运算符重载属于静态多态，复用函数名
  • 动态多态：派生类和虚函数实现运行时多态
    通常我们在c++中说的多态多为动态多态。

静态多态和动态多态区别：

  • 静态多态的函数地址早绑定（编译阶段确定函数地址）
  • 动态多态的函数地址晚绑定（运行阶段确定函数地址）

动态多态满足条件：

  1. 有继承关系
  2. 子类要重写父类中的虚函数（重写和重载不同，重写：函数返回值类型、函数名、参数列表完全形同。virtual关键字可写可不写）

以下面案例为例。

class Animal{
public:
    //虚函数
    virtual void speak(){
        cout << "动物在说话" << endl;
    }
};
class Cat :public Animal{
public:
	//子类重写父类虚函数
    void speak(){
        cout << "小猫在说话" << endl;
    }
};
class Dog :public Animal{
public:
	//子类重写父类虚函数
    void speak(){
        cout << "小狗在说话" << endl;
    }
};

动态多态的使用

  • 父类的指针或者引用 指向子类对象
void doSpeak(Animal &animal){ //Animal & animal = cat;
    animal.speak();
}
void test01(){
    Cat cat;
    doSpeak(cat);

    Dog dog;
    doSpeak(dog);
}

完整代码如下：

#include <iostream>
using namespace std;
//多态
class Animal{
public:
    //虚函数
    virtual void speak(){
        cout << "动物在说话" << endl;
    }
};
class Cat :public Animal{
public:
    void speak(){
        cout << "小猫在说话" << endl;
    }
};
class Dog :public Animal{
public:
    void speak(){
        cout << "小狗在说话" << endl;
    }
};
//执行说话的函数
//地址早绑定 在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定
void doSpeak(Animal &animal){ //Animal & animal = cat;
    animal.speak();
}
void test01(){
    Cat cat;
    doSpeak(cat);

    Dog dog;
    doSpeak(dog);
}
int main(){
    test01();
    system("pause");
    return 0;
}

运行结果

小猫在说话
小狗在说话

那么认识了多态之后，多态的底层原理又是什么呢？
接下来我们来看看多态的原理刨析。

4.7.2 多态的原理刨析

关于多态的原理刨析，我依旧通过上述案例来解释一下。

一、发现与引入

  1. 首先看一下该类的定义，此时父类中函数不加关键字virtual，即不发生动态多态。通过sizeof可知该类大小为1字节。（原因：前面章节讲过，对于没有定义非成员变量的类，看作空类，空类占一个字节。）：
class Animal{
public:
	void speak(){
        cout << "动物在说话" << endl;
    }
};
  1. 那么加上virtual，sizeof(Animal）的值又为多少。
class Animal{
public:
    //虚函数
    void virtual speak(){
        cout << "动物在说话" << endl;
    }
};
void test(){
	cout << "sizeof Animal  = " << sizeof(Animal) << endl;
}
  1. 通过测试可知，加上virtual后类内部结构改变，其大小变为8个字节。此时，类内多了一个虚表指针。
    Alt

二、虚函数(表)指针（vfptr）与虚函数表（vftable）

  • 在类的函数前加上virtual后，其类内结构发生变化，会多出一个虚函数指针vfptr，该指针指向一个表，为此类的虚函数表vftable，如下图所示。
    Alt
  • 虚函数表vftable内记录着该虚函数的地址。
    而当子类重写父类的虚函数，子类中的虚函数表内部会替换成子类的虚函数地址（如下图）。
    在这里插入图片描述
    故此时当父类的指针或者引用指向子类对象时，发生（动态）多态：

4.7.3 多态案例一：计算机类

案例描述： 分别利用普通写法和多态技术，设计实现两个操作数 进行运算的计算器类

多态的优点：

  • 代码组织结构清晰
  • 可读性强
  • 利于前期和后期的扩展以及维护

示例：

#include <iostream>
#include <string>
using namespace std;
//分别利用普通写法和多态技术实现计算器
class Calculator{
public:
    int getResult(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;
        }
        else if(oper == "/"){
            return m_Num1 / m_Num2;
        }
        //如果想扩展新的功能，需修改源码
        //在真实开发中 提倡 开闭原则
        //开闭原则：对扩展进行开发，对修改进行关闭
    }
    int m_Num1;//操作数1
    int m_Num2;//操作数2
};
void test01(){
     Calculator c;
     c.m_Num1 = 10;
     c.m_Num2 = 10;
     cout << c.m_Num1 << "+" << c.m_Num2 << "= " << c.getResult("+") << endl;
     cout << c.m_Num1 << "-" << c.m_Num2 << "= " << c.getResult("-") << endl;
     cout << c.m_Num1 << "*" << c.m_Num2 << "= " << c.getResult("*") << endl;
     cout << c.m_Num1 << "/" << c.m_Num2 << "= " << c.getResult("/") << endl;
}
//利用多态实现计算器
//实现计算器抽象类
class AbstractCalculator{
public:
    virtual int getResult(){
        return 0;
    }
    int m_Num1;
    int m_Num2;
};
//+
class AddCalculator :public AbstractCalculator{
public:
    int getResult(){
        return m_Num1 + m_Num2;
    }
};//-
class SubCalculator :public AbstractCalculator{
public:
    int getResult(){
        return m_Num1 - m_Num2;
    }
};
//*
class MulCalculator :public AbstractCalculator{
public:
    int getResult(){
        return m_Num1 * m_Num2;
    }
};
void test02(){
    //多态使用条件
    //父类指针或者引用指向子类对象
    AbstractCalculator * abc = new AddCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    cout << abc->getResult() << endl;
    delete abc;
    abc = new SubCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    cout << abc->getResult() << endl;
    delete abc;
}
int main(){
    test02();
    system("pause");
    return 0;
}

4.7.4 纯虚函数和抽象类

  • 在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容。 因此可以将虚函数改为纯虚函数。
  • 纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0；
  • 当类中有了纯虚函数，这个类也称为抽象类。
  • 抽象类特点：
    • 无法实例化对象。
    • 子类必须重写抽象类中的抽象函数，否则也属于抽象类。
  • 示例代码：
class AbstractCalculator {
public:
    virtual int getResult() = 0;
    int m_Num1;
    int m_Num2;
};

4.7.5 多态案例二：制作饮品

  • 案例描述： 制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料。 利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶。

代码实现：

#include <iostream>
using namespace std;
class AbstractDrinking{
public:
    //煮水
    virtual void Boil() = 0;
    //冲泡
    virtual void Brew() = 0;
    //倒入杯中
    virtual void PourInCup() = 0;
    //加入辅料
    virtual void PutSomething() = 0;
    //制作饮品
    void makeDrink(){
        Boil();
        Brew();
        PourInCup();
        PutSomething();
    }
};
//制作咖啡
class Coffee :public AbstractDrinking{
public:
    //煮水
    virtual void Boil() {
        cout << "煮农夫山泉" << endl;
    }
    //冲泡
    virtual void Brew() {
        cout << "冲泡咖啡" << endl;
    }
    //倒入杯中
    virtual void PourInCup() {
        cout << "倒入杯中" << endl;
    }
    //加入辅料
    virtual void PutSomething() {
        cout << "加入糖和牛奶" << endl;
    }
};
//制作咖啡
class Tea :public AbstractDrinking{
public:
    //煮水
    virtual void Boil() {
        cout << "煮矿泉水" << endl;
    }
    //冲泡
    virtual void Brew() {
        cout << "冲泡茶叶" << endl;
    }
    //倒入杯中
    virtual void PourInCup() {
        cout << "倒入杯中" << endl;
    }
    //加入辅料
    virtual void PutSomething() {
        cout << "加入枸杞" << endl;
    }
};
void dowork(AbstractDrinking * abs){
    abs->makeDrink();
    delete abs;
}
void test01(){
    //制作咖啡
    dowork(new Coffee);
}
int main(){
    test01();
    system("pause");
    return 0;
}
  • 运行结果：
    Alt

4.7.6 虚析构和纯虚析构

  • 多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。
    如下例所示：
#include <iostream>
#include <string>
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);
    }
    virtual void speak(){
        cout << *m_Name << "小猫在说话" << endl;
    }
    ~Cat(){
        if(m_Name != NULL)
        {
            cout << "Cat析构函数调用" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }
    string *m_Name;
};
void test01(){
    Animal * animal  = new Cat("Tom");
    animal->speak();
    //父类指针在析构时候不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄漏
    delete animal;
}
int main(){
    test01();
    system("pause");
    return 0;
}
  • 运行结果：
    Alt
    上图可发现调用不到子类析构函数。
  • 解决方式：将父类中的析构函数改为虚析构或者纯虚析构
  • 虚析构和纯析构共性：
    • 可以解决父类指针释放子类对象
    • 都需要有具体的函数实现
  • 虚析构和纯虚析构区别：
    • 如果是纯虚析构，该类属于抽象类，无法实例化对象
  • 虚析构语法：virtual~类名(){}
  • 纯虚析构语法：virtual~类名() = 0； 类名::类名(){}
  1. 现在试试将虚析构运用到上述示例中（更改代码中父类的析构部分）：
class Animal{
public:
    Animal(){
        cout << "Animal构造函数调用" << endl;
    }
    //利用虚析构可以解决父类指针释放子类对象时不干净的问题
    virtual ~Animal(){
        cout << "Animal析构函数调用" << endl;
    }
    virtual void speak() = 0;
};

-运行结果( 可发现子类析构函数调用成功)：
Alt

而如果使用纯虚析构，则必须在类外对纯虚析构进行实现，否则会报错（因为析构和构造是必须要被实现的）。

  1. 下面看看纯虚析构的具体运用吧：
class Animal{
public:
    Animal(){
        cout << "Animal构造函数调用" << endl;
    }
    //利用虚析构可以解决父类指针释放子类对象时不干净的问题
//    virtual ~Animal(){
//        cout << "Animal析构函数调用" << endl;
//    }
    //纯虚析构 需要声明也需要实现
    virtual ~Animal() = 0;
    virtual void speak() = 0;
};
//类外实现纯虚析构
Animal :: ~Animal() {
    cout << "Animal的纯虚析构函数" << endl;
}
  • 运行结果(子类析构函数调用成功)：
    Alt
  • 总结：
    • 虚析构或者纯虚析构就是用来解决通过父类指针释放子类对象。
    • 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构。
    • 拥有纯虚析构函数的类也属于抽象类。

4.7.7 多态案例三：电脑组装

案例描述： 电脑主要组成部件为CPU（用于计算），显卡（用于显示），内存条（用于储存）， 将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenvo厂商，
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口。 测试时组装三台不同的电脑进行工作。

  • 思路：
    Alt
  • 代码实现：
#include <iostream>
#include <string>
using namespace std;
//抽象的CPU
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 *vc, Memory *mem){
        m_Cpu = cpu;
        m_VC = vc;
        m_Mem = mem;
    }
    //提供工作的函数
    void work(){
        //让零件工作起来，调用接口
        m_Cpu->calculate();
        m_VC->display();
        m_Mem->storage();
    }
    //提供析构函数 释放3个电脑零件
    ~Computer(){
        //释放cpu零件
        if(m_Cpu != NULL){
            delete m_Cpu;
            m_Cpu = NULL;
        }
        //释放显卡零件
        if(m_VC != NULL){
            delete m_VC;
            m_VC = NULL;
        }
        //释放内存条零件
        if(m_Mem != NULL){
            delete m_Mem;
            m_Mem = NULL;
        }
    }
private:
    CPU* m_Cpu;  //CPU零件指针
    VideoCard* m_VC;  //显卡零件指针
    Memory* m_Mem;   //内存条零件指针
};
//具体厂商
//Intel厂商
class IntelCpu :public CPU{
public:
    virtual void calculate(){
        cout << "Intel的CPU开始计算了" << endl;
    }
};
class IntelVCard :public VideoCard{
public:
    void display(){
        cout << "Intel的显卡开始显示了" << endl;
    }
};
class IntelMemory :public Memory{
public:
    void storage(){
        cout << "Intel的内存条开始存储了！" << endl;
    }
};
class LenovoCpu :public CPU{
public:
    void calculate(){
        cout << "Lenovo的CPU开始计算了" << endl;
    }
};
class LenovoCard :public VideoCard{
public:
    void display(){
        cout << "Lenovo的显卡开始显示了" << endl;
    }
};
class LenovoMemory :public Memory{
public:
    void storage(){
        cout << "Lenovo的内存条开始存储了！" << endl;
    }
};
void test01(){
    //第一台零件
    CPU * intelCpu = new IntelCpu;
    VideoCard * intelCard = new IntelVCard;
    Memory * intelMem = new IntelMemory;
    //创建第一台电脑
    cout << "---------------第一台电脑开始工作--------------" << endl;
    Computer * computer1 = new Computer(intelCpu, intelCard, intelMem);
    computer1->work();
    delete computer1;

    //第二台电脑组装
    cout << "---------------第二台电脑开始工作--------------" << endl;
    Computer * computer2 = new Computer(new LenovoCpu, new LenovoCard, new LenovoMemory);
    computer2->work();
    delete computer2;

    //第三台电脑组装
    cout << "----------------第三台电脑开始工作--------------" << endl;
    Computer * computer3 = new Computer(new IntelCpu, new LenovoCard, new IntelMemory);
    computer3->work();
    delete computer3;
}

int main(){
    test01();
    system("pause");
    return 0;
}
  • 运行结果：
    Alt

至此，多态学习结束，完结撒花~

布逆呲没来
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#中面向对象编程机制之多态学习笔记
09-03
主要介绍了C#中面向对象编程机制之多态学习笔记,本文总结了个人对多态的理解以及接口多态、继承多态等内容,并给出了代码示例,需要的朋友可以参考下
C++自学笔记 核心编程篇（一）
我的博客
09-11 513
c++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置。堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete。堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程。栈区：由编译器自动分配释放，存放函数的参数值，局部变量等。类在设计时，可以把属性和行为放在不同的权限下，加以控制。由编译器自动分配释放，存放函数的参数值，局部变量等。
【c++自学笔记 核心编程篇（六）文件操作】核心编程篇完结
我的博客
10-24 59
读文件与写文件步骤相似，但是读取方式相对于比较多。二进制方式写文件主要利用流对象调用成员函数。二进制文件读文件主要利用流对象调用成员函数。注意：文件打开方式可以配合使用，利用。例如：用二进制方式写文件。
c++ 自学笔记：多态
haoNote
01-16 125
c++ 自学笔记：多态1.什么是多态2.动态多态的原理 1.什么是多态 C++面向对象三大特征：封装、继承、多态 多态分两类： 静态多态：包括 函数重载、运算符重载，复用函数名 动态多态：包括 派生类、虚函数实现运行时多态 静态多态与动态多态区别： 静态多态的函数地址早绑定——编译阶段确定函数地址 动态多态的函数地址晚绑定——运行阶段确定函数地址 动态多态满足条件： 有继承关系 子类重写...
c++自学笔记(陆续更新)
xuelang532777032的博客
04-28 891
抽象是从具体的实例中提取共同的特征，形成抽象类或接口，以便于代码的复用和扩展。抽象类和接口可以让程序员专注于高层次的设计和业务逻辑，而不必关注底层的实现细节。
C++基础入门：面相对象编程C++中的封装、继承和多态.docx
08-06
面向对象编程（Object-Oriented Programming...C++作为一种强大的编程语言，提供了丰富的面向对象编程特性，其中封装、继承和多态是最重要的三个概念。本文将深入探讨C++中的封装、继承和多态，并给出相关的代码示例。
C++中的静态多态和动态多态
01-20
的C++已经是个多重泛型编程语言(multiparadigm programming lauguage)，一个同时支持过程形式(procedural)、面向对象形式(object-oriented)、函数形式(functional)、泛型形式(generic)、元编程形式(metaprogramming)...
C++虚函数多态和纯虚函数多态的经典示例源码
02-25
C++虚函数多态和纯虚函数多态的经典示例源码
C++教学——从入门到精通 10.循环
QIPABOSHI的博客
04-24 369
一些事嘛，需要重复做，这就是循环在开始学之前我提一个事，最好先学Python再学C++，不然就会像我和piaojunhe_0825一样有C++后遗症，在Python里写了一个for(int i=0;i
【C】 初识C语言
努力学习C/C++
04-21 770
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
C++ WebServer的细节理解
我的博客
04-22 622
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
笨蛋学C++【C++基础第六弹】
YSL_Monet的博客
04-24 819
定义类需要用到关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数class 类名{访问修饰符（public/protected/private）:成员变量;成员函数();
C语言如何⽤指针为函数传递数组？
最新发布
PAP
04-25 206
C语言如何⽤指针为函数传递数组？
【C++风云录】精益求精：探索C++开发中的性能优化艺术
记录我的学习历程
04-21 1109
本文将介绍几个在C++开发中常用的性能分析工具和性能优化工具集，包括PerfTools、gperftools、Valgrind、Intel VTune、PAPI以及Boost.Profile。通过深入了解这些工具的功能和用途，读者可以更好地理解如何利用它们来提高代码的执行效率和资源利用率。
C++——初识模板
qq_74245477的博客
04-22 911
之前实现的数据结构，比如栈，我们为了便于修改存储的数据类型，通常使用typedef来重定义数据类型，但是这样有一个缺陷，会导致我们定义的栈存储的都是一种数据，如果同时需要两个栈，一个存储int，一个存储自定义类型，那么typedef就不管用了。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于字符类型也是如此。概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型的版本。
理解C语言中的位操作和整数类型：一个温度传感器读取问题的解析
qq_61637982的博客
04-24 235
当我们编写嵌入式系统的代码时，我们经常需要使用位操作来处理硬件设备的数据。然而，如果我们对C语言的位操作和整数类型不完全理解，可能会遇到一些难以理解的问题。在这篇博客中，我将通过一个实际的例子来解释这些概念，并提供一个解决方案。
C++中的抽象类
hh121386的博客
04-23 200
C++中的抽象类
掉落回弹问题（C语言）
m0_67184754的博客
04-22 364
【代码】掉落回弹问题（C语言）
黑马程序员c++核心编程
10-24
黑马程序员C++核心编程是一门针对C++语言的深入学习课程，主要包括C++基础语法、面向对象编程、模板、STL等内容。该课程通过理论讲解和实战演练相结合的方式，帮助学员深入理解C++语言的核心概念和编程思想，掌握C++编程的基本技能和实践经验。 具体来说，该课程包括以下几个方面的内容： 1. C++基础语法：包括数据类型、运算符、流控制语句、函数等基本语法知识。 2. 面向对象编程：包括类和对象、继承和多态、虚函数、友元等面向对象编程的核心概念和技术。 3. 模板：包括函数模板和类模板的定义和使用，以及模板特化和偏特化等高级应用。 4. STL：包括STL容器、迭代器、算法等STL库的使用方法和实现原理。 此外，该课程还提供了大量的实战演练，通过编写实际的C++程序来巩固所学知识，并提供了丰富的案例和项目实战，帮助学员将所学知识应用到实际项目中。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值