类和对象：多态

多态

1.多态的基本概念
多态分为两类：
静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态

#include <iostream>
//多态
using namespace std;

class animal
{
public:
   virtual void speak()//如果去掉virtual 输出将会不一样
    {
        cout<<"动物在说话"<<endl;
    }
};
//动态多态满足条件
//1.有继承关系
//2.重写父类中的虚函数

//动态多态使用
//父类的指针或引用 指向子类对象
class cat:public animal
{
public:
    void speak()
    {
        cout<<"小猫在说话"<<endl;
    }
};

//执行说话的函数
void dospeak(animal &animal)
{
    animal.speak();
}

void test01()
{
    cat c;
    dospeak(c);
}
int main()
{
    test01();
}

多态案例 --计算器实现

#include <iostream>

using namespace std;
class AbstractCalculator//计算器抽象类
{
public:
    virtual int getresult()
    {
        return 0;
    }
    int m_a;
    int m_b;
};

class JiaFa:public AbstractCalculator//加法
{
public:
    int getresult()
    {
        return m_a+m_b;
    }
};

void test01()
{
//    多态使用条件
//    父类指针或者引用指向子类对象
    AbstractCalculator * abc=new JiaFa;
    abc->m_a=10;
    abc->m_b=60;

    cout<<abc->m_a<<"+"<<abc->m_b<<"="<<abc->getresult()<<endl;
    delete abc;


}
int main()
{
    test01();
}

纯虚函数
在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数的语法：
virtual 返回值类型 函数名(参数列表)=0;

类中有了纯虚函数 这个类也成为抽象类

#include <iostream>
//纯虚函数
using namespace std;

class Base
{
public:
    virtual void func() =0;//纯虚函数
    //有纯虚函数 这个类称为抽象类
//    无法实例化对象
};
//抽象类的子类 必须要重写父类中的纯虚函数 否则也属于抽象类
class son:public Base
{
public:
    void func()//子类必须重写父类中的纯虚函数
    {
        cout<<"子类在运行"<<endl;
    }
};

void test01()
{
//    son s;
//    s.func();

    Base *base=new son;
    base->func();//多态技术来使用
}
int main()
{
    test01();

}

小案例：
制作饮品

#include <iostream>

using namespace std;

class MakeDrink
{
public:

    virtual void MDfunc1()=0;
    virtual void MDfunc2()=0;
    virtual void MDfunc3()=0;
    virtual void MDfunc4()=0;
    void makeDrink1()
    {
        MDfunc1();
        MDfunc2();
        MDfunc3();
        MDfunc4();
    }


};

class MakeCoffe:public MakeDrink
{
public:
    void MDfunc1()
    {
        cout<<"煮水"<<endl;
    }

    void MDfunc2()
    {
        cout<<"冲泡咖啡"<<endl;
    }

    void MDfunc3()
    {
        cout<<"倒入杯中"<<endl;
    }

    void MDfunc4()
    {
     cout<<"加糖和牛奶"<<endl;
    }

};

class MakeTea:public MakeDrink
{
public:
    void MDfunc1()
    {
        cout<<"煮水"<<endl;
    }

    void MDfunc2()
    {
        cout<<"冲泡茶叶"<<endl;
    }

    void MDfunc3()
    {
        cout<<"倒入杯中"<<endl;
    }

    void MDfunc4()
    {
     cout<<"加柠檬"<<endl;
    }

};

void dowork(MakeDrink *abs)
{
    abs->makeDrink1();
    delete abs;
}

void test01()
{
    dowork(new MakeCoffe);
    cout<<"----------"<<endl;
    dowork(new MakeTea);

}
int main()
{
    test01();
}

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

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

class CPU
{
public:

    virtual void caculate()=0;
};

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

class Memory
{
public:
    virtual void storage()=0;
};

class Comptuer
{
public:
    Comptuer(CPU *cpu ,VideoCard *vc ,Memory*mem)
    {
        m_cpu= cpu;
        m_vc= vc;
        m_mem= mem;
    }

    void work()//工作 调用接口
{
    m_cpu->caculate();
    m_vc->display();
    m_mem->storage();
}

private:
    CPU *m_cpu;
    VideoCard *m_vc;
    Memory *m_mem;
};

class IntelCPU:public CPU
{
public:
    virtual void caculate()
    {
        cout<<"Interd的CPU开始计算了！"<<endl;
    }
};

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

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

class LenovoCPU:public CPU
{
public:
    virtual void caculate()
    {
        cout<<"Lenovo的CPU开始计算了！"<<endl;
    }
};

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

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

void test01()
{
    //第一台电脑零件
    CPU *intelcpu=new IntelCPU;
    VideoCard *intelCard=new IntelVideoCard;
    Memory *intelMem=new IntelMemory;

    //创建第一台电脑
    Comptuer *computer1 =new Comptuer(intelcpu,intelCard,intelMem);
    computer1->work();
    delete computer1;

}

int main()
{
    test01();
}