C++多态

1、多态的基本概念

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

多态分为两类

• 静态多态：函数重载和运算符重载属于静态多态，复用函数名
• 动态多态：派生类和虚函数实现运行时多态

静多态和动多态的区别:

• 静态多态的函数地址早绑定—编译阶段确定函数地址
• 动态多态的函数地址晚绑定—运行阶段确定函数地址

动态多态满足条件

1. 有继承关系
2. 子类重写父类的虚函数

动态多态的使用

父类的指针或者引用 指向子类对象

指针：

（new什么对象下一行就执行该对象里的对应函数）

引用：

多态的优点

• 代码组织结构清晰
• 可读性强
• 利于前期和后期的扩展和维护

虚函数

在函数前加virtual关键字，函数变成虚函数，那么编译器在编译的时候就不能确定函数调用了（在编译时就不能绑定地址）

函数重写

返回值类型、函数名、参数列表完全相同

案例：

问题：

//由于传入对象不同，要多种形态调用公共接口
#include <iostream>
using namespace std;
//动物类
class Animal{
public:
    void speak()
    {
        cout<<"动物在说话 "<<endl;
    }
};

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

//执行说话的函数
//地址早绑定 在编译阶段确定函数地址
void doSpeak(Animal &animal)
//父类的引用指向子类对象
//c++中允许父子之间的类型转换
//Animal & animal=cat;
{
    animal.speak();
    //问题：执行的是Animal中的speak函数还是cat中的speak说话
    //执行Animal中的speak函数
    //因为地址早绑定 在编译阶段确定函数地址
}
void test01()
{
    Cat cat;
    doSpeak(cat);
    
}
int main(){


    system("pause")
    teturn 0;
}

执行的speak函数是Animal中的speak函数

因为地址早绑定 在编译阶段确定函数地址

如果想让cat执行Cat中的speak函数，那么这个函数地址就不能提前绑定，需要在运行阶段绑定，地址晚绑定

方法：

在Animal的speak函数前加上virtual关键字

加上关键字后cat执行cat中的speak，dog执行dog中的speak，实现动态多态

2、多态的原理剖析

用sizeof来查看Animal类只占一个字节，因为只有非静态成员函数属于类的对象上，所以speak这个非静态成员函数不属于Animal这个类的对象上，相当于一个空类，占用一个字节

但是将speak函数加上virtual关键字变成动态多态之后Animal这个类占四个字节，因为类内多了一个指针，虚函数（表）指针（vfptr）

该指针指向vftable（虚函数表，记录虚函数地址）

如果子类中不重写函数，那么只是执行了简单的继承，子类也会将父类中的vfptr指针继承下来并且指向父类的虚函数列表

如果发生了重写，子类中的虚函数内部会替换成子类的虚函数地址（从父类中继承下来的，且父类中的虚函数表）

当父类的指针或者引用指向子类对象时(Animal &animal = cat;)，执行spaek函数，会执行cat中的speak函数，发生多态

案例1：

计算器类

普通实现：

如果要提供新的运算，需要修改源码

多态实现：

• 代码组织结构清晰
• 可读性强
• 利于前期和后期的扩展和维护

#include <iostream>
using namespace std;
#include <string>

//实现计算器类抽象
class AbstactCaluculator
{
public:
    virtual int getResult()//1、父类中的函数写为虚函数
    {
        return 0;
    }
    int m_Num1;
    int m_Num2;
};

//加法计算器
//2、继承抽象计算器类
class AddCaculator ：public AbstractCalculat
{
public:
    int getResult()
    {
        return m_Num1+m_Num2;
    }
}；

//减法计算器（继承抽象计算器类）
class subCaculator ：public AbstractCalculat
{
public:
    int getResult()
    {
        return m_Num1-m_Num2;
    }
}；


void test02(
{
//加法运算
//父类指针或者引用指向子类对象
AbstractCalculator * abc=new AddCalculator；//堆区创建内存
abc->m_Num1=10;
abc->m_Num2=10;

cout<<abc->m_Num1<<"+"<<abc->m_Num2<<"="<<abc->getResult()<<endl;
delete abc；//用完后记得释放堆区内存

    //减法运算
    abc=new subCalculator；
    abc->m_Num1=10;
    abc->m_Num2=10;

cout<<abc->m_Num1<<"-"<<abc->m_Num2<<"="<<abc->getResult()<<endl;
}

int main(){
    test02();
    system("pause");
    return 0;
}

3、纯虚函数和抽象类函数

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

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

纯虚函数语法：

virtual 返回值类型 函数名 （参数列表）=0；

抽象类

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

抽象类特点：

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

示例：

1、无论在栈区还是堆区实例化对象都会报错

2、子类中没有重写函数func，子类也属于抽象类，无法创建对象，编译器报错

（son因没有重写父类中的纯虚函数，也属于抽象函数，无法实例化出对象s）

4、虚析构和纯虚析构

语法：

虚析构：

virtual ~类名（）{}；

纯虚析构：

virtual ~类名（）=0；

类名：：类名（）{}；

问题：

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

（父类的指针或引用指向子类对象，但是父类指针无法释放子类对象）

（在释放父类时并没有执行子类的析构函数）

解决：

将父类中的析构函数改为虚析构或纯虚析构

虚析构解决：

纯虚析构解决：

将父类中的析构函数改为纯虚析构函数

但是编译器报错，因为该函数没有具体实现

（如果父类中开辟了数据到堆区，则需要使用父类中的析构函数）

解决：

在内声明，类外写出析构函数的具体实现

注意：

1. 纯虚析构需要声明也需要实现
2. 含有纯虚析构的类也属于抽象类，无法实例化对象
3. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
4. 都需要有具体函数实现

虚析构和纯虚析构共性：

• 可以解决父类指针释放子类对象
• 都需要有具体函数实现

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

如果是纯虚析构，该类属于抽象类，无法实例化对象（纯虚函数也无法实例化对象）

案例：电脑组装

#include <iostream>
using namespace std;

//抽象不同零件的类
//抽象cpu类
class CPU
{
public:
    //抽象的计算函数
    virtual void caculate()=0;
};

//抽象的显卡类
class VideoCard
{
public:
    //抽象的显示函数
    virtual void display()=0;
};

//抽象的内存条类
class Memory
{
public:
    //抽象的存储函数
    virtual void storage()=0;
};

//电脑类
class Computer
{
public:
    Computer(CPU *cpu,VideoCard *vc,Memory *mem)
    {
        //将三个指针进行接收
        m_cpu=cpu;
        m_vc=vc;
        m_mem=mem;
    }

//提供工作函数
voide work()
{
    //让零件工作起来，调用接口（父类指针调用接口，根据传入不同的子类实现不同的函数，多态）
    m_cpu->caculate();

    m_vc->display();

    m_mem->storage();
}

//析构函数 释放三个电脑零件
~Computer()
{
    if(m_cpu!=NULL){
        delete m_cpu;
        m_cpu=NULL;
    }
    
     if(m_vc!=NULL){
        delete m_vc;
        m_vc=NULL;
    }
    
    if(m_mem!=NULL){
        delete m_mem;
        m_mem=NULL;
    }
}

private:
    //父类指针
    CPU *m_cpu;//CPU零件指针
    VideoCard *m_vc;//显卡零件指针
    Memory *m_mem;//内存条指针
};



//具体厂商

//Intel厂商
//CPU类的子类
class IntelCPU：public CPU
{
public:
    virtual void caculate()
    {
        cout<<"interl的CPU开始计算了"<<endl;
    }
};

//显卡
class IntelVideoCard：public VideoCard
{
public:
    virtual void display()
    {
        cout<<"interl的显卡开始显示了"<<endl;
    }
};

//interl的内存条
class IntelMemory：public Memory
{
public:
    virtual void storage()
    {
        cout<<"interl的内存条开始储存了"<<endl;
    }
};

//Lenovo厂商
//CPU类的子类
class LenovoCPU：public CPU
{
public:
    virtual void caculate()
    {
        cout<<"Lenovo的CPU开始计算了"<<endl;
    }
};

//显卡
class LenovoVideoCard：public VideoCard
{
public:
    virtual void display()
    {
        cout<<"Lenovo的显卡开始显示了"<<endl;
    }
};

//interl的内存条
class LenovoMemory：public Memory
{
public:
    virtual void storage()
    {
        cout<<"Lenovo的内存条开始储存了"<<endl;
    }
};

void test01()
{
    //组装不同的电脑
   
    //第一台电脑零件
    //父类指针指向子类对象（多态）
     CPU *intelCpu=new IntelCPU;
    VideoCard *interlCard=new IntelVideoCard;
    Memory *interlMem=new IntelMemory;

    //创建第一台电脑
    Computer *computer1 = new Computer(intelCpu,interlCard,interlMem)
    computer1->work();
    delete computer1;
    //需要将父类中的析构函数写成虚析构函数或者纯虚析构函数
    //因为这三个零件指针是在Computer类中进行维护的
    //否则父类对象在释放时不会将子类对象（电脑零件）释放
}

int main(){
    test01();
    system("pause");
    return 0;
}