Qt/C++ - Lektion 027. Polymorphismus in Qt am Beispiel geometrischer Formen in QGraphicsScene

QGraphicsScene, Qt уроки, figure, QGraphicsItem, ооп, Полиморфизм, пример, Qt, square, triangle

Polymorphismus ist eines der Paradigmen von OOP (Object Oriented Programming). Polymorphismus implementiert die Fähigkeit einer Basisklasse, Eigenschaften und Methoden bereitzustellen, deren Implementierung für zukünftige Klassen, die von dieser Klasse erben werden, nicht bekannt ist. Das heißt, die Basisklasse hat in diesem Fall alle notwendigen Methoden, um die zugewiesenen Aufgaben zu implementieren, aber die spezifische Implementierung bestimmter Methoden wird den Nachkommenklassen zugewiesen. Und in der Regel ist die Basisklasse abstrakt, dh es werden keine Objekte daraus erstellt.

Zum Beispiel ist es notwendig, ein Programm zu implementieren, in dem es möglich ist, mehrere geometrische Formen mit der Maus auf die Grafikszene zu zeichnen und die aktuelle Form auszuwählen über die Schaltflächen in der Anwendung. Dazu können Sie mehrere Klassen erstellen, von denen jede alle erforderlichen Funktionen implementiert, und tatsächlich den größten Teil des Codes in jeder Klasse duplizieren, was die Entwicklung kompliziert und verwirrend macht. Oder Sie können eine Basisklasse erstellen, zum Beispiel Figure , die von QGraphicsItem erbt und alle Hauptfunktionen in dieser Klasse implementieren , und erstellen Sie dann bereits drei Klassen, die von dieser Klasse erben, aber nur die Zeichenmethode der Form selbst darin implementieren: Romb, Square, Triangle.

Die folgende Abbildung zeigt die Vererbungslogik für die Figure -Basisklasse. Die Mehrfachvererbung der Klasse Figure wurde auch angewendet, um die Arbeit mit [Signalen und Slots] zu implementieren (https://evileg.com/ru/post/87/).

Projektstruktur - Polymorphismus am Beispiel

• PaintFigure.pro - Projektprofil;
• mainwindow.h - Header-Datei des Hauptanwendungsfensters;
• mainwindow.cpp - Datei mit Quellcodes des Hauptfensters der Anwendung;
• paintscene.h - Header-Datei der Grafikszene;
• paintscene.cpp - Datei mit den Quellcodes der Grafikszene;
• figure.h - Header-Datei der Basisklasse der Figuren;
• figure.cpp - Datei mit Quellcodes der Figurenklasse;
• romb.h - Header-Datei der Rhombus-Klasse;
• romb.cpp - Datei mit Quellcodes der Romb-Klasse;
• square.h - Header-Datei der Square / Rectangle-Klasse;
• square.cpp - Datei mit Quellcodes der Klasse Square / Rectangle;
• Triangle.h - Header-Datei der Triangle-Klasse;
• Triangle.cpp - Datei mit Quellcodes der Triangle-Klasse;
• mainwindow.ui - die Form des Hauptfensters der Anwendung.

mainwindow.ui - PaintFigure.pro - main.cpp

Skizzieren der folgenden Form des Hauptanwendungsfensters im Designer. Und die Dateien PaintFigure.pro und main.cpp bleiben standardmäßig erstellt und werden nicht geändert.

mainwindow.h

In der Header-Datei des Hauptanwendungsfensters müssen Sie eine benutzerdefinierte PaintScene-Grafikszene deklarieren, die für das Zeichnen geometrischer Formen verantwortlich ist. Wir überschreiben auch die Methode resizeEvent(), bei der wir die Größe der Grafikszene in Abhängigkeit von der Größe des Anwendungsfensters neu berechnen. Dies ist ein rein kosmetisches Problem.

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QTimer>
#include <QResizeEvent>

#include "paintscene.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private:
    Ui::MainWindow *ui;
    PaintScene *scene;  // Объявляем кастомную графическую сцену
    QTimer *timer;      /* Определяем таймер для подготовки актуальных размеров
                         * графической сцены
                         * */
private:
    /* Переопределяем событие изменения размера окна
     * для пересчёта размеров графической сцены
     * */
    void resizeEvent(QResizeEvent * event);

private slots:
    // Таймер для изменения размеров сцены при изменении размеров Окна приложения
    void slotTimer();
    void on_pushButton_clicked();       // Включаем отрисовку Ромба
    void on_pushButton_2_clicked();     // Включаем отрисовку Квадрата
    void on_pushButton_3_clicked();     // Включаем отрисовку Треугольника
};

#endif // MAINWINDOW_H

mainwindow.cpp

Im Hauptfenster der Anwendung gibt es drei Schaltflächen, durch die wir die gewünschte Form für das Zeichnen mit der Maus einstellen. Es gibt auch einen Steckplatz für die Bearbeitung der Fenstergröße basierend auf einem Signal vom Neuzeichnungs-Timer.

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

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

    scene = new PaintScene();   // Инициализируем графическую сцену
    ui->graphicsView->setScene(scene);
    ui->graphicsView->setRenderHint(QPainter::Antialiasing);                // Устанавливаем сглаживание
    ui->graphicsView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);   // Отключаем скроллбар по вертикали
    ui->graphicsView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); // Отключаем скроллбар по горизонтали

    timer = new QTimer();       // Инициализируем таймер
    connect(timer, &QTimer::timeout, this, &MainWindow::slotTimer);
    timer->start(100);          // Запускаем таймер
}

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

void MainWindow::slotTimer()
{
    /* Переопределяем размеры графической сцены в зависимости
     * от размеров окна
     * */
    timer->stop();
    scene->setSceneRect(0,0, ui->graphicsView->width() - 20, ui->graphicsView->height() - 20);
}

void MainWindow::resizeEvent(QResizeEvent *event)
{
    timer->start(100);
    QMainWindow::resizeEvent(event);
}

// Ромб
void MainWindow::on_pushButton_clicked()
{
    scene->setTypeFigure(PaintScene::RombType);
}

// Квадрат
void MainWindow::on_pushButton_2_clicked()
{
    scene->setTypeFigure(PaintScene::SquareType);
}

// Треугольник
void MainWindow::on_pushButton_3_clicked()
{
    scene->setTypeFigure(PaintScene::TriangleType);
}

paintscene.h

Header-Datei für eine benutzerdefinierte Grafikszene. In dieser Szene gibt es eine Q_PROPERTY-Eigenschaft, die dafür verantwortlich ist, den aktuellen Shape-Typ für das Rendern zu speichern. Die Typenliste wird mit enum FigureTypes angegeben Es gibt auch eine Deklaration für das tempFigure Objekt, das eine Instanz der Figure Klasse ist. Diese Klasse ist gemäß dem Polymorphismus-Paradigma grundlegend, wird also verwendet, um die auf der Grafikszene gezeichnete Figur zwischenzuspeichern, da alle grundlegenden Methoden zum Einstellen der Größe der Figur mit der Maus in der Basisklasse implementiert sind * Zahl. *

Auch Mausereignismethoden wurden überschrieben. Die Methode mousePressEvent erstellt eine geometrische Form zum Zeichnen, und die Methode mouseMoveEvent zeichnet die Form basierend auf der Position des Mauszeigers neu, bis die Maustaste losgelassen wird.

#ifndef PAINTSCENE_H
#define PAINTSCENE_H

#include <QGraphicsScene>
#include <QGraphicsSceneMouseEvent>
#include "figure.h"

class PaintScene : public QGraphicsScene
{
    Q_OBJECT
    // Свойство текущего типа используемой фигуры
    Q_PROPERTY(int typeFigure
               READ typeFigure WRITE setTypeFigure
               NOTIFY typeFigureChanged)

public:
    explicit PaintScene(QObject *parent = 0);
    ~PaintScene();

    int typeFigure() const;                 // Возвращение текущего типа
    void setTypeFigure(const int type);     // Установка текущего типа

    // Перечисление типов используемых фигур
    enum FigureTypes {
        SquareType,
        RombType,
        TriangleType
    };

signals:
    void typeFigureChanged();               // Сигнал об изменении типа текущей фигуры

private:
    /* Объект для временного хранения рисуемой фигуры
     * Является объектом базового класса для всех трёх типов фигур в примере
     * */
    Figure *tempFigure;
    int m_typeFigure;   // текущий тип фигуры

private:
    // Для рисования используем события мыши
    void mousePressEvent(QGraphicsSceneMouseEvent * event);
    void mouseMoveEvent(QGraphicsSceneMouseEvent *event);

};

#endif // PAINTSCENE_H

paintscene.cpp

#include "paintscene.h"
#include "romb.h"
#include "triangle.h"
#include "square.h"

PaintScene::PaintScene(QObject *parent) : QGraphicsScene(parent)
{

}

PaintScene::~PaintScene()
{

}

int PaintScene::typeFigure() const
{
    return m_typeFigure;
}

void PaintScene::setTypeFigure(const int type)
{
    m_typeFigure = type;
}

void PaintScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    /* Устанавливаем конечную координату положения мыши
     * в текущую отрисовываемую фигуру
     * */
    tempFigure->setEndPoint(event->scenePos());
    /* Обновляем содержимое сцены,
     * необходимо для устранения артефактов при отрисовке фигур
     * */
    this->update(QRectF(0,0,this->width(), this->height()));
}

/* Как только нажали кнопку мыши, создаём фигуру одного из трёх типов
 * и помещаем её на сцену, сохранив указатель на неё в переменной
 * tempFigure
 * */
void PaintScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    switch (m_typeFigure) {
    case SquareType: {
        Square *item = new Square(event->scenePos());
        item->setPos(event->pos());
        tempFigure = item;
        break;
    }
    case RombType: {
        Romb *item = new Romb(event->scenePos());
        item->setPos(event->pos());
        tempFigure = item;
        break;
    }
    case TriangleType: {
        Triangle *item = new Triangle(event->scenePos());
        item->setPos(event->pos());
        tempFigure = item;
        break;
    }
    default:{
        Square *item = new Square(event->scenePos());
        item->setPos(event->pos());
        tempFigure = item;
        break;
    }
    }
    this->addItem(tempFigure);
}

figur.h

Header-Datei der Basisklasse zum Erstellen von geometrischen Formen. Es bietet die grundlegende Funktionalität zum Definieren der Zeichengrenzen einer geometrischen Form, unabhängig davon, welche Form gezeichnet wird, wodurch Polymorphismus bereitgestellt wird. Zum Zeichnen werden zwei Punkte verwendet: Start und Ende . Das Zeichnen beginnt am Startpunkt und ändert seine Position nicht, aber der Endpunkt ist die Koordinate der gegenüberliegenden Ecke des rechteckigen Bereichs, in dem die Figur gezeichnet wird. Abhängig von diesen Punkten werden alle anderen Schlüsselpunkte der Formen neu gezeichnet und dementsprechend die Grenzen dieser Formen.

#ifndef FIGURE_H
#define FIGURE_H

#include <QObject>
#include <QGraphicsItem>
#include <QDebug>

class Figure : public QObject, public QGraphicsItem
{
    Q_OBJECT
    // Свойство стартовой точки, относительно которой отрисовываем фигуру
    Q_PROPERTY(QPointF startPoint
               READ startPoint WRITE setStartPoint
               NOTIFY pointChanged)
    // Свойство конечной точки, до куда отрисовываем фигуру
    Q_PROPERTY(QPointF endPoint
               READ endPoint WRITE setEndPoint
               NOTIFY pointChanged)
public:
    explicit Figure(QPointF point, QObject *parent = 0);
    ~Figure();

    QPointF startPoint() const; // Стартовая точка
    QPointF endPoint() const;   // Конечная точка

    void setStartPoint(const QPointF point);    // Установка стартовой точки
    void setEndPoint(const QPointF point);      // Установка конечной точки

signals:
    void pointChanged();    // Сигнал об изменении точки

private:
    QPointF m_startPoint;   // Стартовая точка
    QPointF m_endPoint;     // Конечная точка

    QRectF boundingRect() const;    // Область, в которой содержится фигура

public slots:
    void updateRomb();     // Слот обновления области, в которой содержится фигура
};

#endif // FIGURE_H

figure.cpp

#include "figure.h"
#include <QPainter>

Figure::Figure(QPointF point, QObject *parent) :
    QObject(parent), QGraphicsItem()
{
    // Устанавливаем стартовую координату для отрисовки фигуры
    this->setStartPoint(mapFromScene(point));
    this->setEndPoint(mapFromScene(point));
    /* Подключаем сигнал изменения координат к слоту запуска обновления содержимого объекта
     * Сигнал и слот присутствуют в базовом классе
     * */
    connect(this, &Figure::pointChanged, this, &Figure::updateRomb);
}

Figure::~Figure()
{

}

QRectF Figure::boundingRect() const
{
    /* Возвращаем область, в которой лежит фигура.
     * Обновляемая область зависит от стартовой точки отрисовки и от конечной точки
     * */
    return QRectF((endPoint().x() > startPoint().x() ? startPoint().x() : endPoint().x()) - 5,
                  (endPoint().y() > startPoint().y() ? startPoint().y() : endPoint().y()) - 5,
                  qAbs(endPoint().x() - startPoint().x()) + 10,
                  qAbs(endPoint().y() - startPoint().y()) + 10);
}

void Figure::updateRomb()
{
    // Вызываем обновление области, в которой лежит фигура
    this->update((endPoint().x() > startPoint().x() ? startPoint().x() : endPoint().x()) - 5,
                 (endPoint().y() > startPoint().y() ? startPoint().y() : endPoint().y()) - 5,
                 qAbs(endPoint().x() - startPoint().x()) + 10,
                 qAbs(endPoint().y() - startPoint().y()) + 10);
}

void Figure::setStartPoint(const QPointF point)
{
    m_startPoint = mapFromScene(point);
    emit pointChanged();
}

void Figure::setEndPoint(const QPointF point)
{
    m_endPoint = mapFromScene(point);
    emit pointChanged();
}

QPointF Figure::startPoint() const
{
    return m_startPoint;
}

QPointF Figure::endPoint() const
{
    return m_endPoint;
}

romb.h

Alles, was Sie in der Header-Datei der Klasse der Figur tun müssen, die wir brauchen, ist, von der Basisklasse Figur zu erben und die paint()-Methode zu überschreiben, die vom Vorfahren des geerbt wird Figurenklasse, dh von QGraphicsItem Diese Methode implementiert die Rendering-Logik für diese geometrische Form.

#ifndef ROMB_H
#define ROMB_H

#include <QObject>
#include <QGraphicsItem>
#include "figure.h"

/* Наследуемся от класса Figure,
 * в котором реализован общий для всех фигур функционал
 * */
class Romb : public Figure
{
    Q_OBJECT

public:
    explicit Romb(QPointF point, QObject *parent = 0);
    ~Romb();

private:
    // Для Ромба реализуем только саму отрисовку
    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
};

#endif // ROMB_H

romb.cpp

#include "romb.h"
#include <QPainter>

Romb::Romb(QPointF point, QObject *parent) :
    Figure(point,parent)
{
    Q_UNUSED(point)
}

Romb::~Romb()
{

}

// Реализуем метод отрисовки
void Romb::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    painter->setPen(QPen(Qt::black, 2));

    QPolygonF polygon;

    polygon << QPointF(startPoint().x() + (endPoint().x() > startPoint().x() ? + 1 : - 1)*
                           abs((endPoint().x() - startPoint().x())/2), startPoint().y())
                << QPointF(endPoint().x(), startPoint().y() + (endPoint().y() > startPoint().y() ? + 1 : - 1)*
                           abs((endPoint().y() - startPoint().y())/2))
                << QPointF(startPoint().x() + (endPoint().x() > startPoint().x() ? + 1 : - 1)*
                           abs((endPoint().x() - startPoint().x())/2), endPoint().y())
                << QPointF(startPoint().x(), startPoint().y() + (endPoint().y() > startPoint().y() ? + 1 : - 1)*
                           abs((endPoint().y() - startPoint().y())/2));

    painter->drawPolygon(polygon);

    Q_UNUSED(option)
    Q_UNUSED(widget)
}

Die Dreiecks- und Quadratklassen

Die Struktur der Klassendatendateien ähnelt der Klasse Romb , der einzige Unterschied besteht in der Logik der Implementierung des Zeichnens der Figur.

Ergebnis

Durch die geschickte Anwendung des Paradigmas Polymorphismus können Sie die Menge des Programmcodes erheblich reduzieren und die Häufigkeit seiner Wiederverwendung erhöhen, insbesondere wenn viele ähnliche Objekte vorhanden sind, wie z. ist impliziert.

Eine Demonstration der resultierenden Anwendung wird im Video-Tutorial gezeigt.

Link zum Download des Projekts in einem Zip-Archiv: PaintFigure

Videoanleitung