C++_day8_ 多重继承、钻石继承和虚继承

1.继承的复习

1.1 类型转换

编译器认为访问范围缩小是安全的。

1.2 子类的构造与析构

子类中对基类构造函数初始化只能写在初始化表里，不能写在函数体中。

阻断继承。

1.3 子类的拷贝构造与拷贝赋值

2. 多重继承、钻石继承和虚继承

• 多重继承

　　一个类可以同时从多个基类继承实现代码。

　　

　　

　　示例代码：

#include <iostream>

using namespace std;

class Phone{
public:
    Phone(string const& no):m_no(no){
        cout << "Phone构造" << this << endl;
    }
    ~Phone(void)
    {
        cout << "Phone析构" << this << endl;
    }
    void call (string const& no)
    {
        cout << m_no << "呼叫" << no << endl;
    }
private:
    string m_no;
};

class Player{
public:
    Player(string const& media):m_media(media)
    {
        cout << "Player构造" << this << endl;
    }
    ~Player(void)
    {
        cout << "Player析构" << this << endl;
    }
    void play(string const& clip)
    {
        cout << m_media << "播放" << clip << endl;
    }
private:
    string m_media;
};

class Computer{
public:
    Computer(string const& os):m_os(os)
    {
        cout << "Computer构造" << this << endl;
    }
    ~Computer(void)
    {
        cout << "Computer析构" << this << endl;
    }
    void run(string const& app)
    {
        cout << "在" << m_os << "上运行" << app << endl;
    }
private:
    string m_os;
};

class SmartPhone:public Phone, public Player, public Computer{
public:
    SmartPhone (string const& no, string const& media, string const& os):Phone(no), Player(media), Computer(os){}
private:
};

int main(void)
{
    SmartPhone sp("17816120319", "MP3/MP4/3GP", "Andriod");
    sp.call("17095400176");
    sp.play("我还年轻");
    sp.run("JBG大战Victor Wang");
    Phone* pPhone = &sp;    //访问范围缩小，不会报错
    cout << "&sp = " << &sp << endl;
    cout << "pPhone = " << pPhone << endl;
    Player* pPlayer = &sp;
    cout << "pPlayer = " << pPlayer << endl;
    Computer* pComputer = &sp;
    cout << "pComputer = " << pComputer << endl;
    /*
    SmartPhone* pSmart = static_cast<SmartPhone*> (pComputer);
    cout << "pSmart = " << pSmart << endl;
    */
    
    /*
    SmartPhone* pSmart = (SmartPhone*) pComputer;
    cout << "pSmart = " << pSmart << endl;
    */
    
    SmartPhone* pSmart = reinterpret_cast <SmartPhone*> (pComputer);
    cout << "pSmart = " << pSmart << endl;
    
    return 0;
}

 　　

　　名字冲突问题：

　　1.

class C: public A, public B{
public:
    using A::foo;
    using B::foo;
    
};

　　2.

/*
    c.A::foo();
    c.B::foo(100);
    */

　　3.

class C: public A, public B{
public:
/*
    using A::foo;
    using B::foo;
    */
    void foo(int f, int x)
    {
        if(f == 1)
            A::foo();
        else if(f == 2)
            B::foo(x);
    }
};

• 钻石继承

   　　一个子类继承自多个基类，而这些基类有源自共同的祖先，这样的继承结构成为钻石继承（菱形继承）。

　　

　　

　　

• 虚继承

　　

　　示例代码：

#include <iostream>

using namespace std;

class A{
public:
    A(int data):m_data(data)
    {
        cout << "A构造" << this << endl;
    }
protected:
    int m_data;
};

class B: virtual public A {
public:
    B(int data): A(data)
    {
        cout << "B构造" << this << endl;
    }
    void set(int data)
    {
        cout << "B:" << &m_data << endl;
        m_data = data;
    }
};

class C: virtual public A {
public:
    C(int data): A(data)
    {
        cout << "C构造" << this << endl;
    }
    int get (void) const
    {
        cout << "C:" << &m_data << endl;
        return m_data;
    }
};

class D: public B, public C{
public:
    D(int data):B(data), C(data), A(data) {}
};

int main(void)
{
    D d(100);
    d.set(200);
    cout << d.get() << endl;
    cout << sizeof(d) << endl;
    
    return 0;
}

 虚继承是为了解决钻石继承的问题。