C++从入门到精通 (7) (多态) 连载！！！-CSDN博客

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

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

void dospeak(Animal& animal)    //提前写好了
{
    animal.speak();
}
void test_01()
{
    Cat c;            //这是一个静态多态 地址早绑定
    dospeak(c);        //动物在说话
}

如果以上程序想要调用小猫在说话这个时候 函数的地址就不能早绑定（动态联编）

虚函数

动态多态在运行阶段绑定地址，地址晚绑定，动态联编

class Animal
{
public:
    //虚函数
    virtual void speak()
    {
        cout<<"动物在说话"<<endl;
    }
};

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

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

  //传参多态
  //父类指向子类空间的方式 是传参的形式实现的
void dospeak(Animal& animal)    
{
    animal.speak();
}
void test_01()
{
    Cat c;            
    dospeak(c);        //小猫在说话
    Dog d;
    dospeak(d);        //小狗在说话
}

纯虚函数(重点)

在多态的应用中子类调用父类重写的函数那么父类的虚函数被覆盖了父类必须有该虚函数

但是具体实现是浪费的此时我们可以将父类的虚函数写成纯虚函数只作为模板告诉子类必须要重写虚函数

注意:父类如果有纯虚函数该父类一定是抽象类抽象类不能实例化只能用于多态应用(父类指针指向子类空间)

父类的纯虚函数子类必须全部重写否则子类也会变成抽象类

class Animal
{
public:
    virtual void func() = 0;    //纯虚函数格式
};

class Dog:public Animal
{
public:
    void func()
    {
        cout<<"小狗正在叫"<<endl;
    }
};

class Cat:public Animal
{
public:
    void func()
    {
        cout<<"小猫正在叫"<<endl;
    }
};

void barking(Animal *a)
{
    a->func();
}

void test_01()
{
    //Animal a;  //error  抽象类不能实例化
    barking(new Dog);   //小狗正在叫
    barking(new Cat);   //小猫正在叫
}

练习:饮品制作

制作饮品为抽象类功能有煮茶冲泡倒入加佐料具体实现由两个子类完成为冲咖啡和冲茶叶

class driak
{
public:
    virtual void heat() = 0;    //煮水
    virtual void brew() = 0;    //冲泡
    virtual void pour() = 0;    //倒入
    virtual void ingredients() = 0;     //辅料
};


class tea:public driak
{
public:
    void heat()
    {
        cout<<"煮水"<<endl;
    }
    void brew()
    {
        cout<<"冲泡茶叶"<<endl;
    }
    void pour()
    {
        cout<<"倒入杯中"<<endl;
    }


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


class coffee:public driak
{
public:
    void heat()
    {
        cout<<"煮水"<<endl;
    }
    void brew()
    {
        cout<<"冲泡咖啡"<<endl;
    }
    void pour()
    {
        cout<<"倒入杯中"<<endl;
    }


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


void make(driak *d)
{
    d->heat();
    d->brew();
    d->pour();
    d->ingredients();
}


void test_01()
{
    cout<<"----茶----"<<endl;
    make(new tea);
    cout<<"----咖啡----"<<endl;
    make(new coffee);
}

纯虚函数和多继承(了解)

绝大多少面向对象语言都不支持多继承但是绝大多数面向对象的语言都支持接口概念

c++没有接口概念但是可以通过纯虚函数来实现接口

虚析构函数

虚析构应用(重点)

在多态的应用中如果需要释放资源时需要使用到虚析构函数

也就是由虚构函数的地方就一定要写虚析构否则会造成内存泄漏

虚函数的目的:释放子类的析构函数

class Animal
{
public:
    Animal()
    {
        cout<<"Animal构造函数"<<endl;
    }
    virtual ~Animal()
    {
        cout<<"Animal析构函数"<<endl;
    }
    virtual void func()
    {
        cout<<"动物正在叫"<<endl;
    }
};

class Dog:public Animal
{
public:
    Dog()
    {
        cout<<"Dog构造函数"<<endl;
    }
    ~Dog()
    {
        cout<<"Dog析构函数"<<endl;
    }


    void func()
    {
        cout<<"小狗正在叫"<<endl;
    }
};

class Cat:public Animal
{
public:
    Cat()
    {
        cout<<"Cat构造函数"<<endl;
    }
    ~Cat()
    {
        cout<<"Cat析构函数"<<endl;
    }

    void func()
    {
        cout<<"小猫正在叫"<<endl;
    }
};

void barking(Animal *a)
{
    a->func();
    delete a;
}

void test_01()
{
    //Animal a;  //error  抽象类不能实例化
    barking(new Dog);   //小狗正在叫
    barking(new Cat);   //小猫正在叫
}

纯虚析构

在虚析构的基础上将虚虚构的函数去掉具体实现类外完成

具体场景和虚析构是一样的都是用于释放子类的析构函数

纯虚析构所在的类一定是抽象类

class Animal
{
public:
    Animal()
    {
        cout<<"Animal构造函数"<<endl;
    }
    virtual ~Animal() = 0;
    virtual void func()
    {
        cout<<"动物正在叫"<<endl;
    }
};

Animal::~Animal()   //类外实现
{
    cout<<"Animal析构函数"<<endl;
}

class Dog:public Animal
{
public:
    Dog()
    {
        cout<<"Dog构造函数"<<endl;
    }
    ~Dog()
    {
        cout<<"Dog析构函数"<<endl;
    }

    void func()
    {
        cout<<"小狗正在叫"<<endl;
    }
};

class Cat:public Animal
{
public:
    Cat()
    {
        cout<<"Cat构造函数"<<endl;
    }
    ~Cat()
    {
        cout<<"Cat析构函数"<<endl;
    }


    void func()
    {
        cout<<"小猫正在叫"<<endl;
    }
};

void barking(Animal *a)
{
    a->func();
    delete a;
}

void test_01()
{
    //Animal a;  //error  抽象类不能实例化
    barking(new Dog);   //小狗正在叫
    barking(new Cat);   //小猫正在叫
}