#include <iostream> class A { int *p; A(int n) { p = &n; } show(); ~A() { delete p; } }; show() { cout << *p << endl; } int main() { A a; a.show(); return 0; }

这代码存在一些问题：

1. 在 A 类的构造函数中，将 p 指向了一个局部变量 n 的地址，当构造函数结束时，n 的生命周期结束，p 指向的内存已经被释放了，因此在 show 函数中访问 *p 会导致未定义的行为。
2. show 函数应该是 A 类的成员函数，需要在 A 类的定义中声明和实现。
3. main 函数中创建 A 类对象时需要传入一个 int 类型的参数，但是没有提供这个参数。

下面是一个修正后的代码示例：

#include <iostream>
using namespace std;

class A {
    int *p;
public:
    A(int n) {
        p = new int;
        *p = n;
    }
    void show() {
        cout << *p << endl;
    }
    ~A() {
        delete p;
    }
};

int main() {
    A a(123);
    a.show();
    return 0;
}

在这个修正后的代码中，我们使用 new 运算符在堆上分配了一块内存，将 p 指向这块内存，并将 n 的值赋给了这块内存中的整数。在 A 类的析构函数中，我们使用 delete 运算符释放了 p 指向的内存。同时，我们将 show 函数声明为了 A 类的成员函数。在 main 函数中，我们创建了一个 A 类对象并传入了一个 int 类型的参数，调用了 show 函数输出了这个参数的值。

相关问题

#include <iostream> class A { int *p; A(int n) { p = \\&n; } show(); ~A() { delete p; } }; show() { cout << *p << endl; } int main() { A a; a.show(); return 0; }

该代码存在一些问题，需要进行修改才能正常运行。以下是修改后的代码：

#include <iostream> 

using namespace std;

class A { 
    int *p; 
public:
    A(int n) { 
        p = new int; 
        *p = n; 
    } 
    void show() { 
        cout << *p << endl; 
    } 
    ~A() { 
        delete p; 
    } 
};

int main() { 
    A a(10); 
    a.show(); 
    return 0; 
}

主要修改的地方有：

1. 在类 A 中，构造函数应该使用 new 运算符为指针 p 动态分配内存，并将 n 的值赋给 *p，而不是直接将指针 p 的地址指向 n。

2. 在类 A 中，show 函数应该添加 public 访问修饰符，才能在 main 函数中调用。

3. 在 main 函数中，创建对象 a 时，应该传入一个 int 类型的参数，以便在构造函数中动态分配内存。同时，调用 show 函数时应该使用对象名 a 调用，而不是类名 A。

4. 在类 A 中，析构函数应该释放指针 p 所指向的内存，以免内存泄漏。

指出下列程序的错误，说明错误的原因并改正。 #include <iostream> class A { int *p; A(int n) { p = &n; } show(); ~A() { delete p; } }; show() { cout << *p << endl; } int main() { A a; a.show(); return 0; }

这段程序存在多个错误：

1. 在A类的构造函数中，将指针p指向了一个局部变量n的地址，当构造函数运行结束后，n变量会被销毁，p指向的地址就变成了一个无效的地址。

2. A类的show()函数没有指定返回类型。

3. A类的析构函数中使用了delete操作符，但是p指向的内存并不是通过new操作符分配的，所以delete操作是不正确的。

4. 在main函数中创建A类的对象时，应该传入一个int类型的参数，但是没有传入参数。

下面是改正后的程序：

#include <iostream> 
using namespace std;

class A {
private:
    int *p;
public:
    A(int n) {
        p = new int(n);
    }
    void show() {
        cout << *p << endl;
    } 
    ~A() {
        delete p;
    }
};

int main() {
    A a(10);
    a.show();
    return 0;
}

我们将p指向的内存通过new操作符进行分配，并在析构函数中使用delete操作符释放内存。同时，在A类的构造函数中，将n的值赋给了p指向的内存。在main函数中创建A类的对象时，传入了一个int类型的参数。