#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; }为什么调用B1构造函数时，没有运 cout<<"Base constructor. b="<<i<<endl;

在这个程序中，B1和B2都继承了虚拟基类Base。由于Base是虚拟继承，所以在Derived类中只会有一个Base子对象，而不是两个。

当Derived对象被创建时，首先会调用Base类的构造函数，因为Derived类中的Base子对象需要被初始化。然后，B1和B2类的构造函数会被调用，它们会通过委托构造函数来调用Base类的构造函数，但是由于Base类已经被初始化过了，所以它的构造函数不会再次被调用。

因此，在调用B1构造函数时，不会再次调用Base类的构造函数，而是直接使用已经初始化好的Base子对象。

相关问题

#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 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 的构造函数。在构造函数中，我们可以看到每个类的成员变量都被初始化，并输出了相应的信息。当程序结束时，析构函数也会按照相反的顺序被调用，依次销毁每个类的对象。