构造析构的顺序问题

#include 
using namespace std;

class M
{
public:
M()
{
cout << "M constructed" << endl;
}

~M()
{
cout << "M destructed" << endl;
}
};

class N
{
public:
N()
{
cout << "N constructed" << endl;
}

~N()
{
cout << "N destructed" << endl;
}
};

class A : virtual public M
{
public:
A()
{
cout << "A constructed" << endl;
}

~A()
{
cout << "A destructed" << endl;
}
};

class B : virtual public M
{
public:
B()
{
cout << "B constructed" << endl;
}

~B()
{
cout << "B destructed" << endl;
}
};

class C : public B, public A
{
public:
C()
{
cout << "C constructed" << endl;
}

~C()
{
cout << "C destructed" << endl;
}

private:
N m_n;
};

int main()
{
// 构造的几点原则：
// 1. 先构造父类，然后构造子类
// 2. 虚拟继承，虚基类只会被构造一次
// 3. 多重继承，写在前面的先被构造（class C : public B, public A，所以B先于A被构造）
// 4. 先构造基类，然后构造成员对象（m_n）
// 所以，这里将依次输出：
// M constructed
// B constructed
// A constructed
// N constructed
// C constructed
C c;  

// 析造的重要原则：析构的顺序与构造的顺序刚好相反！
// 所以，这里将依次输出：
// C destructed
// N destructed
// A destructed
// B destructed
// M destructed
return 0;
}