在下面程序的基础上作以下三种修改，并对修改前后结果的变化及原因展开讨论。 1) 把构造函数修改为带参数的函数，在建立对象时初始化。 2) 先不将析构函数声明为virtual，在main函数中另设一个指向Circle类对象的指针变量p1。运行程序，分析结果。 3) 不作第2)点的修改，而将析构函数~Point()声明为virtual，运行程序，分析结果。 #include <iostream> using namespace std; class Point { public: Point(){} ~Point() { cout<<"executing Point destructor"<<endl; } }; class Circle: public Point { public: Circle(){} ~Circle() { cout<<"executing Circle destructor"<<endl; } private: int radius; }; int main() { Point *p=new Circle; delete p; return 0; }

1) 修改构造函数为带参数的函数

修改之前的构造函数是默认构造函数，不带参数。现在我们可以将其修改为带参数的构造函数，如下所示：

class Point {
public:
    Point(int x, int y): x(x), y(y) {}
    ~Point() {
        cout << "executing Point destructor" << endl;
    }
private:
    int x, y;
};

class Circle: public Point {
public:
    Circle(int x, int y, int r): Point(x, y), radius(r) {}
    ~Circle() {
        cout << "executing Circle destructor" << endl;
    }
private:
    int radius;
};

int main() {
    Point *p = new Circle(1, 2, 3);
    delete p;
    return 0;
}

在建立对象时初始化时，需要传入构造函数所需要的参数。在这个例子中，我们将Point类和Circle类的构造函数修改为带参数的函数，需要传入一个x坐标、一个y坐标和一个半径。这样在建立Circle对象时就可以直接传入这些参数，而不需要再调用Circle对象的成员函数来设置这些参数。这种方式可以使代码更简洁，也更方便。

2) 先不将析构函数声明为virtual

现在我们先不将析构函数声明为virtual，而是在main函数中另设一个指向Circle类对象的指针变量p1，如下所示：

int main() {
    Circle *p1 = new Circle();
    Point *p2 = p1;
    delete p2;
    return 0;
}

在这个例子中，我们建立了一个Circle对象p1，并将其地址赋值给Point指针变量p2。然后我们使用p2来delete这个对象。由于Circle是Point的子类，所以我们可以使用Point指针来指向Circle对象。但是由于我们没有将析构函数声明为virtual，所以在delete这个对象时，只会调用Point类的析构函数，而不会调用Circle类的析构函数。因此，这个程序只会输出"executing Point destructor"，而不会输出"executing Circle destructor"。

3) 将析构函数~Point()声明为virtual

现在我们将析构函数~Point()声明为virtual，如下所示：

class Point {
public:
    Point() {}
    virtual ~Point() {
        cout << "executing Point destructor" << endl;
    }
};

class Circle: public Point {
public:
    Circle() {}
    ~Circle() {
        cout << "executing Circle destructor" << endl;
    }
};

int main() {
    Point *p = new Circle();
    delete p;
    return 0;
}

在这个例子中，我们将析构函数~Point()声明为virtual。这样在delete这个对象时，会先调用Circle类的析构函数，再调用Point类的析构函数。因此，这个程序会输出"executing Circle destructor"和"executing Point destructor"，这两个析构函数都会被调用。这种方式可以保证在delete一个对象时，它的所有子类的析构函数都会被调用，避免内存泄漏的问题。