继承——多态

继承

        概念

对一个已经存在的类，去创建一个新的类，称为继承

        现实价值

可实现类中参数的重复使用，减少重复代码

        继承类的称呼

被继承的类称为：父类/基类

继承的类称为：子类/派生类

        语法

class 父类{

}
class 子类: public 父类{

}

        对象初始化

//继承时，需要在子类的构造函数的初始化表中，显性的调用父类的构造函数，来完成成员初始化
构造函数名(int a1, int b1): class(a1, b1);

        派生类中调用基类

类外访问：

        对象名.基类名::变量;

        对象名.基类名::函数名(函数的实参表);

类内访问:

        基类名::变量名;

        基类名::函数名(函数的实参表)；

        继承方式

1.公有继承——public

2.保护继承——protected

3.私有继承——private

哪种继承方式继承父类，子类就为哪种

                比喻：龙生龙，凤生凤

        模型

一般采用pubile继承，不写默认用private继承

子类继承父类的所有成员，但不能访问父类的私有成员，需要父类提供公有函数访问私有成员

当父子类中出现相同的函数时访问也不会出错，因为这两函数不在同一空间内

//类外访问
    对象名.基类名::变量;
    对象名.基类名::函数名(函数的实参表);
//类内访问
    基类名::变量;
    对象名.基类名::函数名(函数的实参表)；

构造/析构

构造函数

        1.父类的构造函数不会被子类继承

        2.需要在子类的构造函数的初始列表中，显性调用父类函数的构造函数，进行对父类的初始化

        3.无子类构造函数父类使用无参函数，不会报错，父类中没有无参构造函数，会报错

        4.先调父类函数的构造函数，再调子类的构造函数

析构函数

        1.父类的析构函数不会被子类继承

        2.不管是否手动调用父类析构函数，父类的析构函数都会被调用

        3.子类的析构函数中无需调用父类析构函数

        4.先调子类函数的析构函数，再调用父类函数的析构函数

调用顺序

        继承中，先父类构造函数，再子类构造函数，析构与构造的顺序相反

多继承

一个子类继承多个父类

        例子：一个寝室中每个人都有几个“爹”

菱形继承

通常不能出现

        例子：近亲结婚（你的爷爷与外公是一个人）

多态

概念

        1.静态多态：函数重载、运算符重载

        2.动态多态：派生类、虚函数实现运行时多态

区别

        静态多态函数，地址早绑定，编译时确定函数地址

        动态多态函数，地址晚绑定，运行时确定函数地址

定义

        基类使用虚函数声明允许子类重写

派生类重写

        使用（ override ）关键字，也可以在重写函数前面加（ virtual ）关键字

        override可增加代码的可读性、安全性，能确保你在重写一个虚函数，如果没有对应的虚函数编译器会报错

条件

        有继承关系

        子类重写父类的虚函数

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

        重写：函数返回值类型、函数名、参数列表完全一致称为重写

总测试

#include <iostream>
using namespace std;
/*************类继承************/
class a
{
public:
    // 虚函数
    // CPU
    virtual void func() = 0;
    // GPU
    virtual void func1() = 0;
    // 内存
    virtual void func2() = 0;
    // 主板
    virtual void func3() = 0;
    // 电源
    virtual void func4() = 0;
};
class b : public a
{
public:
    // 虚函数
    // CPU
    virtual void func()
    {
        cout << "CPU1" << endl;
    }
    // GPU
    virtual void func1()
    {
        cout << "GPU1" << endl;
    }
    // 内存
    virtual void func2()
    {
        cout << "内存1" << endl;
    }
    // 主板
    virtual void func3()
    {
        cout << "主板1" << endl;
    }
    // 电源
    virtual void func4()
    {
        cout << "电源1" << endl;
    }
};
/*************虚构类************/
class zhu
{
public:
    // 虚函数
    // CPU
    virtual void func() = 0;
    // GPU
    virtual void func1() = 0;
    // 内存
    virtual void func2() = 0;
    // 主板
    virtual void func3() = 0;
    // 电源
    virtual void func4() = 0;
};
class fu : public zhu
{
public:
    void func()
    {
        cout << "CPU" << endl;
    }
    void func1()
    {
        cout << "GPU" << endl;
    }
    void func2()
    {
        cout << "内存" << endl;
    }
    void func3()
    {
        cout << "主板" << endl;
    }
    void func4()
    {
        cout << "电源" << endl;
    }
};
/*************派生类重写************/
class zhu1 : public zhu
{
public:
    // 虚函数
    // CPU
    virtual void func()
    {
        cout << "CPU1" << endl;
    }
    // GPU
    virtual void func1()
    {
        cout << "GPU1" << endl;
    }
    // 内存
    virtual void func2()
    {
        cout << "内存1" << endl;
    }
    // 主板
    virtual void func3()
    {
        cout << "主板1" << endl;
    }
    // 电源
    virtual void func4()
    {
        cout << "电源1" << endl;
    }
};

/*************派生类重写************/
class fu1 : public zhu1
{
public:
    void func()
    {
        cout << "CPU2" << endl;
    }
    void func1()
    {
        cout << "GPU2" << endl;
    }
    void func2()
    {
        cout << "内存2" << endl;
    }
    void func3()
    {
        cout << "主板2" << endl;
    }
    void func4()
    {
        cout << "电源2" << endl;
    }
};
/*************虚构类************/
void test(zhu &obj)
{
    cout << "开始测试" << endl;
    // 调用虚构函数
    obj.func();
    obj.func1();
    obj.func2();
    obj.func3();
    obj.func4();
    cout << "测试结束" << endl;
}

int main()
{
    /*************虚构类************/
    cout << endl;
    cout << "虚构类" << endl;
    // 实例化对象
    fu obj;
    // 调用创建的函数
    test(obj);
    /*************派生类重写************/
    cout << endl;
    cout << "派生类重写" << endl;
    // 实例化对象
    fu1 obj1;
    // 调用创建的函数
    test(obj1);
    /*************类继承************/
    cout << endl;
    cout << "类继承" << endl;
    // 实例化对象
    b obj2;
    // 调用创建的函数
    obj2.func();
    obj2.func1();
    obj2.func2();
    obj2.func3();
    obj2.func4();
    return 0;
}