C++（六）——多态

多态

同名函数的几种关系

覆盖（重写）

 1.作用域不同

 2.函数一模一样

3.需要有virtual关键字（基类），派生类可有可无

重载

1.作用域一样

2.函数名一样

3.参数不同

隐藏

 1.作用域不同

2.函数名一样

3.参数一样，基类不能有virtual

 4.参数不一样，基类有没有virtual都是隐藏

虚函数表

 当类里面有虚函数时

 类的对象前八个字节会存储虚函数表的首地址

虚函数表存储对应类的虚函数的地址

虚函数

1.构造函数不能是虚函数

 2.析构函数最好是虚函数

3.纯虚函数（拥有纯虚函数的类叫做抽象类）

验证虚函数表存在的代码

#include <iostream>

using namespace std;

typedef unsigned long   u64;
typedef void (*FUNC)(void);

class Base
{
    public:
    virtual void fun()
    {
        cout<<"func🐼"<<endl;
    }
    private:
        int i ;
};

class Inhirt:public Base
{
    public:
    void fun()
    {
        cout<<"🐼🐼🐼"<<endl;
    }
};
    

int main()
{
    Base *p = new Base;
    
    u64 *q = (u64*)p;//转位8位一个单位的指针
#if 0
    u64 *t = (u64*) *q;//获取指向虚函数的指针，即最开始的8位

    FUNC f = (FUNC) *t;//转换虚函数表第一个的值的类型
    f();
#else
    FUNC f = (FUNC)((u64 *)q[0])[0];
    f();
#endif


    return 0;
}

限制构造

把构造函数写成非public

面向对象编程模式

 经典编程模式一共有23种

 1.单例模式，一个类只能创建唯一一个对象

1.限制构造

 2.static

思路，构造函数作为限制构造，在类的内部写一个函数去调用构造函数（static），有一个指针变量保存创建处理的空间（static变量），

工厂模式

1.规范接口（纯虚函数）， 2.实现多态（虚函数表）3.继承

一、简单工厂模式

 1.产品基类  抽象类

 2.派生具体的产品类   

 3.工厂类

二、工厂方法模式 生产简单产品

1.产品基类  抽象类（产品属性）

 2.派生具体的产品A类  

派生具体的产品B类

 3.工厂类  抽象类      （生产的方式）

 4.具体的工厂类A        

 5.具体的工厂类B

三、抽象工厂模式 生产复杂的产品

工厂方法模式

#include <iostream>

using namespace std;

class Product
{
    public:
        virtual void fun() = 0;
};

class Product_A:public Product
{
    public:
        void fun()
        {
            cout<<"A A A🐼"<<endl;
        }
};

class Product_B:public Product
{
    public:
        void fun()
        {
            cout<<"B B B🐼"<<endl;
        }
};

class Factor:public Product_A,public Product_B
{
    public:
        virtual Product* creat() = 0 ;

};

class Factor_A:public Factor
{
    public:
        Product* creat()
        {
            return new Product_A;
        }
};

class Factor_B:public Factor
{
    public:
        Product* creat()
        {
            return new Product_B;
        }
};


int main()
{

    //创建工厂🐼
    Factor * fa = new Factor_A;
    Factor * fb = new Factor_B;

    //创建物品🐼
    Product * pa = fa->creat();
    Product * pb = fb->creat();

    //展示物品🐼
    pa->fun();
    pb->fun();



    return 0;
}