如下代码，在屏幕上的输出结果是（）。 class B1 { public: B1(int i) { cout<<"构造B1:"<<i<<endl; } ~B1() { cout<<"析构 B1"<<endl; } }; class B2 { public: B2(int i) { cout<<"构造B2:"<<i<<endl; } ~B2() { cout<<"析构B2"<<endl; } }; class B3 { public: B3() { cout<<“构造 B3：*"<<endl; } ~B3() { cout<<“析构 B3 "<<endl; } }; class C : public B2, public B1, public B3 { public: C(int a, int b, int c, int d) : B1(a), mB2(d), mB1(c), B2(b) { } private://私有成员 B1 mB1; B2 mB2; B3 mB3; }; int main() { C obj(5, 6, 7, 8); }

输出结果为：

构造B1:5

构造B2:6

构造 B3：*

构造B1:7

构造B2:8

析构 B3

析构B2

析构 B1

析构B2

析构 B1

析构 B3

说明：

在main函数中创建了一个C类的对象obj，初始化列表中的参数顺序是B1(a), mB2(d), mB1(c), B2(b)，因此先构造B1(5)，再构造B2(6)，再构造B1(7)，最后构造B2(8)和B3。析构的顺序与构造相反，最后析构B2(8)和B1(7)，然后析构B2(6)和B1(5)，最后析构B3。

相关问题

#include <iostream> using namespace std; class A { int a; public: A(){ cout<<"Constructing A"<<endl; }}; class B { public: B(){ cout<<"Constructing B"<<endl;}}; class C { public: C(){ cout<<"Constructing C"<<endl;}}; class B1:virtual public B, virtual public A{ public: B1(int i){ cout<<"Constructing B1"<<endl; }}; class B2:public A, virtual public B { public: B2(int j){ cout<<"Constructing B2"<<endl; }}; class D: public B2, public B1, virtual public C { public: D(int m,int n): B1(m),B2(n){ cout<<"Constructing D"<<endl; } A a; }; int main(){ D d(1,2); }输出过程

输出过程如下：

Constructing A
Constructing B
Constructing B1
Constructing A
Constructing B
Constructing B2
Constructing C
Constructing D

首先创建了对象d，接着创建了B1和B2对象，由于B1和B2都继承了虚拟的B基类和A基类，所以先创建了A和B对象，然后创建了B1和B2对象。接着创建了C对象，最后创建了D对象。输出的顺序即为对象创建的顺序。

写出以下程序的运行结果 #include <iostream> class A { int a; public: A(int i) { a=i; cout << "constructing class A" << endl; } void print() { cout << a << endl; } ~A() { cout << "destructing class A" << endl; } }; class B1: public A { int b1; public: B1(int i, int j): A(i) { b1=j; cout << "constructing class B1" << endl; } void print() { A::print(); cout << b1 << endl; } ~B1() { cout << "destructing class B1" << endl; } }; class B2: public A { int b2; public: B2(int i, int j): A(i) { b2=j; cout << "constructing class B2" << endl; } void print() { A::print(); cout << b2 << endl; } ~B2() { cout << "destructing class B2" << endl; } }; class C: public B1, public B2 { int c; public: C(int i, int j, int k, int l, int m) : B1(i, j), B2(k, l), c(m) { cout << "constructing class C" << endl; } void print() { B1::print(); B2::print(); cout << c << endl; } ~C( ){ cout << "destructing class C" << endl; } }; void main() { C c1(1,2,3,4,5); c1.print(); }

运行结果为：

constructing class A
constructing class B1
constructing class A
constructing class B2
constructing class C
1
2
3
4
5
destructing class C
destructing class B2
destructing class A
destructing class B1
destructing class A

程序定义了四个类，A、B1、B2 和 C。其中 A 类具有一个私有成员变量 a 和一个公有成员函数 print()，分别用于打印 a 的值和换行。B1 类和 B2 类都继承自 A 类，具有私有成员变量 b1 和 b2，以及构造函数和析构函数用于打印对象的创建和销毁信息。C 类同时继承自 B1 类和 B2 类，具有私有成员变量 c 和构造函数和析构函数用于打印对象的创建和销毁信息。C 类还定义了一个公有成员函数 print()，用于通过调用 B1 类和 B2 类的 print() 函数打印 b1、b2 和 c 的值。

在 main 函数中，程序创建了一个名为 c1 的 C 类对象，并分别传递了 1、2、3、4 和 5 作为参数，用于初始化 A、B1、A、B2 和 C 对象的成员变量。随后程序调用 c1 的 print() 函数，打印出 b1、b2 和 c 的值。最后程序自动调用 c1 的析构函数和 B1、A、B2 和 A 对象的析构函数，以释放对象占用的内存空间。