C++黑马程序员——P131-134. 继承 同名(静态)成员处理，多继承，菱形继承，虚继承

• P131. 类和对象——继承——同名成员处理
• P132. 类和对象——继承——同名静态成员处理
• P133. 类和对象——继承——继承语法
• P134. 类和对象——继承——菱形继承问题以及解决方法
• P131. 同名成员处理

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

● 访问子类同名成员 直接访问即可

● 访问父类同名成员 需要加作用域

//继承中同名成员处理
class Base
{
public:
    Base()
    {
        m_A = 100;
    }

    void func()
    {
        cout << "Base 的func() 函数调用" << endl;
    }

    void func(int a)
    {
        cout << "Base 的func(int a) 函数调用" << endl;
    }
    int m_A;
};

class Son :public Base
{
public:
    Son()
    {
        m_A = 200;
    }

    void func()
    {
        cout << "Son 的func() 函数调用" << endl;
    }
    int m_A;
};

void test01()
{
    Son s1;
    cout << "s1.m_A = " << s1.m_A << endl;    //200
    //如果通过子类对象访问父类同名成员，需要加作用域
    cout << "Base 下m_A = " << s1.Base::m_A << endl;
}

//同名成员函数处理方式
void test02()
{
    Son s2;
    s2.func();
    s2.Base::func();
    //如果子类出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
    //如果想访问到父类中被隐藏的同名成员函数，需要加作用域
    s2.Base::func(10);    //这一行，如果不加 Base:: 就会报错
}

int main()
{
    test01();
    test02();
    return 0;
}

运行结果：

　　

 

• P132. 同名静态成员处理

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

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

● 访问子类同名成员 直接访问即可

● 访问父类同名成员 需要加作用域

//继承中同名静态成员的处理方式
class Base
{
public:
    static void func()
    {
        cout << "Base的static void func()调用" << endl;
    }
    static void func(int a)
    {
        cout << "Base的static void func(int a)调用" << endl;
    }
    static int m_A;
};
int Base::m_A = 100;

class Son:public Base
{
public:
    static void func()
    {
        cout << "Son的static void func()调用" << endl;
    }
    static int m_A;
};
int Son::m_A = 200;

//同名静态成员属性
void test01()
{
    //1. 通过对象访问
    cout << "通过对象访问：" << endl;
    Son s1;
    cout << "s1.m_A = " << s1.m_A << endl;
    cout << "s1.Base::m_A = " << s1.Base::m_A << endl;
    //2. 通过类名访问
    cout << "通过类名访问：" << endl;
    cout << "Son::m_A = " << Son::m_A << endl;
    cout << "Son::Base::m_A = " << Son::Base::m_A << endl;    //第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
}
//同名静态成员函数
void test02()
{
    //1. 通过对象访问
    cout << "通过对象访问：" << endl;
    Son s2;
    s2.func();
    s2.Base::func();
    //2. 通过类名访问
    cout << "通过类名访问：" << endl;
    Son::func();
    Son::Base::func();
    //子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
    //如果想访问父类中被隐藏的同名成员，需要加作用域
    Son::Base::func(100);    //不加 Base:: 会报错
}


int main()
{
    test01();
    cout << endl;
    test02();
    return 0;
}

运行结果：

　　

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

 

• P133. 继承语法

多继承语法

C++允许一个类继承多个类

语法：class 子类：继承方式 父类1，继承方式 父类2...

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

C++实际开发中不建议用多继承

//多继承语法
class Base1
{
public:
    Base1()
    {
        m_A = 1;
    }
    int m_A;
};

class Base2
{
public:
    Base2()
    {
        m_A = 2;
    }
    int m_A;
};

//子类，继承 Base1 和 Base2
class Son :public Base1, public Base2
{
public:
    Son()
    {
        m_C = 3;
        m_D = 4;
    }
    int m_C;
    int m_D;
};

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

int main()
{
    test01();
    return 0;
}

运行结果：

　　

 

• P134. 菱形继承问题以及解决方法

菱形继承概念：

　　● 两个派生类继承同一个基类

　　● 又有某个类同时继承着两个派生类

　　● 这种继承被称为菱形继承，或者钻石继承

　　

菱形继承问题：

1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

2. 草泥马继承自 动物 的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以（比如 有一份数据代表 动物年龄，草泥马只需要继承一份就可以）。

//动物类
class Animal
{
public:
    int m_Age;
};

//羊类
class Sheep : public Animal
{};
//驼类
class Camel : public Animal
{};
//草泥马类
class Alpaca :public Sheep, public Camel
{};

void test01()
{
    Alpaca a1;
    //a1.m_Age = 18; //报错
    //当菱形继承，两个父类拥有相同成员，需要加作用域区分
    a1.Sheep::m_Age = 18;
    a1.Camel::m_Age = 28;
    cout << "a1.Sheep::m_Age = " << a1.Sheep::m_Age << endl;
    cout << "a1.Camel::m_Age = " << a1.Camel::m_Age << endl;
    //m_Age这份数据，只要有一份就可以，菱形继承导致数据有两份，资源浪费

}

int main()
{
    test01();
    return 0;
}

运行结果：

　　

 

解决办法：虚继承

//动物类
class Animal
{
public:
    int m_Age;
};

//利用虚继承，可以解决菱形继承的问题
//继承方式之前，加上关键字virtual，变为虚继承
//被虚继承的 Animal 类，称为虚基类
//羊类
class Sheep :virtual public Animal
{};
//驼类
class Camel :virtual public Animal
{};
//草泥马类
class Alpaca :public Sheep, public Camel
{};

void test01()
{
    Alpaca a1;     //当菱形继承，两个父类拥有相同成员，需要加作用域区分
    a1.Sheep::m_Age = 18;
    a1.Camel::m_Age = 28;
    cout << "a1.Sheep::m_Age = " << a1.Sheep::m_Age << endl;
    cout << "a1.Camel::m_Age = " << a1.Camel::m_Age << endl;

    cout << "a1.m_Age = " << a1.m_Age << endl;　　//此时可以直接访问到 a1.m_Age 了
}

int main()
{
    test01();
    return 0;
}

运行结果：

　　

 

vbptr：虚 基类 指针

v——virtual

b——base

ptr——pointer

vbptr 指向 vbtable（虚 基类 表），表中记录了一个偏移量，vbptr+偏移量 就是唯一继承的 m_Age 的地址

 

总结：

● 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义

● 利用虚继承可以解决菱形继承问题

(〃＞＿＜;〃)(〃＞＿＜;〃)(〃＞＿＜;〃)