纯虚函数练习小案例

#pragma once
//头文件 #include"Computer.h"

/*------纯虚函数电脑组装练习案例---------*/

#include<iostream>
using namespace std;
/*---------------------------------------------------*/
class Cpu        //cpu抽象类
{
public:
    virtual void Calculate() = 0;
};

class IntelCpu :public Cpu   //继承抽象Cpu类，进行重写
{
    virtual void Calculate()
    {
        cout << "InterlCpu开始工作了·" << endl;
    }

};
/*----------------------------------------------------*/
class VideoCard   //显卡抽象类
{
public:
    virtual void display() = 0;
};

class IntelVideoCard :public VideoCard   //继承抽象VideoCard类，进行重写
{
public:
    virtual void display()
    {
        cout << "Inteld显卡开始工作" << endl;
    }

};
/*----------------------------------------------------*/
class Memory   //内存条抽象类
{
public:
    virtual void storage() = 0;
};

class IntelMemory :public Memory     //继承抽象类Memory，进行重写
{
public:
    virtual void storage()
    {
        cout << "Intel内存开始工作" << endl;
    }
};

/*------使用三个Lenvo厂商标准，继承三个抽象类，并重写------*/
class LenvoCpu :public Cpu   //继承抽象Cpu类，进行重写
{
    virtual void Calculate()
    {
        cout << "Lenvo Cpu开始工作了·" << endl;
    }

};

class LenvoVideoCard :public VideoCard   //继承抽象VideoCard类，进行重写
{
public:
    virtual void display()
    {
        cout << "Lenvo显卡开始工作" << endl;
    }

};

class LenvolMemory :public Memory     //继承抽象类Memory，进行重写
{
public:
    virtual void storage()
    {
        cout << "Lenvo显卡开始工作" << endl;
    }
};
/*----------------------------------------------------*/
class Computer  //电脑组装类,
{
public:
    //抽象基类作为形参，可以将子类new进来，完成动态绑定
    //相当于Cpu* cpu=new IntelCpu;
    //这样m_cpu就可以调用子类的重写方法
    Computer(Cpu* cpu, VideoCard* card, Memory* memory)
    {
        m_cpu = cpu;
        m_card = card;
        m_memory = memory;
    }
    //下列函数即为抽象父类调用子类的重写函数,传入哪个子类，就调用哪个子类的重写函数
    void work()
    {
        m_cpu->Calculate();
        m_card->display();
        m_memory->storage();

    };


    ~Computer()  //析构电脑组装零件，因为子类对象均使用new传参，则需要释放堆空间
    {
        if (m_cpu != nullptr && m_card != nullptr && m_memory != nullptr)
        {
            delete  m_cpu;
            m_cpu = nullptr;
            cout << "m_cpu被析构" << endl;
            delete  m_card;
            m_card = nullptr;
            cout << "m_card被析构" << endl;
            delete  m_memory;
            m_memory = nullptr;
            cout << "m_memory被析构" << endl;
        }
    }

private:
    Cpu* m_cpu;
    VideoCard* m_card;
    Memory* m_memory;

};

#include"Computer.h"


int main()
{
    //第一台电脑零件
    
    Cpu* Intelcpu = new IntelCpu;
    VideoCard* Intelvideo = new IntelVideoCard;
    Memory* Intelmemory = new IntelMemory;

    //开始组装第一台电脑,将上面三个堆区数据传入写好类中
    cout << "第一台电脑开始工作" << endl;
    
    Computer* computer1 = new Computer(Intelcpu, Intelvideo, Intelmemory);
    computer1->work();
    delete computer1;
    computer1 = nullptr;
    
    //开始组装第二台电脑，也可以直接new堆对象，写入类参数中，两种方法都可以
    //直接在形参中new子类对象，等同于将抽象父类的指针，指向子类.如下.
    // Cpu* Intelcpu = new IntelCpu;
    //VideoCard* video = new IntelVideoCard;
    //Memory* Intelmemory = new IntelMemory;
    cout << "第二台电脑开始工作" << endl;

    //也可以不使用堆对象初始化，与第一台电脑实例化区别.
    Computer computer2 (new LenvoCpu,new LenvoVideoCard,new LenvolMemory);
    computer2.work();
  

    /*纯虚函数小结：
        1-纯虚函数以New的形式，进行动态绑定子类对象，从而可以使用子类的重写方法，
        2-与虚函数的区别在于，（1）纯虚函数只有定义，没有实现；而虚函数既有定义，也有实现的代码。
                             （2）包含纯虚函数的类不能定义其对象，而包含虚函数的则可以。
                              (3) 暂时使用的虚函数，主要用以区分继承类中，函数同名问题，进行动态绑定
                                  而纯虚函数，则使用重写方法，使父类调用子类重写函数。
        3-纯虚析构才可以析构子类中的堆数据。
        4-在以后工程中，使用纯虚函数，则可以在碰到新的新的需求时，添加代码，而不需要去动已经写好的源代码。
    
        注意项:
                1-子类必须重写父类函数，否则会报错。
                2-定义函数时，形参必须是抽象类父类指针，而传参则为某个子类的new对象(动态绑定).
                3-析构时，需要注意堆区内存在哪个函数/类体内。
                3-设计调用函数或类时，有使用指针对象，也可以不使用。
    */
    

    return 0;
}