多态

多态：静态多态，动态多态

静态多态：函数重载、运算符重载

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

静态多态与动态多态的区别：

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

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

多态满足条件：
有继承关系

子类重写父类的虚函数

多态使用条件：
父类指针或引用指向子类对象

 

#include <iostream>


class Animal{
    public:
    void speak(){
        std::cout<<"动物在说话"<<std::endl;
    }
    virtual void speak1(){
        std::cout<<"动物1在说话"<<std::endl;
    }
};

class Dog:public Animal{
    public:
    void speak(){
        std::cout<<"小狗在说话"<<std::endl;
    };
    void speak1(){
        std::cout<<"小狗1在说话"<<std::endl;
    };
};

class Cat:public Animal{
    public:
    void speak(){
        std::cout<<"小猫在说话"<<std::endl;
    };
     void speak1(){
        std::cout<<"小猫1在说话"<<std::endl;
    };
};

void doSpeak(Animal &animal){
    animal.speak();
    animal.speak1();

}

int main(){
    Dog dog;
    doSpeak(dog);
    Cat cat;
    doSpeak(cat);
    return 0;
}

　　

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

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

虚析构和纯虚析构共性：

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

   都需要有具体的函数实现

虚析构和纯虚析构的区别：
   如果是纯虚析构 ，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名(){}

 

纯虚析构语法：

virtual ~类名（）=0；
类名::~类名(){}

利用虚析构函数可以解决 父类指针释放子类对象时不干净的问题

#include <iostream>

class Animal{
public:
     Animal(){
        std::cout<<"Animal 构造函数"<<std::endl;
     }
     //虚析构函数
     virtual ~Animal(){
        std::cout<<"Animal 析构函数"<<std::endl;
     }
    //纯虚函数
     virtual void speak()=0;
};

class Cat:public Animal{
    public:
    Cat(std::string name){
        m_Name= new std::string(name);
    }
    void speak(){
        std::cout<<"小猫在说话"<<std::endl;
    }
    ~Cat(){
        if (m_Name!=nullptr){
            std::cout<<"Cat 析构函数"<<std::endl;
            delete m_Name;
            m_Name=nullptr;
        }
    }
    std::string *m_Name=nullptr;
};



void doSpeak(Animal &animal){
   animal.speak();
}

int main(){

    //父类指针指向子类对象
    Animal *anmial=new Cat("Tom");
    // 父类指针在析构时候 不会调用子类中析构函数，导致子类如果有堆区数据，释放不干净
    anmial->speak();
    delete anmial;
    anmial=nullptr;
}