实现基类Point类（X,Y坐标成员变量），定义有参构造函数，实现函数分别获取x，y坐标成员函数，实现display函数，定义一个point变量，输出当前点的坐标信息。

好的，这是一个简单的基于C++的实现：

class Point {
private:
    int x, y;
public:
    Point(int x_, int y_): x(x_), y(y_) {} // 有参构造函数
    int getX() const { return x; }        // 获取x坐标
    int getY() const { return y; }        // 获取y坐标
    void display() const {                // 输出坐标信息
        std::cout << "Current coordinates: (" << x << ", " << y << ")" << std::endl;
    }
};

int main() {
    Point p(1, 2);    // 创建一个Point对象
    p.display();      // 输出当前坐标信息
    return 0;
}

输出结果：

Current coordinates: (1, 2)

以上代码中，我们首先定义了一个Point类，并在其中声明了x和y坐标成员变量。在有参构造函数中，我们给这两个变量赋值。getX和getY函数分别返回这两个坐标变量的值。display函数用于输出当前点的坐标信息。

在main函数中，我们创建了一个Point对象，并将x和y的值分别设置为1和2。接着，我们调用display函数输出当前点的信息。

相关问题

运用c++定义一个Point类，派生出Rectangle和Circle类，计算个派生类对象的面积Area()。 要求：①Point类，Rectangle和Circle类都有成员变量、成员函数； ②分别写出他们的构造函数和析构函数； ③通过point的坐标计算面积。 ④在main函数中实现输出。

好的，我会尽力回答您的问题。下面是我实现的代码：

#include <iostream>
#include <cmath>

using namespace std;

class Point {
protected:
    double x, y;

public:
    Point(double x = 0, double y = 0) {
        this->x = x;
        this->y = y;
    }

    virtual ~Point() {}

    double getX() const {
        return x;
    }

    double getY() const {
        return y;
    }
};

class Rectangle : public Point {
private:
    double width, height;

public:
    Rectangle(double x = 0, double y = 0, double width = 0, double height = 0) : Point(x, y) {
        this->width = width;
        this->height = height;
    }

    ~Rectangle() {}

    double getWidth() const {
        return width;
    }

    double getHeight() const {
        return height;
    }

    double Area() const {
        return width * height;
    }
};

class Circle : public Point {
private:
    double radius;

public:
    Circle(double x = 0, double y = 0, double radius = 0) : Point(x, y) {
        this->radius = radius;
    }

    ~Circle() {}

    double getRadius() const {
        return radius;
    }

    double Area() const {
        return M_PI * pow(radius, 2);
    }
};

int main() {
    Rectangle r(0, 0, 5, 3);
    Circle c(0, 0, 2);

    cout << "The area of the rectangle is: " << r.Area() << endl;
    cout << "The area of the circle is: " << c.Area() << endl;

    return 0;
}

在这个代码中，我们定义了一个Point类作为基类，然后派生出Rectangle和Circle类。在Rectangle和Circle类中，我们分别定义了它们的成员变量和成员函数，并且实现了Area()函数用于计算面积。在main函数中，我们创建了一个Rectangle对象和一个Circle对象，并输出它们的面积。

需要注意的是，我们在Point类中定义了虚析构函数，这是因为我们在Rectangle和Circle类中使用了多态性，如果不定义虚析构函数，可能会导致内存泄露。

1.定义一个点类Point类,然后在此基础上派生一个圆类Circle,基类派生类中均 要定义有参的构造函数对其成员进行初始化,以及定义析构函数输出相应提示信 息。在主函数中先定义一个指向Point类对象的指针,并让其指向动态

### 回答1：
分配的Circle类对象，最后释放内存并输出相应提示信息。

以下是代码实现：

#include <iostream>
#include <cmath>
using namespace std;

class Point {
protected:
    double x;
    double y;
public:
    Point(double x0 = 0, double y0 = 0) :x(x0), y(y0) {}
    ~Point() {
        cout << "Point对象被析构" << endl;
    }
};

class Circle :public Point {
private:
    double r;
public:
    Circle(double x0, double y0, double r0) :Point(x0, y0), r(r0) {}
    ~Circle() {
        cout << "Circle对象被析构" << endl;
    }
    double getArea() {
        return 3.14 * r * r;
    }
};

int main() {
    Point* p;
    p = new Circle(1, 2, 3);
    cout << "该圆的面积为：" << dynamic_cast<Circle*>(p)->getArea() << endl;
    delete p;
    return 0;
}

首先定义了一个Point类，包含了x、y两个成员变量，以及构造函数和析构函数。

然后定义了一个Circle类，继承自Point类，新增了一个r成员变量和一个计算圆面积的getArea()函数。Circle类也有自己的构造函数和析构函数。

在主函数中，先定义了一个指向Point类对象的指针p，然后让它指向动态分配的Circle类对象，输出该圆的面积后，释放内存并输出相应提示信息。

运行结果如下：

该圆的面积为：28.26
Circle对象被析构
Point对象被析构

### 回答2：
定义一个点类Point类：

class Point {
public:
    Point(float x, float y) : m_x(x), m_y(y) {
        cout << "Point构造函数被调用" << endl;
    }
    ~Point() {
        cout << "Point析构函数被调用" << endl;
    }
protected:
    float m_x;
    float m_y;
};

在此基础上派生一个圆类Circle：

class Circle : public Point {
public:
    Circle(float x, float y, float radius) : Point(x, y), m_radius(radius) {
        cout << "Circle构造函数被调用" << endl;
    }
    ~Circle() {
        cout << "Circle析构函数被调用" << endl;
    }
private:
    float m_radius;
};

在主函数中定义一个指向Point类对象的指针，并让其指向动态分配的Circle对象：

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

以上代码先创建了一个指针p，类型为Point*，指向动态分配的Circle对象。创建Circle对象时，会先调用Point类的有参构造函数来初始化基类成员，然后再调用Circle类的有参构造函数来完成派生类成员的初始化。在程序结束时，使用delete关键字释放动态分配的内存，会调用Circle类的析构函数和Point类的析构函数来完成对象的清理工作。析构函数内输出相应提示信息。

### 回答3：
定义一个点类Point类包含两个私有成员变量x和y代表坐标，并具有公有成员函数用于获取和设置坐标值。在构造函数中，可以通过传递参数来初始化x和y的值。

class Point {
private:
    int x;
    int y;
public:
    Point(int _x, int _y) : x(_x), y(_y) {}
    int getX() const { return x; }
    int getY() const { return y; }
    void setX(int _x) { x = _x; }
    void setY(int _y) { y = _y; }
};

派生一个圆类Circle，继承自基类Point类，并添加一个私有成员变量radius表示半径。在派生类的构造函数中，除了需要初始化继承自基类的成员变量x和y之外，还需要初始化radius。

class Circle : public Point {
private:
    int radius;
public:
    Circle(int _x, int _y, int _radius) : Point(_x, _y), radius(_radius) {}
    int getRadius() const { return radius; }
    void setRadius(int _radius) { radius = _radius; }
};

在派生类的析构函数中，输出相应提示信息。

~Circle() { cout << "圆类的析构函数被调用" << endl; }

在主函数中，先定义一个指向Point类对象的指针，并让其指向动态分配的Point对象。然后，再通过该指针定义一个派生类Circle的对象，并进行相应的初始化和操作。

int main() {
    Point* ptr = new Point(1, 2); // 动态分配Point对象
    Circle circle(3, 4, 5); // 定义一个Circle对象
    ptr = &circle; // 指针指向Circle对象
    // 进行相关操作，如调用派生类的成员函数等
    delete ptr; // 释放动态分配的内存
    return 0;
}

以上就是定义了一个点类Point类，然后在此基础上派生了一个圆类Circle，并在基类和派生类中定义了有参的构造函数进行初始化，同时在派生类的析构函数中输出相应提示信息的程序。