C++笔记打卡第12天（多继承、菱形继承）

1.继承中的构造和析构顺序

先构造父类，再构造子类。先析构子类，再析构父类。

class Base
{
public:
    Base()
    {
        cout << "父类的构造函数" << endl;
    }
    ~Base()
    {
        cout << "父类的析构函数" << endl;
    }
};

class Son:public Base
{
public:
    Son()
    {
        cout << "子类的构造函数" << endl;
    }
    ~Son()
    {
        cout << "子类的析构函数"  << endl;
    }
};

void test01()
{
    Son s;
}

2.继承中同名成员处理方式

问题：当父类与子类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

• 访问子类同名成员，直接访问即可
• 访问父类同名成员，需要加作用域

class Base
{
public:
    Base()
    {
        m_A = 100;
    }
    void func()
    {
        cout << "父类成员函数调用" << endl;
    }
    void func(int a)
    {
        cout << "父类成员函数调用2" << endl;
    }
    int m_A;
};

class Son:public Base
{
public:
    Son()
    {
        m_A = 400;
    }
    void func()
    {
        cout << "子类成员函数调用" << endl;
    }
    int m_A;
};
// 同名成员属性的处理
void test01()
{
    Son s;
    cout << "子类" << s.m_A << endl;
    // 如果通过子类对象 访问到父类中同名成员 需要加一个作用域
    cout << "父类" << s.Base::m_A << endl;
}

// 同名成员函数的处理
void test02()
{
    Son s;
    s.func();  // 直接调用时，调用的是子类中的同名成员函数
    s.Base::func();  // 加作用域就可以调用父类的同名函数

    // s.func(100);  // 错误，如果子类中出现和父类同名的成员函数，那么子类的同名成员会隐藏父类中的所有同名成员函数
    // 如果想访问到父类中被隐藏的成员函数，需要加作用域
    s.Base::func(100);
}

•  子类对象可以直接访问到子类中同名成员
• 子类对象加作用域可以访问到父类同名成员
• 当子类与父类拥有同名的成员函数时，子类会隐藏父类中所有的同名成员函数，要想访问父类中被隐藏的同名成员函数，需要加作用域。

 3.同名静态成员处理

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式与上面一致。

• 静态成员变量的特点：所有对象都共享同一份数据；在编译阶段就分配内存；类内定义，类外初始化。
• 静态成员函数的特点：只能访问静态成员变量；所有对象都共享同一个函数。

 

class Base
{
public:
    static int m_A;
    static void func()
    {
        cout << "父类的静态成员函数" << endl;
    }
    static void func(int a)
    {
        cout << "父类的静态成员函数" << endl;
    }
};
// 静态成员变量类外初始化
int Base::m_A = 100;

class Son:public Base
{
public:
static void func()
    {
        cout << "子类的静态成员函数" << endl;
    }
    static int m_A;
};
int Son::m_A = 200;

void test01()
{
    // 1.通过对象来访问静态成员变量
    Son s;
    cout << s.m_A << endl;
    cout << s.Base::m_A << endl;

    // 2.通过类名访问静态成员变量
    cout << Son::m_A << endl; 
    cout << Son::Base::m_A << endl;  
    // 第一个双冒号表示通过类名方式访问，第二个双冒号表示访问父类作用域下
};

void test02()
{
    // 1.通过对象的方式来访问
    Son s;
    s.func();
    s.Base::func();

    // 2.通过类名的对象来访问
    Son::func();
    Son::Base::func();
    // 当子类中出现与父类同名的静态成员函数时，也会隐藏掉父类中所有同名的静态成员函数
    // 如果想访问父类中被隐藏的同名成员，需要加作用域
    Son::Base::func(100);
}

同名静态成员处理方式和非静态处理方式一样，只不过有两种访问方式（通过对象 和 通过类名）

 4.多继承语法

C++允许一个类继承多个类（一个儿子，多个父亲）。

多继承可能会引发父类中有同名成员出现，需要加作用域区分。

语法：class 子类:public 父类1, public 父类2...

class Base1
{
public:
    Base1()
    {
        m_A = 100;
    }
    int m_A;
};

class Base2
{
public:
    Base2()
    {
        m_A = 200;
    }
    int m_A;
};
// 子类，需要继承Base1和Base2
class Son:public Base1, public Base2
{
public:
    Son()
    {
        m_C = 300;
        m_D = 400;
    }
    int m_C;
    int m_D;
};

void test01()
{
    Son s;
    cout << sizeof(s) << endl;  // 16
    // 当父类中出现同名成员，调用时需要加作用域区分
    cout << s.Base1::m_A << endl;
    cout << s.Base2::m_A << endl;
}

5.菱形继承

概念：

• 两个子类继承同一个父类
• 同时有某个类继承了这两个子类

这种继承方式称为菱形继承，或者钻石继承。

使用菱形继承会造成资源浪费，比如说有两份m_Age（利用虚继承来解决）：

虚继承后：

 vbptr：虚基指针，vbtable:虚基列表

// 动物类
class Animal
{
public:
    int m_Age;
};
// 利用虚继承 可以解除菱形继承的问题
// 在继承之前，加上关键字virtual 变为虚继承
// Animal称为虚基类
// 羊类
class Sheep:virtual public Animal{};
// 驼类
class Tuo:virtual public Animal{};
// 羊驼类
class SheepTuo:public Sheep, public Tuo{};

void test01()
{
    SheepTuo st;
    st.Sheep::m_Age = 18;
    st.Tuo::m_Age = 28;
    // 当菱形继承时，两个父类拥有同名的数据，需要加作用域区分
    cout << "羊" << st.Sheep::m_Age << endl;
    cout << "驼" << st.Tuo::m_Age << endl;
    // 但这份数据我们知道只要有一份就可以，可是菱形继承会导致数据有两份，造成资源浪费
    cout << st.m_Age << endl;
}

6.多态的基本概念

多态分为两类：

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

静态多态和动态多态的区别：

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

动态多态满足条件：

• 有继承关系
• 子类要重写父类的虚函数（重写：函数返回值类型 函数名 参数列表 完全相同）

动态多态使用：父类的指针或者引用，指向子类对象，如Animal &animal = cat;

class Animal
{
public:
    // 虚函数
    virtual void speak()
    {
        cout << "动物在说话" << endl;
    }
};

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

// 地址早绑定：在编译阶段就确定了函数地址
// 如果想执行让猫说话，那么这个函数的地址就不能提前绑定，需要在运行阶段进行绑定，也称为地址晚绑定
// 使用virutal关键字实现虚函数，就可以输出小猫在说话
void dospeak(Animal &animal)  // Animal &animal = cat;
{
    animal.speak();  // 不加virtual永远都会是动物在说话
}

void test01()
{
    Cat cat;
    dospeak(cat);
}