1.多态的基本概念

多态是C++面向对象三大特性之一

多态分为两类

1.静态多态：函数重载，运算符重载属于静态多态，复用函数名

2.动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态区别

1.静态多态的函数地址早绑定 ------ 编译阶段确定函数地址

2.动态多态的函数地址未绑定 ------- 运行阶段确定函数地址

动态多态满足条件 1.有继承关系 2.子类重写父类的虚函数

动态多态使用

父类的指针或引用，执行子类对象

重写：函数返回值类型，函数名，参数列表，完全一致称为重写

动态多态和静态多态的代码演示

//动物类class Animal{    public:        //虚函数        virtual void speak(){            cout <<"动物在说话"<<endl;        }};//猫类class Cat :public Animal{    public:        void speak(){            cout <<"小猫在说话"<<endl;        }}; //狗类class Dog :public Animal{    public:        virtual void speak(){            cout <<"小狗在说话"<<endl;        }};//执行说话函数void doSpeak(Animal &animal){//Animal &animal = cat 引用    animal.speak();}void test01(){    Cat cat;    doSpeak(cat);    //输出为 动物在说话，因为地址早绑定，在编译阶段确定函数地址    //如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定。    Dog dog;    doSpeak(dog);//在加上virtual后，输出为  小狗在说话}

案例描述：

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

多态的优点

1.代码组织结构清晰

2.可读性强

3.利用前期和后期的扩展以及维护

普通的实现

//普通写法class Calculator {public :    int getResult(string oper) {        if (oper == "+") {            return m_Num1 + m_Num2;        }        else if (oper == "-") {            return m_Num1 - m_Num2;        }        else if(oper == "*") {            return m_Num1 * m_Num2;        }        //如果想扩展新的功能，需要修改源码        //在真的开发中 提倡  开闭原则        //开闭原则：对扩展进行开发，对修改进行关闭    }    int m_Num1;//操作数1    int m_Num2;//操作数2};void test01() {    //创建计算器对象    Calculator c;    c.m_Num1 = 10;    c.m_Num2 = 10;    cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;    cout << c.m_Num1 << "-" << c.m_Num2 << "=" << c.getResult("-") << endl;    cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getResult("*") << endl;}int main() {    test01();}

多态版本

class AbstractCalcuator {public:    virtual int getResult() {        return 0;    }    int m_Num1;    int m_Num2;};class AddCalculator :public AbstractCalcuator {public:    int getResult() {        return m_Num1+ m_Num2;    }};class SubCalculator :public AbstractCalcuator {public:    int getResult() {        return m_Num1 - m_Num2;    }};class MulCalculator :public AbstractCalcuator {public:    int getResult() {        return m_Num1 * m_Num2;    }};void test02() {    //多态使用条件    //父类指针或者引用指向子类对象    AbstractCalcuator* abc = new AddCalculator;    abc->m_Num1 = 10;    abc->m_Num2 = 10;    cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;    //用完记的销毁    delete abc;}int main() {    test02();}

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

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

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0；

当类中有了纯虚函数，这个类也称为抽象类

抽象类特点：

1.无法实例化对象

2.子类必须重写抽象类中的纯虚函数，否则也属于抽象类

//虚函数和抽象类class Base {public:    //纯虚函数    //只要有一个纯虚函数，这个类称为抽象类    /*    *   抽象类特点        1.无法实例化对象        2.子类必须重写抽象类中的纯虚函数，否则也属于抽象类    */    virtual void func() = 0;};class Son :public Base {    virtual void func() {        cout << "func函数调用" << endl;    }};void test03() {    //Base b;  抽象类是无法实例化对象    //new Base;抽象类是无法实例化对象     //Son s; 子类必须重写抽象类中的纯虚函数，否则也属于抽象类 抽象类无法实例化对象    Base * base = new Son ;    base->func();}int main() {    test03();    system("pause");    return 0;}

案例描述：

制作饮品的大致流程为：煮水 — 冲泡 — 倒入杯中 — 加入辅料

利用多态技术实现案例，提供抽象制作饮品的基类，提供子类制作咖啡和茶叶

//多态的案例二  制作饮品class AbstractDrinking {public:    //煮水    virtual void Boli() = 0;    //冲泡    virtual void Brew() = 0;    //倒入杯子    virtual void PourInCup() = 0;    //加入辅料    virtual void PutSomething() = 0;    //制作饮品     void makeDrink() {         Boli();         Brew();         PourInCup();         PutSomething();    }};//制作咖啡class Coffee :public AbstractDrinking {    //煮水    virtual void Boli() {        cout<<"煮农夫山泉" << endl;    }    //冲泡    virtual void Brew() {        cout << "冲泡咖啡" << endl;    }    //倒入杯子    virtual void PourInCup() {        cout << "倒入杯中" << endl;    }    //加入辅料    virtual void PutSomething() {        cout << "加入糖和牛奶" << endl;    }};class Tea :public AbstractDrinking {    //煮水    virtual void Boli() {        cout << "煮山泉水" << endl;    }    //冲泡    virtual void Brew() {        cout << "冲泡茶叶" << endl;    }    //倒入杯子    virtual void PourInCup() {        cout << "倒入杯中" << endl;    }    //加入辅料    virtual void PutSomething() {        cout << "什么都不加" << endl;    }};//制作饮品函数void doWork(AbstractDrinking *abc) {    abc->makeDrink();    delete abc;}void test01() {    //制作咖啡    //第一种创建和调用    AbstractDrinking * c = new  Coffee;//（new是堆区数据需要释放）    doWork(c);    //第二种创建和调用    //doWork(new Coffee);    //制作茶    doWork(new Tea);}int main() {    test01();    system("pause");    return 0;}

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。

解决方式：将父类中的析构函数改为虚析构或者纯虚析构。

虚析构和纯虚构共性：

1.可以解决父类指针释放子类对象

2.都需要有具体的函数实现

虚析构和纯虚析构区别：

1.如果是纯虚析构，该类属于抽象类，无法实例化对象。

虚析构语法：

virtual ~类名（）{}

纯虚析构语法：

virtual ~类名（）{} = 0；

class Animal {public:    //纯虚函数    virtual void speak() = 0;    Animal() {        cout << "Animal的构造函数调用" << endl;    }    //第一种解决方法    /*利用虚析构可以解决 父类指针释放子类对象时不干净问题    virtual~Animal() {        cout << "Animal的析构函数调用" << endl;    }    */    //第二种解决方法    //纯虚析构，纯虚析构函数需要重写，才可以编译通过。    virtual ~Animal() = 0;};//纯虚析构函数的实现Animal :: ~Animal() {    cout << "Animal的纯虚析构函数调用" << endl;}class Cat :public Animal {public:    string * m_Name;    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;    }};void test01() {    Animal* animal = new Cat("汤姆");    animal->speak();    delete animal;}int main() {    test01();    /*运行结果        Animal的构造函数调用        cat的构造函数调用        汤姆小猫会说话        Animal的析构函数调用        没有走cat的析构函数，m_Name指针指向堆区的数据没有释放，造成数据泄露    出现这种情况的原因：            父类指针在析构时候，不会调用子类中的析构函数，导致子类如果有堆区属性，出现内存泄露    解决方法：            把父类的析构函数 加 virtual 变成虚析构    此时运行结果        Animal的构造函数调用        cat的构造函数调用        汤姆小猫会说话        cat的析构函数调用        Animal的析构函数调用    */    system("pause");    return 0;}