【c++编程思想】多重继承

 

• 虚基类

 

因为虚基类引起共享子对象，共享发生之前他们就应该存在才会有意义。所以子对象的初始化顺序遵循如下的规则递归的进行：

1）所有虚基类子对象，按照他们出现的位置，从上到下从左到右初始化。

2）然后非虚基类按照通常顺序初始化

3）所有的成员对象按照声明的顺序初始化

4）完整的对象构造函数执行。

 

#include<iostream>
#include<string>
using namespace std;

class M
{
    public:
    M(const string &s){
        cout<<"M constructure "<<s<<endl;
    }
};

class A
{
    M m;
    public:
    A(const string &s):m("in A"){
        cout<<"A "<<s<<endl;
    }
    virtual ~A(){}
};

class B
{
    M m;
    public:
    B(const string &s):m("in B"){
        cout<<"B "<<s<<endl;
    }
    virtual ~B(){}
};

class C
{
    M m;
    public:
    C(const string &s):m("in C"){
        cout<<"C "<<s<<endl;
    }
    virtual ~C(){}
};

class D
{
    M m;
    public:
    D(const string &s):m("in D"){
        cout<<"D "<<s<<endl;
    }
    virtual ~D(){}
};

class E:public A, virtual public B, virtual public C
{
    M m;
    public:
    E(const string& s):A("from E"), B("from E"), C("from E"), m("in E"){
        cout<<"E "<<s<<endl;
    }
};

class F: virtual public B, virtual C, public D
{
    M m;
    public:
    F(const string& s): B("from F"), C("from F"), D("from F"), m("in F"){
        cout<<"F "<<s<<endl;
    }
};

class G: public E, public F
{
    M m;
    public:
    G(const string& s):B("from G"), C("from G"), E("from G"), F("from G"), m("in G")
    {
        cout<<"G "<<s<<endl;
    }
};

int main()
{
    G g("from main");
}

 

 

 

 

 

• 名字查找问题

一般的作用域规则是：一个派生类被认为是嵌套在基类的作用域中，一般情况下，如果A直接或者间接的派生于B，或者换句话说，在继承层次中类A比类B处于更高的派生层次，那么名字A::f()就会比B::f()占优势，因此，在同名的两个函数之间进行选择时，编译器将选择占优势的那个函数，如果没有占优势的函数，就会产生二义性。

 

#include<iostream>
using namespace std;

class A
{
    public:
    virtual ~A(){}
    virtual void f(){
        cout<<"A::f()"<<endl;
    }
};

class B : virtual A
{
    public:
    void f(){
        cout<<"B::f()"<<endl;
    }
};

class C : public B{};
class D : public C, virtual public A{};

int main()
{
    B *p = new D;
    p->f();
    delete p;
}