#include <iostream> using namespace std; class Base { public: Base(int i):b(i) { cout<<"Base constructor. b="<<i<<endl; } ~Base() { cout<<"Base destructor. b="<<b<<endl; } int GetB() { return b; } private: int b; }; class B1: virtual public Base { public: B1(int i, int j) : Base(i), b1(j){cout<<"B1 constructor. b1="<<b1<<endl; } private: int b1; }; class B2: virtual public Base { public: B2(int i, int j) : Base(i), b2(j){cout<<"B2 constructor. b2="<<b2<<endl; } private: int b2; }; class Derived: public B1, public B2 { public: Derived(int i, int m, int n, int k) : Base(i), B1(i,m), B2(i,n), d(k) {cout<<"Derived constructor. d="<<d<<endl; } private: int d; }; int main() { Derived obj(1,2,3,4); return 0; }

这是一个多重继承的例子，它定义了一个基类 Base，和两个派生类 B1 和 B2，它们都通过虚拟继承方式继承了基类 Base。最后，派生类 Derived 继承了 B1 和 B2 两个派生类，从而间接地继承了基类 Base。

在构造对象 obj 的时候，首先会调用基类 Base 的构造函数，然后依次调用 B1 和 B2 的构造函数，最后调用 Derived 的构造函数。在构造函数中，我们可以看到每个类的成员变量都被初始化，并输出了相应的信息。当程序结束时，析构函数也会按照相反的顺序被调用，依次销毁每个类的对象。

相关问题

#include <iostream> using namespace std; class Base { int a; public: Base(int i) { a=i; cout<< "Base constructor" <<endl; } ~Base(){ cout<< "Base destructor" <<endl; } void print(){ cout<< a <<endl;} }; class Member { int b; public: Member(in

这段代码定义了一个Base类和一个Member类，在Member类中包含了一个Base类的对象。在main函数中，创建了一个Member对象m，并且将参数5传递给了Base类的构造函数。程序输出"Base constructor"，然后输出5。接着程序输出"Member constructor"，然后输出10，最后输出"Member destructor"和"Base destructor"。

因为Member类包含了一个Base类的对象，所以在创建Member对象时会先调用Base的构造函数，然后才调用Member的构造函数。在Member的构造函数中，将参数10赋值给了Member类的成员变量b，所以输出10。在程序结束时，析构函数的调用顺序与构造函数的调用顺序相反，所以先输出"Member destructor"，然后输出"Base destructor"。

#include <iostream> using namespace std; class Base1 { protected: int data1; public: Base1(int a = 8) { data1 = a; cout << data1 << ", Base1 Constructor\n"; } ~Base1() { cout << data1 << ", Base1 Destructor\n"; } }; class Base2 { protected: int data2; public: Base2(int a = 9) { data2 = a; cout << data2 << ", Base2 Constructor\n"; } ~Base2() { cout << data2 << ", Base2 Destructor\n"; } }; class Derived :public Base1, public Base2 { int d; public: Derived(int x, int y, int z) : Base1(x), Base2(y) //A { d = z; cout << "Derived Constructor\n"; } ~Derived() { cout << "Derived Destructor\n"; } void Show() { cout << data1 << ',' << data2 << ',' << d << endl; } }; int main() { Derived c(1, 2, 3); c.Show(); return 0; }以上C++代码调试时显示有一个错误，怎么解决？

在代码的构造函数`Derived(int x, int y, int z) : Base1(x), Base2(y)`后面没有加上大括号`{}`，导致编译器无法正确识别构造函数的定义，因此报错。

正确的代码应该是：

#include <iostream>
using namespace std;

class Base1 {
protected:
    int data1;
public:
    Base1(int a = 8) {
        data1 = a;
        cout << data1 << ", Base1 Constructor\n";
    }
    ~Base1() {
        cout << data1 << ", Base1 Destructor\n";
    }
};

class Base2 {
protected:
    int data2;
public:
    Base2(int a = 9) {
        data2 = a;
        cout << data2 << ", Base2 Constructor\n";
    }
    ~Base2() {
        cout << data2 << ", Base2 Destructor\n";
    }
};

class Derived :public Base1, public Base2 {
    int d;
public:
    Derived(int x, int y, int z) : Base1(x), Base2(y) {
        d = z;
        cout << "Derived Constructor\n";
    }
    ~Derived() {
        cout << "Derived Destructor\n";
    }
    void Show() {
        cout << data1 << ',' << data2 << ',' << d << endl;
    }
};

int main() {
    Derived c(1, 2, 3);
    c.Show();
    return 0;
}

以上代码中，在`Derived`类定义后面加上了大括号`{}`，用于定义构造函数和析构函数的内容。这样就可以正确识别构造函数的定义，消除了编译器报错。