分析代码示例：
 
#include <iostream>

using namespace std;

class X
{
	public: X()
	{
		cout<<"X ";
	}
};
class Y 
{
	public: Y()
	{
	cout<<"Y ";
	}
};
class Z 
{
	public: Z()
	{
		cout<<"Z ";
	}
};
class A 
{
	public: A()
	{
		cout<<"A ";
	}	
};
class B 
{
	public: B()
	{
		cout<<"B ";
	}
};
class C : public B, virtual public A  
{
	public: C()
	{
		cout<<"C ";
	}
};
class D : public B, virtual public A  
{
	public: D()
	{
		cout<<"D ";
	}
};
class E : public C, virtual public D, virtual public Z
{     public:
    X objX;
    Y objY;
    E()
    {
    	cout<<"E ";
    }
};
int main() 
{      
	E obj; 
}

 
输出结果：
 
A B D Z B C X Y E
 
按步骤debug：
 
 
多重继承的顺序分析
 
主要遵循以下几点：
 1.先执行各基类的构造函数，再执行对象成员构造函数，后执行派生类构造函数
 注：
 ①处于同一层次的各基类构造函数的执行顺序与声明派生类时所指定的各基类顺序一致，而与派生类的构造函数定义中初始化列表顺序无关。
 ②若父类构造函数带有参数，必须在最远继承子类初始化列表调用。
 
2.析构函数的执行顺序与构造函数相反。
 
3.若同一层次中同时包含虚基类和非虚基类，先调用虚基类的构造函数，再调用非虚基类的构造函数。
 
4.同一层次中的非虚基类只调用一次。
 
5.如果派生类的成员与基类的某个成员同名，则派生类将在其作用域隐藏掉该基类成员。（C++ Prime 5）
 
依据如上分析，则示例代码中：
 由3，找到classD
 由3，找到classA并执行A()
 由1，找到classB并执行B()
 由1，执行classD的D()
 由3，找到classZ并执行Z()
 由3，找到classC
 由4，找到classB并执行B()
 由1，找到classX并执行X()
 由1，找到classY并执行Y()
 由1，执行E()
 得到结果A B D Z C B X Y E

Scala多重继承、多重继承构造器执行顺序及AOP实现
 

  
 
内容：
 
 
1、多重继承的trait代码实战
 
 
2、多重继承构造器执行顺序
 
 
3、给予trait的AOP代码实现
 
 
 
 
该代码中PianoPlayer类继承了Human，在构造的时候按照从左到右的顺序进行构造，TTeacher和PianoPlayer是PianoTeacher的特性，然后覆写了TTeacher的抽象方法teach。
 
 
 
 
 
 
 
 
 
 
改代码中t2后面构造了一个匿名的内部类，有TTeacher和PianoPlayer的特征（多重继承和继承顺序）。
 
 
 
 
在上述代码中TBeforeAfter继承了Action，所以要覆写doAction方法，因为以上代码中使用super.doAction调用父类的方法，即doAction没有具体实现，因此在覆写的时候要加上abstract和override关键字。
 
 
AOP实现中包括了前置方法，具体实现，后工作完成后的资源清理和回收等动作。
 
 
 

#include<iostream>
using namespace std;

class a{
	public:
		a()
		{
			cout<<"\na\n";
		}
};

class b{
	public:
		b()
		{
			cout<<"\nb\n";
		}
};

class c{
	public:
		c()
		{
			cout<<"\nc\n";
		}
};

class d{
	public:
		d()
		{
			cout<<"\nd\n";
		}
};

class dd{
	public:
		dd()
		{
			cout<<"\ndd\n";
		}
};

class ff{
	public:
		ff()
		{
			cout<<"\nff\n";
		}
};

class dyh:public a,virtual public b,public c,virtual public d
{
	public:
		dyh()	//:a(),b(),c(),d(),s(),ss()
		{
			cout<<"\n类的继承顺序\n";
		}
	protected:
		dd s;
		ff ss;		
};

int main()
{
	dyh aa;
	cout<<"\nok\n";
}
 
 

今天看程序员面试宝典（第三版时）时，看到一个关于多重继承的问题。题目如下
 
#include<iostream>
 using namespace std;
 
 class A
 {
 int a;
 };
 class B 
 {
 int b;
 };
 class C : public  A, public B
 {
 int c;
 };
  
 int main()
 {
 
 
C * pc = new C;

 
B * pb = dynamic_cast<B *>(pc);

 
A * pa = dynamic_cast<A *>(pc);

 
if(pc == pb)
     {
 cout << "equal" << endl;
     }  
     else
     {
           cout << "not equal" << endl;
     }
     if((int)pc == (int )pb)
     {
           cout << "equal" << endl;
     } 
     else
     {
           cout << "not equal" << endl;
     }
 cout << "pa : " << pa << endl;
 cout << "pb : " << pb << endl;
 cout << "pc : " << pc << endl;
 cout << "(int)pa : " << (int)pa << endl;
 cout << "(int)pb : " << (int)pb << endl;
 cout << "(int)pc : " << (int)pc << endl;
 
      return 0;
 
}
 
 
C的继承顺序若是先A后B，用vs2010测试后，结果如下：
 

 
 
可以看到，pa和pc值是相同的，pb前进了4个字节，这里我是这么理解的，C的继承顺序是先A后B，故C的数据成员在内存中的排序应该是a，b，c，pc指向a的位置，pb应该指向b的位置，pa也指向a的位置，这里可以通过变换C继承的顺序来证明，若C的继承顺序是先B后A，结果如下：
 

 
 
在dev c++下的测试结果，可以看到pb和pc的指向内存地址是相同的。
 

 
 
再来看看两个比较的问题。继承顺序是先A后B时，pb和pc指向的内存地址不同，但是为何第一个if语句（即pc == pb）的结果输出时equal咧？
 
pc == pb比较的到底是什么呢？
 
按照面试宝典上的解释，比较的是pc指向的对象和（C*）隐式转换pb后pb指向的对象（pc指向的对象）的部分，指向的是同一个部分，这里倒不是很明白，希望谁看到了可以给我解释一下。
 
这里写这个主要是明白了一个东西，多重继承时，继承的顺序不同，继承来的东西在子类中的存储顺序也会跟着不同，同时各父类指针发生这种强制转换时指向的地址也是按照这个排序来确定的。