C++ 多态实例二

 描述:创建一个生成电脑零部件的纯虚函数,让各个厂商品牌去生产这些零部件(也就是具体去实现基类的方法),再通过一个电脑类去实现各个零件的组装,完成一个完整电脑的配置,其中一台电脑的零件可以来自不同厂商。

#include <iostream>


using namespace std;

///抽象类
class Cpu
{
public:
    virtual void calculator() = 0;
};
class VideoCard
{
public:
    virtual void disPlay() = 0;
};
class Memory
{
public:
    virtual void storage() = 0;
};
class Computer
{
    public:
    Computer(Cpu *cpu,VideoCard *vc,Memory *me){
        m_cpu = cpu;
        m_vc =  vc;
        m_me = me;
    }
   virtual ~Computer(){
       cout<<"computer 析构函数"<<endl;
        if(m_cpu != nullptr){
            delete m_cpu;
            m_cpu = nullptr;
        }
        if(m_vc != nullptr){
            delete m_vc;
            m_vc = nullptr;
        }
        if(m_me != nullptr){
            delete m_me;
            m_me = nullptr;
        }
    }

    void doWork();


    private:

    Cpu *m_cpu;
    VideoCard *m_vc;
    Memory *m_me;

};
class InterCpu:public Cpu
{
public:
    virtual void calculator(){
        cout<<"InterCpu 正在执行数据计算"<<endl;
    }
};
class InterVieoCard:public VideoCard
{
public:
     void disPlay()
     {
        cout<<"InterVieoCard 正在显示数据处理"<<endl;
     }
};
class InterMemory:public Memory
{
public:
    virtual void storage()
    {
        cout<<"InterMemory 正在存储数据处理"<<endl;
    }
};
class LenovoCpu:public Cpu
{
    public:
    virtual void calculator()
    {
        cout<<"LenovoCpu 正在执行数据计算"<<endl;
    }
};
class LenovoVieoCard:public VideoCard
{
    public:
    virtual void disPlay()
    {
        cout<<"LenovoVieoCard 正在显示数据处理"<<endl;
    }
};
class LenovoMemory:public Memory
{
    public:
    virtual void storage(){
        cout<<"LenovoMemory 正在存储数据处理"<<endl;
    }
};
void Computer::doWork()
{
    m_cpu->calculator();
    m_vc->disPlay();
    m_me->storage();
}
void test()
{
    //第一台电脑
    cout<<"第一台电脑开始工作"<<endl;
    Cpu *cpu = new InterCpu;
    VideoCard *vc = new InterVieoCard;
    Memory *me = new InterMemory;

    Computer *com1 = new Computer(cpu,vc,me);
    com1->doWork();

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

    //第二台电脑
    cout<<"第二台电脑开始工作"<<endl;
    Computer *com2 = new Computer(new LenovoCpu,new LenovoVieoCard,new LenovoMemory);
    com2->doWork();

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

    cout<<"第三台电脑开始工作"<<endl;
    Computer *com3 = new Computer(new LenovoCpu,new InterVieoCard,new InterMemory);
    com3->doWork();


    delete com1;
    delete com2;
    delete com3;
}
int main()
{
    test();

    return 0;
}



### 回答1: 下面是一个更加完整的C++多态实例,其中定义了一个基类Shape和两个派生类Circle和Rectangle,它们都实现了基类的虚函数area()和draw(),并且在main函数中通过基类指针传入不同的派生类实例并调用它们的虚函数: ```c++ #include <iostream> using namespace std; class Shape { public: virtual double area() = 0; virtual void draw() = 0; }; class Circle : public Shape { private: double radius; public: Circle(double r) { radius = r; } double area() { return 3.14 * radius * radius; } void draw() { cout << "Drawing a circle..." << endl; } }; class Rectangle : public Shape { private: double width, height; public: Rectangle(double w, double h) { width = w; height = h; } double area() { return width * height; } void draw() { cout << "Drawing a rectangle..." << endl; } }; int main() { Shape* pShape; Circle circle(5); Rectangle rectangle(3, 4); pShape = &circle; cout << "Circle area: " << pShape->area() << endl; pShape->draw(); pShape = &rectangle; cout << "Rectangle area: " << pShape->area() << endl; pShape->draw(); return 0; } ``` 输出结果如下: ``` Circle area: 78.5 Drawing a circle... Rectangle area: 12 Drawing a rectangle... ``` 可以看到,在传入不同的派生类实例时,基类指针可以调用对应的派生类虚函数实现,实现了多态的效果。 ### 回答2: 多态是面向对象的一个重要特性,它允许我们通过父类的指针或引用来操作子类的对象。这种多态的使用方式可以提高代码的灵活性和可复用性。 当一个子类对象传入父类指针的实例时,父类指针将指向子类对象的地址。此时,如果通过父类指针来调用虚函数,将会根据对象的实际类型来执行对应的子类方法。这就是多态。 假设有一个Animal类作为父类,有两个子类Dog和Cat继承了Animal类。我们可以创建一个Animal类型的指针,然后将一个Dog或Cat类的对象传入该指针。这样,在后续的代码中,我们可以通过该指针调用Animal类中的方法,编译器会根据实际的子类对象类型来动态决定是调用Dog还是Cat中的方法。 例如,我们可以创建一个Animal指针,然后用Dog类的对象来初始化该指针。然后通过该指针调用Animal类中的虚函数,实际会执行Dog类中的虚函数。 这种多态的使用方式非常有用,可以在编写通用的代码时,将关注点放在父类上,而不需要关心具体的子类类型。这样可以提高代码的可扩展性和可维护性,减少了代码的重复和冗余。 总之,多态实例传入父类指针实例,是实现多态性的一种常见方式。通过父类指针来操作子类对象,可以以父类的角度来处理不同子类的对象,提高代码的灵活性和可复用性。 ### 回答3: 多态是面向对象编程中的一个重要概念,它允许一个对象能够同时具备多个类型,即在不修改代码的情况下,能够通过父类的指针或引用来操作子类的对象。在C++中,可以通过继承和虚函数来实现多态。 当一个子类对象传递给一个父类指针实例时,会发生隐式类型转换,并且只能调用父类中定义的成员函数。这是因为父类指针指向的是子类对象的基类部分,而基类只能访问自己的成员函数和数据成员。这种情况下,如果子类中重写了父类的虚函数,那么在通过父类指针调用该函数时,会根据实际对象的类型来调用相应的函数。 例如,有一个父类Animal和两个子类Dog和Cat。Animal类中有一个虚函数speak(),并且Dog和Cat类分别重写了这个函数。那么当我们通过Animal*指针指向一个Dog对象时,调用speak()函数,会输出“汪汪”,因为实际指向的是Dog类中重写后的函数。同理,如果将Animal*指针指向一个Cat对象,调用speak()函数,会输出“喵喵”。 实例传入父类指针实例可以在很多场景中使用。比如,我们可以定义一个接口类A,然后定义多个实现类B、C、D等,并且它们都继承自A。当我们需要使用这些实现类的时候,可以通过A*指针来传递不同的实例对象,从而实现对于不同实例的统一操作和处理。 总之,多态实例传入父类指针实例可以提高代码的灵活性和可扩展性,使得程序设计更加符合面向对象的思想。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值