多态实际应用

点餐

利用多态的实现方便维护，实现了低耦合的特点

#include<iostream>
using namespace std;
//抽象类
class drink
{
public:    
    virtual void suger()
    {
        return ;
    }
    virtual void boil()
    {
        return ;
    }
    virtual void type()
    {
        return ;
    }
    virtual void coldorhot()
    {
        return ;
    }
    void allfeature()
    {
        suger();
        boil();
        type();
        coldorhot();
        return ;
    }
};
//继承抽象类，实现具体的虚函数实现覆盖
class coffee:public drink
{
public:
    virtual void suger()
    {
        cout<<"少糖"<<endl;
        return ;
    }
    virtual void boil()
    {
        cout<<"加入咖啡豆蒸煮"<<endl;
        return ;
    }
    virtual void type()
    {
        cout<<"用咖啡杯装"<<endl;
        return ;
    }
    virtual void coldorhot()
    {
        cout<<"冰咖啡"<<endl;
        return ;
    }
};
class tee:public drink
{
public:
  virtual void suger()
    {
        cout<<"茶多放糖"<<endl;
        return ;
    }
    virtual void boil()
    {
        cout<<"加入茉莉花茶蒸煮"<<endl;
        return ;
    }
    virtual void type()
    {
        cout<<"用茶杯装水"<<endl;
        return ;
    }
    virtual void coldorhot()
    {
        cout<<"一杯热茶"<<endl;
        return ;
    }  
};
//多态的实现
void A_drink(drink& some)
{
    some.allfeature();
    return;
}
int main()
{
    //创建父类指针指向子类对象或者父类引用绑定子类对象实现多态
    coffee a;
    cout<<"先生你的咖啡好了"<<endl;
    A_drink(a);
    tee b;
    cout<<"------------"<<endl;
    cout<<"先生你的茶好了"<<endl;
    A_drink(b);
    return 0;
}

多态的实现主要是
1.父类的指针指向子类对象

drink *a=new coffee()//需要手动释放内存
drink *b;
coffee c;
b=&c;
2.父类的引用与子类绑定
比较常见的是通过 函数来实现 引用与子类对象的绑定
void A_drink(drinl& coffee)
{
}
coffee a;
drink(a);//实际上是drink& coffee = a;

用new在堆区创建的内存要手动释放

• 用delete释放父类指针时，无法释放子类的对象，因此要采用虚析构函数的方式来释放子类函数
• 在构造子类函数的时候是先创建父类对象后创建子类对象
• 调用delete的时候默认调用析构函数
• 用虚析构函数可以做到先释放子类函数后释放父类函数

#include<iostream>
using namespace std;
//抽象类
class drink
{
public:    
    virtual void suger()
    {
        return ;
    }
    virtual void boil()
    {
        return ;
    }
    virtual void type()
    {
        return ;
    }
    virtual void coldorhot()
    {
        return ;
    }
    void allfeature()
    {
        suger();
        boil();
        type();
        coldorhot();
        return ;
    }
    //父类对象的构造函数
     drink()
    {
      cout<<"这是父类drink的构造器"<<endl;
    }
   //虚析构函数，在释放父类对象的时候子类对象无法释放，可以通过这种方法实现成功释放
    virtual ~drink()
    {
     cout<<"这是父类drink析构函数"<<endl;
    }
};
//继承抽象类，实现具体的虚函数实现覆盖
class coffee:public drink
{
public:
    virtual void suger()
    {
        cout<<"少糖"<<endl;
        return ;
    }
    virtual void boil()
    {
        cout<<"加入咖啡豆蒸煮"<<endl;
        return ;
    }
    virtual void type()
    {
        cout<<"用咖啡杯装"<<endl;
        return ;
    }
    virtual void coldorhot()
    {
        cout<<"冰咖啡"<<endl;
        return ;
    }
    coffee()
    {
        cout<<"这是coffee的构造函数"<<endl;
    }
    ~coffee()
    {
        cout<<"这是coffee的析构函数"<<endl;
    }
};
class tea:public drink
{
public:
  virtual void suger()
    {
        cout<<"茶多放糖"<<endl;
        return ;
    }
    virtual void boil()
    {
        cout<<"加入茉莉花茶蒸煮"<<endl;
        return ;
    }
    virtual void type()
    {
        cout<<"用茶杯装水"<<endl;
        return ;
    }
    virtual void coldorhot()
    {
        cout<<"一杯热茶"<<endl;
        return ;
    }  
    tea()
    {
        cout<<"这是tea的构造函数"<<endl;
    }
    ~tea()
    {
        cout<<"这是tea的析构函数"<<endl;
    }
};
//多态的实现
void text1()
{
    //堆区创建的内存需要程序员显示释放
    //创建子类对象的过程是先建立父类对象再生成子类对象
    drink* a =new coffee();
    a->allfeature();
    delete a;
}
int main()
{
    text1();
    return 0;
}

结果对比：
分别为加virtual与不加virtual