C++笔记打卡第13天（多态）

Cycal1020

已于 2024-04-14 23:40:02 修改

阅读量594

点赞数 14

分类专栏： C++ 文章标签： c++ 笔记 java

于 2024-04-14 23:34:31 首次发布

本文链接：https://blog.csdn.net/weixin_57139639/article/details/137758134

版权

C++ 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

本文详细介绍了C++中的多态概念，包括vfptr和vftable的作用，子类重写父类虚函数的过程，以及多态在计算器、饮品制作和电脑组装案例中的应用。此外，还讨论了纯虚函数、抽象类、虚析构及其区别，以及如何解决父类指针释放子类对象的问题。

摘要由CSDN通过智能技术生成

1.多态的基本原理

vfptr - 虚函数表指针（指向虚函数表）

v:virtual
f:function
ptr:pointer

vftable - 虚函数表（存储类中所有虚函数地址）

v:virtual
f:funtion
table:table

当子类重写父类的虚函数，子类中的虚函数表内部会替换成子类的虚函数地址

如：在Cat类中，原本继承自父类的@Animal::speak，因为重写，变成了@Cat::Speak

当父类的指针或者引用指向子类对象时，发生多态。

如：Animal &animal = cat; 由于此时父类的指针指向cat，就会从cat的虚函数表中找到speak这个函数，这就是动态多态。

2.多态案例一：计算器类

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

多态的优点：代码组织结构清晰；可读性强；利于前期和后期的扩展以及维护

// 普通写法
class Calculator
{
public:
    int getResult(string oper)
    {
        if (oper == "+")
        {
            return m_Num1 + m_Num2;
        }
        if (oper == "-")
        {
            return m_Num1 - m_Num2;
        }
        if (oper == "*")
        {
            return m_Num1 * m_Num2;
        }
        // 如果想扩展新的功能，需要修改源码
        // 在真实开发中，提倡开闭原则
        // 开闭原则：对扩展进行开放，对修改进行关闭
    }
    int m_Num1;
    int m_Num2;
};

void test01()
{
    Calculator c1;
    c1.m_Num1 = 10;
    c1.m_Num2 = 20;
    cout << c1.getResult("+") << endl;
}

// 利用多态实现
// 多态的好处：1.组织结构清晰 2.可读性强 3.对于前期和后期扩展以及维护性高
// 实现计算器抽象类
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;
    }
};

void test02()
{
    // 加法
    abstractCalculator* abc = new AddCalculator; // 父类的指针指向子类的对象,是发生多态的条件
    abc->m_Num1 = 10;
    abc->m_Num2 = 20;
    cout << abc->getResult() << endl;
    delete abc;

    // 减法
    abc = new SubCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 20;
    cout << abc->getResult() << endl;
    delete abc;
}

3.纯虚函数和抽象类

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

class Base
{
public:
    // 纯虚函数
    // 只要有一个纯虚函数，这个类就称为抽象类
    // 抽象类的特点：
    // 1.无法实例化对象（如Base base; 错误)
    // 2.子类必须重写父类的纯虚函数,否则也无法实例化对象
    virtual void func() = 0;
};
class Son :public Base
{
public:
    virtual void func()
    {
        cout << "func函数调用" << endl;
    }
};
void test01()
{
    // Base base;  // 错误，抽象类无法实例化对象
    Base* base = new Son;  // 使用Base类型的指针指向Son的实例
    base->func();  // 动态绑定调用Son的func
    delete base;
}

4.多态案例二：制作饮品

问题：制作饮品的大概流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料，请使用多态技术实现本案例，提供抽象制作的饮品基类，根据子类制作咖啡和茶叶。

class AbstractDrinking
{
public:
    virtual void Boil() = 0;
    virtual void Brew() = 0;
    virtual void Pourintocup() = 0;
    virtual void PutSomething() = 0;
    void MakeDrink()
    {
        Boil();
        Brew();
        Pourintocup();
        PutSomething();
    }
};

// 制作咖啡
class Coffee :public AbstractDrinking
{
    virtual void Boil() 
    {
        cout << "煮水" << endl;
    }
    virtual void Brew()
    {
        cout << "冲泡咖啡" << endl;
    }
    virtual void Pourintocup()
    {
        cout << "倒入杯中" << endl;
    }
    virtual void PutSomething()
    {
        cout << "加入牛奶" << endl;
    }
};

// 制作茶叶
class Tea :public AbstractDrinking
{
    virtual void Boil()
    {
        cout << "煮农夫山泉" << endl;
    }
    virtual void Brew()
    {
        cout << "冲泡茶叶" << endl;
    }
    virtual void Pourintocup()
    {
        cout << "倒入杯中" << endl;
    }
    virtual void PutSomething()
    {
        cout << "加入柠檬" << endl;
    }
};

void dowork(AbstractDrinking* abs) // AbstractDrinking* abs = new Coffee
{
    abs->MakeDrink();
}

void test01()
{
    // 制作咖啡
    dowork(new Coffee);
    delete Coffee;
    cout << "--------" << endl;
    // 制作茶叶
    dowork(new Tea);
    delete Tea;
}

5.虚析构和纯虚析构

多态使用时，如果有子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构代码。（子类无法析构）
解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象
都需要具体的函数实现

虚析构和纯虚析构的区别：

如果是纯虚析构，该类属于抽象类，无法实例化对象
纯虚析构，既需要声明，也需要实现

class Animal
{
public:
    Animal()
    {
        cout << "Animal的构造函数调用" << endl;
    }
    // 利用虚析构可以解决 父类指针释放子类对象不干净的问题
    virtual ~Animal()
    {
        cout << "Animal的虚析构函数调用" << endl;
    }
    // 纯虚析构，需要声明，也需要实现
    // 有了纯虚析构，该类也属于抽象类，无法实例化对象
    virtual ~Animal() = 0;
    // 纯虚函数
    virtual void speak() = 0;
};

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

class Cat:public Animal
{
public:
    Cat(string name)
    {
        cout << "Cat的构造函数调用" << endl;
        m_Name = new string(name); // 创建在堆区
    }
    ~Cat()
    {
        if(m_Name != NULL)
        {
            cout << "Cat的析构函数调用" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }
    virtual void speak()
    {
        cout << *m_Name << "小猫在说话" << endl;
    }
    string *m_Name;  // 有子类中有属性开辟到堆区
};

void test01()
{
    Animal *animal = new Cat("TOM"); // 父类指针指向子类对象
    animal->speak();
    // 父类指针在析构时候，不会调用子类中析构函数，导致子类如果有堆区属性，会出现内存泄漏
    delete animal;
}

虚析构或纯虚析构是用来解决父类指针释放子类对象不干净的问题
如果子类中没有堆区数据，可以不写为虚析构或者纯虚析构
拥有纯虚析构函数的类也属于抽象类，不可以实例化对象

6.多态案例三：电脑组装

电脑主要组成部件为CPU，显卡，内存条。

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商。

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口。

测试时组装三台不同的电脑进行工作。

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)
    {
        m_cpu = cpu;
        m_videocard = videocard;
        m_memory = memory;
    }
    ~Computer()
    {
        if(m_cpu != NULL)
        {
            delete m_cpu;
            m_cpu = NULL;
        }
        if(m_videocard != NULL)
        {
            delete m_videocard;
            m_videocard = NULL;
        }
        if(m_memory != NULL)
        {
            delete m_memory;
            m_memory = NULL;
        }
    }
    void work()
    {
        m_cpu->calculate();
        m_videocard->display();
        m_memory->storage();
    }
    CPU* m_cpu;
    VideoCard* m_videocard;
    Memory* m_memory;
};

class IntelCPU:public CPU
{
public:
    virtual void calculate()
    {
        cout << "Inter-CPU计算中" << endl;
    }
};

class IntelVideoCard:public VideoCard
{
public:
    virtual void display()
    {
        cout << "Inter-VideoCard显示中" << endl;
    }
};

class IntelMemory:public Memory
{
public:
    virtual void storage()
    {
        cout << "Inter-Memory储存中" << endl;
    }
};

class LenovoCPU:public CPU
{
public:
    virtual void calculate()
    {
        cout << "Lenovo-CPU计算中" << endl;
    }
};

class LenovoVideoCard:public VideoCard
{
public:
    virtual void display()
    {
        cout << "Lenovo-VideoCard显示中" << endl;
    }
};

class LenovoMemory:public Memory
{
public:
    virtual void storage()
    {
        cout << "Lenovo-Memory储存中" << endl;
    }
};

void test01()
{
    // 第一台电脑零件
    CPU *intelcpu = new IntelCPU;
    VideoCard *intelcard = new IntelVideoCard;
    Memory *intelmemory = new IntelMemory;
    // 第一台电脑
    Computer *computer1 = new Computer(intelcpu, intelcard, intelmemory);
    computer1->work();
    delete computer1;

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

    // 第二台电脑
    Computer *computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
    computer2->work();
    delete computer2;

    cout << "-----------------" << endl;
    
    // 第三台电脑
    Computer *computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);
    computer3->work();
    delete computer3;
}