using namespace std; class A{ int i; public: A(int k=0){ i=k; } void display(){ cout<<"i="<<i<<endl; } }; int main() { A*p=new A; //动态创建对象p p->display(); delete p; //删除对象p p=new A(8); p->display(); delete p; p=new A[3]; //p指向对象数组 A *q=p; for(int i=0;i<3;i++){ q++->display(); //输出对象数组数据 } delete p; //删除对象数组指针p return 0; }

这个程序的功能是创建一个类 A，该类有一个 int 类型的成员变量 i，以及一个 display() 函数用于显示 i 的值。在 main() 函数中，首先使用 new 关键字动态创建一个 A 类对象并将其指针赋值给 p，然后调用 p 指针所指向的对象的 display() 函数进行输出，并使用 delete 关键字删除 p 指针所指向的对象。接着重新使用 new 关键字创建一个 A 类对象并将其指针赋值给 p，并设置 i 的值为 8，然后再次调用 p 指针所指向的对象的 display() 函数进行输出，并使用 delete 关键字删除 p 指针所指向的对象。接着，使用 new 关键字创建一个 A 类对象数组，数组大小为 3，然后将其指针赋值给 p，用 q 指针指向第一个对象，使用 for 循环输出对象数组的数据，并最后使用 delete 关键字删除 p 指针指向的对象数组。

相关问题

【简答题】妭撦并改正摎撧撡序中匋错徹。 #include <iostream> using namespace std; class A { public: int x; A(int a = 0) { x = a; } void display() { cout << "A.x=" << x << endl; } }; class B { public: int x; B(int a = 0) { x = a; } void display() { cout << "B.x=" << x << endl; } }; class C : public A, public B { int y; public: C(int a, int b, int c) : A(a), B(b) { y = c; } int gety() { return y; } }; int main() { C myc(1, 2, 3); myc.x = 10; myc.display(); return 0; }

在类`C`的构造函数中，应该将成员变量`y`的初始化列表放在`A(a)`和`B(b)`之后，如下所示：

C(int a, int b, int c) : A(a), B(b), y(c) {
}

此外，在`main`函数中，应该将调用`display`函数的对象由`myc`改为`myc.A::display()`或`myc.B::display()`，以指定调用哪个基类的`display`函数。修改后的代码如下：

#include <iostream>
using namespace std;

class A {
public:
    int x;
    A(int a = 0) { x = a; }
    void display() { cout << "A.x=" << x << endl; }
};

class B {
public:
    int x;
    B(int a = 0) { x = a; }
    void display() { cout << "B.x=" << x << endl; }
};

class C : public A, public B {
    int y;
public:
    C(int a, int b, int c) : A(a), B(b), y(c) {
    }
    int gety() { return y; }
};

int main() {
    C myc(1, 2, 3);
    myc.x = 10;
    myc.A::display(); // 指定调用A类的display函数
    return 0;
}

输出结果为：

A.x=10

说明已经成功地调用了`A`类的`display`函数。

#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）分析程序执行过程，写出调用构造函数和析构函数的规则。

以下是程序的输出结果：

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 类的析构函数。