当前位置：首页 > article >正文

【第六天】c++虚函数多态

article 2024/11/28 6:40:00

一、多态的概述

多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联（父类与子类）时，就会用到多态。

C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

静态多态（编译时多态，早绑定）：函数重载、运算符重载

动态多态（运行时多态，晚绑定）：虚函数

二、虚函数

1、知识点引入

需求：设计一个算法可以操作父类派生的所有子类

算法通用：父类指针（引用）保存子类空间地址

父类指针保存子类空间地址带来的问题：

原因:

解决：通过虚函数

2、虚函数的定义

定义及用法：父类成员函数前加virtual修饰，该函数即为虚函数

子类重写父类虚函数：函数名、返回值类型、参数类型个数顺序完全一致。

动态多态条件：有继承、子类重写(覆盖)父类的虚函数，父类指针指向子类空间。

3、虚函数原理

如果一个类中的成员函数被virtual修饰，那么这个函数就是虚函数。类就会产生一个虚函数指针（vfptr）指向了一张虚函数表（vftable）。

如果这个类没有涉及到继承，这时虚函数表中纪录及时当前类的虚函数入口地址。

Animal的类的结构：

一旦子类重写父类虚函数，就会将子类的虚函数肉蔻地址，覆盖虚函数表中原来的入口地址。

Dog的类存结构：

三、纯虚函数和抽象类

在设计时，常常希望基类仅仅作为其派生类的一个接口。并且不希望用户实际的创建一个基类的对象。所以创建一个纯虚函数允许接口中放置成员原函数，而不一定要提供一段可能对这个函数毫无意义的代码。

一个纯虚函数(pure virtual function),使得基类称为抽象类(abstract class)，抽象类必须被继承同时子类必须重写父类的所有纯虚函数，否则子类也是抽象类。纯虚函数使用关键字virtual并在其后面加上=0。抽象类不能实例化对象，如果试图去实例化一个抽象类，编译器则会阻止这种操作。

虚函数不实现函数体：

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

抽象类主要的目的是设计类的接口：

#include <iostream>
using namespace std;
//抽象制作饮品
class AbstractDrinking{
public:
    //烧水
    virtual void Boil() = 0;
    //冲泡
    virtual void Brew() = 0;
    //倒入杯中
    virtual void PourInCup() = 0;
    //加入辅料
    virtual void PutSomething() = 0;
    //规定流程
    void MakeDrink(){
    this‐>Boil();
    Brew();
    PourInCup();
    PutSomething();
    }
};

//制作咖啡
class Coffee : public AbstractDrinking{
public:
    //烧水
    virtual void Boil(){
        cout << "煮农夫山泉!" << endl;
    }
    //冲泡
    virtual void Brew(){
        cout << "冲泡咖啡!" << endl;
    }
    //倒入杯中
    virtual void PourInCup(){
        cout << "将咖啡倒入杯中!" << endl;
    }
    //加入辅料
    virtual void PutSomething(){
        cout << "加入牛奶!" << endl;
    }
};

//制作茶水
class Tea : public AbstractDrinking{
public:
    //烧水
    virtual void Boil(){
        cout << "煮自来水!" << endl;
}
    //冲泡
    virtual void Brew(){
        cout << "冲泡茶叶!" << endl;
    }
    //倒入杯中
    virtual void PourInCup(){
        cout << "将茶水倒入杯中!" << endl;
    }
    //加入辅料
    virtual void PutSomething(){
        cout << "加入食盐!" << endl;
    }
};

    //业务函数
void DoBussiness(AbstractDrinking* drink){
    drink‐>MakeDrink();
    delete drink;
}

int main(int argc, char *argv[])
{
    DoBussiness(new Coffee);//new Coffee 是在堆上分配内存创建一个 Coffee 对象，然后将该对象的指针传递给 DoBussiness 函数进行处理。
    cout << "‐‐‐‐‐‐‐‐‐‐‐‐‐‐" << endl;
    DoBussiness(new Tea);

    return 0
}

虚函数和纯虚函数的区别：

虚函数：virtual修饰有函数体不会导致父类为抽象类。

纯虚函数：virtual修饰，=0，没有函数体导致父类为抽象类。子类必须重写父类的所有纯虚函数。

四、虚析构函数

构造的顺序：父类--->成员---->子类

析构的顺序：子类--->成员---->父类

虚析构：通过父类指针释放整个子类空间。

原理：

五、纯虚析构

纯虚析构的本质是析构函数，负责释放各类的空间。而且析构函数不能被继承。故必须为纯虚析构函数提供一个函数体，纯虚析构函数必须在类外实现。

#pragma warning(disable:4996)
#include<iostream>
#include<string.h>
using namespace std;
class Animal
{
public:
    //纯虚函数
    virtual void speak(void)=0;
    //纯虚析构
    //纯虚析构函数 必须在类外实现
    virtual ~Animal()=0;
};
class Dog:public Animal
{
public:
    //子类重写父类的虚函数，本质仍是虚函数，此时关键字virtual可省
    void speak(void)
    {
        cout << "狗在汪汪" << endl;
    }
    ~Dog()
    {
        cout<<"Dog析构函数"<<endl;
    }
};
void test()
{
    Animal* p = new Dog;
    p->speak();
    delete p;

}
int main(int argc, char* argv[])
{
    test();
    return 0;
}
//纯虚析构函数 必须在类外实现
Animal::~Animal()
{
    cout<<"Animal析构函数"<<endl;
}

虚析构和纯虚析构的区别：

虚析构：virtual修饰，有函数体，不会导致父类为抽象类。

纯虚析构：virtual修饰，=0，函数体必须类外实现，导致父类为抽象类。

六、多态的常见问题

1、多态的分类

2、谈谈你对动态捆绑机制的理解（虚函数实现原理）

3、重载、重定义、重写的区别

4、虚函数和纯虚函数的区别

5、虚析构和纯虚析构的区别

6、虚函数的作用

7、虚析构的作用

八、重载、重定义、重写的区别

        重载：同一作用域，同名函数，参数的顺序、个数、类型不同都可以重载。函数的返回值类型不能作为重载条件（例：函数重载、运算符重载）

        重定义：有继承，子类重定义父类的同名函数（非虚函数），参数顺序、个数、类型可以不同。子类的同名函数会屏蔽父类的所有同名函数（可以通过作用域解决）

        重写（覆盖）：有继承，子类重写父类的虚函数。返回值类型、函数名、参数顺序、个数、类型都必须一致。

查看全文

http://www.kler.cn/a/230158.html