点类派生圆类多态性与虚函数问题

定义一个点类，并派生一个圆类，点类指针指向圆类对象，并释放指针所指对象怎么写代码啊，析构函数用virtual定义

基于new bing的编写，有帮助记得采纳！：

#include <iostream>
using namespace std;

class Point {
public:
    Point(int x, int y) {
        this->x = x;
        this->y = y;
        cout << "Point构造函数被调用" << endl;
    }
    ~Point() {
        cout << "Point析构函数被调用" << endl;
    }
protected:
    int x;
    int y;
};

class Circle : public Point {
public:
    Circle(int x, int y, int r) : Point(x, y) {
        this->r = r;
        cout << "Circle构造函数被调用" << endl;
    }
    ~Circle() {
        cout << "Circle析构函数被调用" << endl;
    }
private:
    int r;
};

int main() {
    Point *p = new Circle(1, 2, 3); // 动态生成一个Circle对象，并让指针p指向它
    delete p; // 释放指针p所指的对象
    return 0;
}

首先，我们创建了一个名为 Point 的基类，其中包含 x 和 y 两个坐标成员变量，以及一个有参的构造函数和一个析构函数。接着我们创建了一个名为 Circle 的派生类，它继承自 Point 类并新增了一个半径成员变量 r，同样定义有参的构造函数和析构函数。在 Circle 类的构造函数中，我们调用了父类的构造函数，并输出一条初始化信息。

在主函数中，我们首先创建了一个指向基类对象的指针 p，并使用 new 关键字动态生成了一个 Circle 类的对象，让指针 p 指向它。接着我们调用了 delete 关键字释放了指针 p 所指向的对象，并观察、记录和分析了运行结果。

在程序运行时，首先会输出两条来自基类和派生类构造函数的初始化信息，然后系统会在程序结束时自动调用派生类和基类的析构函数，输出两条提示信息。最后，程序正常退出。如果我们没有正确释放指针所指向的对象，就会发生内存泄漏。

你可以参考下这个问题的回答, 看看是否对你有帮助, 链接: https://ask.csdn.net/questions/7564608
这篇博客也不错, 你可以看下程序的装入与链接（动、静态重定位）
除此之外, 这篇博客: 构造函数。常对象，静态对象中的 继承的定义 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
在C++中所谓“继承”就是在一个已存在的类的基础上建立一个新的类。
已存在的类称为“基类(base class)”或“父类(father class)”。新建立的类称为“派生类(derived class)”或“子类(son class)”
```
class Student1: public Student//声明基类是Student
{private:
      int age;    //新增加的数据成员
    string addr;  //新增加的数据成员
public:
   void display_1( )  //新增加的成员函数
   {  cout<<"age: "<<age<<endl; 
   cout<<"address: "<<addr<<endl;
}   
};
```
—在C++语言中，一个派生类可以从一个基类派生，也可以从多个基类派生。从一个基类派生的继承称为单继承；从多个基类派生的继承称为多继承。----
- 但派生并不是简单的扩充，有可能改变基类的性质。
- 有三种派生方式：公有派生、保护派生、私有派生。
- 默认的是私有派生。
您还可以看一下刘超老师的软件测试-测试用例设计课程中的测试用例的定义小节, 巩固相关知识点

以下回答由chatgpt基于相关博客总结生成:

首先，我们需要创建一个点类Point和一个继承于Point的圆类Circle。在Point类中，我们需要定义一个纯虚函数virtual void show() = 0; 用于在Circle类中重写并体现多态性。

class Point {
public:
    Point() {} //默认构造函数
    virtual ~Point() {} //析构函数声明为虚函数，以确保删除基类指针时同时删除派生类实例

    virtual void show() = 0;  //定义纯虚函数
};

class Circle : public Point {
public:
    Circle(int x, int y, double r) : m_x(x), m_y(y), m_r(r) {}  //定义构造函数
    ~Circle() {}  //定义析构函数

    virtual void show();  //重写show函数实现多态性

private:
    int m_x, m_y;
    double m_r;
};

void Circle::show() {
    cout << "这是一个圆心坐标为(" << m_x << "," << m_y << ")，半径为" << m_r << "的圆" << endl;
}

现在我们有了一个点类和一个圆类，现在可以使用一个指向基类的指针来指向派生类实例，并使用该指针调用派生类中的函数。

int main() {
  Point* p = new Circle(1, 2, 3.0);  //创建Circle类实例并指向基类
  p->show();  //调用Circle类中的show函数，实现多态性

  delete p;  //删除基类指针
  return 0;
}

需要注意的是，由于Circle类继承于Point类，所以我们需要使用虚析构函数保证删除基类指针时同时删除派生类实例。因此，我们需要将Point类的析构函数声明为虚函数。

完整代码如下：

#include <iostream>
using namespace std;

class Point {
public:
    Point() {}
    virtual ~Point() {}

    virtual void show() = 0;
};

class Circle : public Point {
public:
    Circle(int x, int y, double r) : m_x(x), m_y(y), m_r(r) {}
    ~Circle() {}

    virtual void show();

private:
    int m_x, m_y;
    double m_r;
};

void Circle::show() {
    cout << "这是一个圆心坐标为(" << m_x << "," << m_y << ")，半径为" << m_r << "的圆" << endl;
}

int main() {
    Point* p = new Circle(1, 2, 3.0);
    p->show();

    delete p;
    return 0;
}