【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;
}