#include<iostream.h>
class A
{
public:
    A(){cout<<"类A的构造函数"<<endl;}
    ~A(){cout<<"类A的析构函数"<<endl;}
};
class B:public A
{
public:
    B(int x=0):b(x){cout<<"类B的构造函数"<<endl;}
    ~B(){cout<<"类B的析构函数"<<endl;}
    int get(){return b;}
private:
    int b;
};
class C:public A
{
public:
    C(int y=0):c(y){cout<<"类C的构造函数"<<endl;}
    ~C(){cout<<"类C的析构函数"<<endl;}
    int get(){return c;}
private:
    int c;
};
class D:public B,public C
{
public:
    D(int x=0,int y=0):B(x),C(y){cout<<"类D的构造函数"<<endl;}
    ~D(){cout<<"类D的析构函数"<<endl;}
    D add(B &p,C &q)
    {
        D D1;
        D1.d=p.get()+q.get();
        return D1;
    }
    void put(){cout<<d<<endl;}
private:
    int d;
};
void main()
{
    B B1(1);
    C C1(2);
    D D2(3,4);
    D2=D2.add(B1,C1);
    D2.put();
}

这是运行结果求解释
类A的构造函数
类B的构造函数
类A的构造函数
类C的构造函数
类A的构造函数
类B的构造函数
类A的构造函数
类C的构造函数
类D的构造函数
类A的构造函数
类B的构造函数
类A的构造函数
类C的构造函数
类D的构造函数
类D的析构函数
类C的析构函数
类A的析构函数
类B的析构函数
类A的析构函数
类D的析构函数
类C的析构函数
类A的析构函数
类B的析构函数
类A的析构函数
3
类D的析构函数
类C的析构函数
类A的析构函数
类B的析构函数
类A的析构函数
类C的析构函数
类A的析构函数
类B的析构函数
类A的析构函数

派生类的构造函数调用之前都会先调用基类的构造函数，但析构函数则是先调用派生类再调用基类的

笑看答案....

派生类首先是对基类的继承，然后在此基础上加以改造。而继承的时候基类的构造函数并没有被继承下来。所以当需要初始化一个派生类的对象的时候，系统就会去调用基类的构造函数首先对一个对象继承自基类的部分做初始化，基类的调用顺序是按照继承声明的顺序来发生的。然后才是对新增成员对象（其他类的直接在初始化列表里进行，本类特有的在构造函数体中进行）的初始化