#include <iostream> using namespace std; class A { public: A(){a=0;b=0;} A(int i){a=i;b=0;} A(int i,int j){a=i;b=j;} void display(){cout<<"a="<<a<<" b="<<b;} private: int a; int b; }; class B : public A { public: B(){c=0;} B(int i):A(i){c=0;} B(int i,int j):A(i,j){c=0;} B(int i,int j,int k):A(i,j){c=k;} void display1() {display(); cout<<" c="<<c<<endl; } private: int c; }; int main() { B b1; B b2(1); B b3(1,3); B b4(1,3,5); b1.display1(); b2.display1(); b3.display1(); b4.display1(); return 0; } (1)写出上述程序的输出结果。 (2)分析程序执行过程,写出调用构造函数和析构函数的规则。
时间: 2024-01-23 07:04:32 浏览: 20
以下是程序的输出结果:
```
a=0 b=0 c=0
a=1 b=0 c=0
a=1 b=3 c=0
a=1 b=3 c=5
```
程序执行过程如下:
1. 在 main 函数中,创建了 4 个 B 类对象 b1、b2、b3、b4。
2. 对象 b1 采用默认构造函数初始化,会调用 A 类的默认构造函数,然后 B 类的默认构造函数。因此,b1 的成员变量 a、b、c 都被初始化为 0。
3. 对象 b2 采用带参构造函数初始化,会调用 A 类的带参构造函数(参数为 1),然后 B 类的带参构造函数。因此,b2 的成员变量 a 被初始化为 1,b、c 被初始化为 0。
4. 对象 b3 采用带参构造函数初始化,会调用 A 类的带参构造函数(参数为 1、3),然后 B 类的带参构造函数。因此,b3 的成员变量 a 被初始化为 1,b 被初始化为 3,c 被初始化为 0。
5. 对象 b4 采用带参构造函数初始化,会调用 A 类的带参构造函数(参数为 1、3),然后 B 类的带参构造函数(参数为 5)。因此,b4 的成员变量 a 被初始化为 1,b 被初始化为 3,c 被初始化为 5。
6. 对象 b1、b2、b3、b4 在程序结束时自动调用析构函数,析构函数的调用顺序与构造函数相反。因此,先调用 B 类的析构函数,再调用 A 类的析构函数。
相关问题
补全程序,并写出程序运行结果。 #include <iostream> using namespace std; class Class { public : Class ( int...
补全程序如下:
```
#include <iostream>
using namespace std;
class Class {
public:
Class(int a, int b, int c) {
x = a;
y = b;
z = c;
}
void print() {
cout << "x: " << x << endl;
cout << "y: " << y << endl;
cout << "z: " << z << endl;
}
private:
int x;
int y;
int z;
};
int main() {
Class obj(1, 2, 3);
obj.print();
return 0;
}
```
程序运行结果为:
```
x: 1
y: 2
z: 3
```
程序定义了一个名为 Class 的类,该类包括有参构造函数和一个 print() 函数,构造函数用于对类的私有成员变量进行初始化,print() 函数用于输出类的私有成员变量。在主函数 main() 中,创建了一个名为 obj 的 Class 类对象,构造函数传入三个整数参数 1、2 和 3。最后调用 obj 对象的 print() 函数,输出 obj 对象的私有成员变量 x、y 和 z 的值。
#include<iostream> using namespace std; class C { public: C(int a) { x = a; } private: int x; }; class D :public C { public: D(int a):y(a){} private: int y; }; 指出错误,并说明原因
在类D的构造函数中,没有显式调用基类C的构造函数,因为类D是从类C派生而来的。因为类C没有默认构造函数,所以必须显式调用基类C的构造函数并传递参数。所以错误的行为是在类D的构造函数中未显式调用基类C的构造函数。
正确的代码应该是这样的:
```cpp
#include <iostream>
using namespace std;
class C {
public:
C(int a) { x = a; }
private:
int x;
};
class D : public C {
public:
D(int a, int b) : C(a) { y = b; }
private:
int y;
};
int main() {
D d(1, 2);
return 0;
}
```
在类D的构造函数中,我们显式调用了基类C的构造函数并传递了参数a,这样,类D就可以正确地初始化基类C的成员变量x。