class RECT{ protected: int x,y; public: RECT(int x1, int y1) { x=x1,y=y1; }; virtual int area() { return x*y; }; int peri() { return 2*x+2*y; }; virtual int isSquare() { if(x==y) return 1; else return 0; }; }; class CUB:public RECT{ private: int height; public: CUB(int x,int y,int h):RECT(x,y) { height=h; }; int volume() { int volume,ar; ar=area(); volume=ar*height; return volume; }; int area() { int ar1,c1; ar1=area(); c1=peri(); return 2*ar1+c1*height; }; int isSquare() { if(isSquare()==1&&height==x) return 1; else return 0; } };

这段代码定义了两个类，一个是矩形类 RECT，一个是立方体类 CUB，CUB 是 RECT 的子类。RECT 类有两个私有成员 x 和 y，一个构造函数和三个成员函数：area()、peri() 和 isSquare()，其中 area() 和 isSquare() 是虚函数。CUB 类有一个私有成员 height，一个构造函数和三个成员函数：volume()、area() 和 isSquare()，其中 area() 和 isSquare() 是重载了 RECT 类中的虚函数。volume() 函数用于计算立方体的体积，area() 函数用于计算立方体的表面积，isSquare() 函数用于判断立方体是否为正方体。

相关问题

C++设计一个绘图的基类图形类 Graphic，在 Graphic 类中添加计算图形面积函数 CalArea()，图形绕点旋转函数 Rotate(float x, float y)，判断点是否在图形 内部函数 IsInsideGraphic(float x, float y) 。 从 Graphic 派生矩形 Rectangle，圆 Circle，三角形 Triangle 等类，将上述三个函数在子类中重新 设计其功能，设计主函数测试三个类

好的，这里是一个可能的 C++ 实现：

#include <iostream>
#include <cmath>

using namespace std;

class Graphic {
protected:
    float x, y;

public:
    Graphic(float _x, float _y) : x(_x), y(_y) {}

    virtual float CalArea() { return 0; }

    virtual void Rotate(float x, float y) {}

    virtual bool IsInsideGraphic(float x, float y) { return false; }

    virtual ~Graphic() {}
};

class Rectangle : public Graphic {
protected:
    float width, height;

public:
    Rectangle(float _x, float _y, float _width, float _height) : Graphic(_x, _y), width(_width), height(_height) {}

    float CalArea() override { return width * height; }

    void Rotate(float x, float y) override {
        // 绕点旋转
    }

    bool IsInsideGraphic(float x, float y) override {
        if (x >= this->x && x <= this->x + width && y >= this->y && y <= this->y + height) {
            return true;
        } else {
            return false;
        }
    }
};

class Circle : public Graphic {
protected:
    float radius;

public:
    Circle(float _x, float _y, float _radius) : Graphic(_x, _y), radius(_radius) {}

    float CalArea() override { return 3.14 * radius * radius; }

    void Rotate(float x, float y) override {
        // 绕点旋转
    }

    bool IsInsideGraphic(float x, float y) override {
        if ((x - this->x) * (x - this->x) + (y - this->y) * (y - this->y) <= radius * radius) {
            return true;
        } else {
            return false;
        }
    }
};

class Triangle : public Graphic {
protected:
    float x1, y1, x2, y2, x3, y3;

public:
    Triangle(float _x1, float _y1, float _x2, float _y2, float _x3, float _y3) : x1(_x1), y1(_y1), x2(_x2), y2(_y2), x3(_x3), y3(_y3), Graphic((_x1 + _x2 + _x3) / 3, (_y1 + _y2 + _y3) / 3) {}

    float CalArea() override { return abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2); }

    void Rotate(float x, float y) override {
        // 绕点旋转
    }

    bool IsInsideGraphic(float x, float y) override {
        bool b1 = (x - x1) * (y2 - y1) - (y - y1) * (x2 - x1) < 0;
        bool b2 = (x - x2) * (y3 - y2) - (y - y2) * (x3 - x2) < 0;
        bool b3 = (x - x3) * (y1 - y3) - (y - y3) * (x1 - x3) < 0;
        return (b1 == b2) && (b2 == b3);
    }
};

int main() {
    Rectangle rect(0, 0, 5, 4);
    cout << "Rectangle area: " << rect.CalArea() << endl;
    cout << "Is point (3, 2) inside rectangle? " << rect.IsInsideGraphic(3, 2) << endl;

    Circle circ(0, 0, 5);
    cout << "Circle area: " << circ.CalArea() << endl;
    cout << "Is point (3, 2) inside circle? " << circ.IsInsideGraphic(3, 2) << endl;

    Triangle tri(0, 0, 3, 0, 0, 4);
    cout << "Triangle area: " << tri.CalArea() << endl;
    cout << "Is point (2, 2) inside triangle? " << tri.IsInsideGraphic(2, 2) << endl;

    return 0;
}

在这个实现中，我们定义了一个基类 `Graphic`，它包括三个虚函数：`CalArea()`、`Rotate()` 和 `IsInsideGraphic()`，它们分别用于计算图形的面积、绕点旋转和判断点是否在图形内部。然后我们从 `Graphic` 派生了三个子类 `Rectangle`、`Circle` 和 `Triangle`，并分别在子类中重新设计了这三个函数的功能。

在每个子类中，我们重写了这三个函数，实现了具体的操作。例如，在 `Rectangle` 类中，我们计算矩形面积的公式是 `width * height`，而判断点是否在矩形内部的方法是检查点的坐标是否在矩形的左上角和右下角之间。

最后，我们编写了一些测试代码，以确保我们的实现是正确的。

我们需要使用Qt的绘图功能来绘制一个有刻度的平面圆形图，然后在这个图形里添加两条指针，分别表示红线和黄线。下面是一个简单的实现过程： 创建一个自定义的QWidget类，用于绘制图形。 在QWidget类中重载paintEvent函数，使用QPainter类来进行绘制。 在paintEvent函数中，首先绘制一个圆形，然后根据圆形的半径和刻度数，计算出每个刻度的位置，并使用QPainter绘制出刻度线和刻度值。 接着，在圆心位置绘制两条指针，一条为红色，一条为黄色。 在QWidget类中添加鼠标事件处理函数，实现红线指针随鼠标移动而移动，而黄线指针跟随鼠标点击位置移动的功能。 在鼠标移动事件处理函数中，根据鼠标位置计算出红线指针的位置，并重新绘制。 最后，我们需要使用三角函数计算出两条指针的夹角度数。具体实现方法是，首先计算出红线指针与圆心的连线和黄线指针与圆心的连线之间的夹角，然后将两个夹角相减即可得到最终的夹角度数。

好的，以下是一个更完善的代码实现：

在头文件中定义一个自定义的QWidget类，如下所示：

#ifndef CIRCLEWIDGET_H
#define CIRCLEWIDGET_H

#include <QWidget>

class CircleWidget : public QWidget
{
    Q_OBJECT
public:
    explicit CircleWidget(QWidget *parent = nullptr);

protected:
    void paintEvent(QPaintEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void mousePressEvent(QMouseEvent *event) override;

private:
    QPoint m_redPointerPos;
    QPoint m_yellowPointerPos;
    int m_radius;
    int m_scaleCount;

    void drawCircle(QPainter *painter);
    void drawScale(QPainter *painter);
    void drawPointer(QPainter *painter);
};

#endif // CIRCLEWIDGET_H

在实现文件中实现这个自定义的QWidget类，如下所示：

#include "circlewidget.h"
#include <QPainter>
#include <QMouseEvent>
#include <cmath>

CircleWidget::CircleWidget(QWidget *parent) : QWidget(parent)
{
    m_redPointerPos = QPoint(0, 0);
    m_yellowPointerPos = QPoint(0, 0);
    m_radius = 100;
    m_scaleCount = 8;
}

void CircleWidget::paintEvent(QPaintEvent *event)
{
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing, true);

    drawCircle(&painter);
    drawScale(&painter);
    drawPointer(&painter);
}

void CircleWidget::mouseMoveEvent(QMouseEvent *event)
{
    m_redPointerPos = event->pos();
    update();
}

void CircleWidget::mousePressEvent(QMouseEvent *event)
{
    m_yellowPointerPos = event->pos();
    update();
}

void CircleWidget::drawCircle(QPainter *painter)
{
    painter->save();

    painter->setPen(QPen(Qt::black, 2));
    painter->drawEllipse(rect().center(), m_radius, m_radius);

    painter->restore();
}

void CircleWidget::drawScale(QPainter *painter)
{
    painter->save();

    painter->setPen(QPen(Qt::black, 2));
    painter->setFont(QFont("Arial", 8));

    for (int i = 0; i < m_scaleCount; i++)
    {
        double angle = i * 2 * M_PI / m_scaleCount;
        int x1 = rect().center().x() + m_radius * std::sin(angle);
        int y1 = rect().center().y() - m_radius * std::cos(angle);
        int x2 = rect().center().x() + (m_radius - 10) * std::sin(angle);
        int y2 = rect().center().y() - (m_radius - 10) * std::cos(angle);

        painter->drawLine(x1, y1, x2, y2);
        painter->drawText(x2 - 10, y2 + 5, QString::number(i + 1));
    }

    painter->restore();
}

void CircleWidget::drawPointer(QPainter *painter)
{
    painter->save();

    painter->setPen(QPen(Qt::red, 2));
    painter->drawLine(rect().center(), m_redPointerPos);

    painter->setPen(QPen(Qt::yellow, 2));
    painter->drawLine(rect().center(), m_yellowPointerPos);

    double redAngle = std::atan2(m_redPointerPos.y() - rect().center().y(), m_redPointerPos.x() - rect().center().x());
    double yellowAngle = std::atan2(m_yellowPointerPos.y() - rect().center().y(), m_yellowPointerPos.x() - rect().center().x());
    double angle = (yellowAngle - redAngle) * 180 / M_PI;

    painter->setFont(QFont("Arial", 12));
    painter->drawText(rect().center().x() + m_radius + 20, rect().center().y(), QString::number(angle, 'f', 2) + "°");

    painter->restore();
}

在主窗口中使用这个自定义的QWidget类，如下所示：

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "circlewidget.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    CircleWidget *circleWidget = new CircleWidget(this);
    setCentralWidget(circleWidget);
}

MainWindow::~MainWindow()
{
    delete ui;
}

这样，一个有刻度的平面圆形图就完成了。在这个图形里，红线指针可以随鼠标移动而移动，黄线指针可以跟随鼠标点击位置移动。同时，我们还使用三角函数计算出了两条指针的夹角度数，并显示在了图形中。