C++学习笔记——核心篇（九）

前言：本部分内容是讲解多态的相关知识。多态是C++面向对象三大特征之一，也是这三大特征的最后一大特征，但并不意味着，其地位也是高低，在面向对象编程中有着举足轻重的位置，也是必须要掌握的内容。特别是在后期，在学习或使用数据结构与算法时，对数据结构的设计及处理上是十分常见的。

目录

1、多态

            1.1、多态的基本概念

            1.2、纯虚函数和抽象类

            1.3、虚析构和纯虚析构

---

1、多态

            1.1、多态的基本概念

多态分为两类：
        1、静态多态：函数重载 和运算符重载属于静态多态，复用函数名
        2、动态多态；派生类 和 虚函数实现运行时时多态

静态多态 和 动态多态的区别：
        1、静态多态的函数地址为早绑定 - 编译阶段确定函数地址
        2、动态多态的函数地址为晚绑定 - 运行阶段确定函数地址

//动物类
class Animal
{
    public:
        //虚函数
        //speak 函数为虚函数
        //函数前面加上 virtual 关键字，变成虚函数，则编译器在函数调用时就不能确定函数调用了
        virtual void speak()
        {
            cout << "动物在说话！" << endl;
        }
};
                            
//猫类
class Cat:public Animal
{
    public:
        //重写  函数返回值类型  函数名  函数列表  完全相同
        void speak()
        {
            cout << "小猫在说话！" << endl;
        }
};

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

//执行说话的函数
//地址早绑定  在编译阶段确定函数地址
//若想执行让猫说话，则该函数地址就不能提前绑定，需要在运行阶段进行绑定，即地址晚绑定

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

//动态多态的使用条件：父类指针或引用指向子类对象
void DoSpeak(Animal &animal)
{
    animal.speak();
}

void test01()
{
    Cat cat;
    DoSpeak(cat);

    Dog dog;
    DoSpeak(dog);
}

            TIPS：当子类重写父类的虚函数时，子类中的虚函数表 内部 会替换成 子类的虚函数地址
                        vfptr -> 虚函数（表）指针                        vftable -> 虚函数表
                            v -> virtual                                    v -> virtual
                            f -> function                                    f -> function
                            ptr -> pointer                                    table -> table
                        当父类的指针或引用指向子类对象时，发生多态

多态的优点：
        1、代码组织结构清晰
        2、可读性强
        3、利于前期和后期的拓展与维护

                    例子：（计算器实现）

//（计算器实现）---普通方法
//用if  elseif 的方法在同一个类中实现
//如果想拓展新的功能，需要修改源码
//在真实开发中  提倡  开闭原则
//开闭原则：对拓展进行开放，对修改进行关闭

//（计算器实现）---多态  开闭原则
class AbtractCalculator
{
    public:
        virtual int getResult()
        {
            return 0;
        }

        int m_Num1;
        int m_Num2;
};

//加法
class PlusCalculator :public AbtractCalculator
{
    public:
        int getResult()
        {
            return m_Num1 + m_Num2;
        }

};

//减法
class MinCalculator :public AbtractCalculator
{
    public:
        int getResult()
        {
            return m_Num1 - m_Num2;
        }

};

//乘法
class MulCalculator :public AbtractCalculator
{
    public:
        int getResult()
        {
            return m_Num1 * m_Num2;
        }

};
                   
//除法
class ChuCalculator :public AbtractCalculator
{
    public:
        int getResult()
        {
            return m_Num1 / m_Num2;
        }

};

void test01()
{
//多态使用条件
//父类指针或引用指向子类对象

    //加法运算
    AbtractCalculator* abc = new PlusCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;

    //用完后销毁
    delete abc;

    //减法运算
    abc = new MinCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
    delete abc;
                        
    //乘法运算
    abc = new MulCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;
    delete abc;
                        
    //除法运算
    abc = new ChuCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    cout << abc->m_Num1 << "/" << abc->m_Num2 << "=" << abc->getResult() << endl;
    delete abc;
}

                TIPS：C++开发提倡利用多态设计程序架构，因为多态优点多

        1.2、纯虚函数和抽象类

            在多态中，通常父类中的虚函数的实现毫无意义，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数

    纯虚函数的语法：

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

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

            抽象类的特点：
                1、无法实现实例化对象
                2、子类必须重写抽象类中的纯虚函数，否则也属于抽象类

                       例1：

class Base
{
    public:
        virtual void func() = 0;
};

class Son :public Base
{
    void func() 
    {
        cout << "Son 中的 func() 函数" << endl;
    }

};

void test01()
{
    //Base b;     //抽象类无法实现实例化函数
    //new Base;    //抽象类无法实现实例化函数
    Son son;    //子类必须重写父类的纯虚函数，即便是重写为空函数也是重写，否则无法实例化对象
    Base* b = new Son;
    b->func();
}

                    例2：

//制作饮品
class AbstractDrinking
{
    public:
        //煮水
        virtual void Boil() = 0;

        //冲泡
        virtual void Brew() = 0;
        
        //倒入杯中
        virtual void PourInCup() = 0;

        //加入辅料
        virtual void PutSomething() = 0;

        void makeDrink()
        {
            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 doWork(AbstractDrinking * abs)    //AbstractDrinking * abs = new Coffee
{
    abs->makeDrink();
    delete abs;    //释放堆区数据，防止内存泄漏
}

void test01()
{
    //制作咖啡
    doWork(new Coffee);

    cout << "------------------------" << endl;

    //制作茶
    doWork(new Tea);
}

            1.3、虚析构和纯虚析构

                多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时，无法调用到子类的析构代码
                解决方法：将父类中的析构函数改为虚析构或纯虚析构

虚析构和纯虚析构的共性：
        1、可以解决父类指针释放子类对象
        2、都需要有具体的函数实现

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

                虚析构语法：virtual ~类名（）{}
                纯虚析构语法：virtual ~类名（） = 0；
                              父类名::子类名（）{} 

              TIPS：1、纯虚析构需要声明，也需要实现
                          2、利用虚析构可以解决 父类指针释放子类对象时不干净的问题
                          3、如果子类中没有堆区开辟的数据，可以不写虚析构或纯虚析构

                  例子：

//案例：电脑组装具体实现
//CPU类
class AbstractCPU
{
    public:
        virtual void calculate() = 0;
};

//显卡类
class AbstractVideoCard
{
    public:
        virtual void display() = 0;
};

//内存条类
class AbstractMemory
{
    public:
        virtual void storage() = 0;
};

class Computer
{
    public:
        //构造函数中传入三个函数指针
        Computer(AbstractCPU * cpu, AbstractVideoCard *vc, AbstractMemory * m)
        {
            m_CPU = cpu;
            m_VC = vc;
            m_M = m;
        }

        void Work()
        {
            m_CPU->calculate();
            m_VC->display();
            m_M->storage();
        }

        virtual ~Computer()
        {
            if (m_CPU != NULL)
            {
                delete m_CPU;
                m_CPU = NULL;
            }

            if (m_VC != NULL)
            {
                delete m_VC;
                m_VC = NULL;
            }

            if (m_M != NULL)
            {
                delete m_M;
                m_M = NULL;
            }

        }
                    
    private:
        AbstractCPU * m_CPU;
        AbstractVideoCard * m_VC;
        AbstractMemory * m_M;
};


//具体厂商
//Intel 厂商
class IntelCpu :public AbstractCPU
{
    public:
        void calculate()
        {
            cout << "Intel 的CPU开始计算！" << endl;
        }
};

class IntelVideoCard:public AbstractVideoCard
{
    public:
        void display()
        {
            cout << "Intel 的显卡开始显示！" << endl;
        }
};

class IntelMemory :public AbstractMemory
{
    public:
        void storage()
        {
            cout << "Intel 的内存条开始存储！" << endl;
        }
};

//Lenovo 厂商
class LenovoCpu :public AbstractCPU
{
    public:
        void calculate()
        {
            cout << "Lenovo 的CPU开始计算！" << endl;
        }
};

class LenovoVideoCard :public AbstractVideoCard
{
    public:
        void display()
        {
            cout << "Lenovo 的显卡开始显示！" << endl;
        }
};

class LenovoMemory :public AbstractMemory
{
    public:
        void storage()
        {
            cout << "Lenovo 的内存条开始存储！" << endl;
        }
};

void test01()
{
    //第一台电脑：Intel 系列
    cout << "第一台电脑：Intel 系列" << endl;
    Computer * computer1 = new Computer(new IntelCpu, new IntelVideoCard, new IntelMemory);
    computer1->Work();
    delete computer1;
    cout << "-----------------------------------------" << endl;

    //第二台电脑：Lenovo系列
    cout << "第二台电脑：Lenovo系列" << endl;
    Computer * computer2 = new Computer(new LenovoCpu,new LenovoVideoCard,new LenovoMemory);
    computer2->Work();
    delete computer2;
    cout << "-----------------------------------------" << endl;

    //第三台电脑：CPU->Intel ; VD->Lenovo ; M->Intel
    cout << "第三台电脑：CPU->Intel ; VD->Lenovo ; M->Intel" << endl;
    Computer * computer3 = new Computer(new IntelCpu, new LenovoVideoCard, new IntelMemory);
    computer3->Work();
    delete computer3;
}

   尾声：以上是我学习是做的笔记，可供大家参考学习，若有不准确的地方，欢迎指出！