Qt/C++ - Lektion 024. Signale und Slot in Qt5

сигналы слоты Qt, сигналы Qt, слоты Qt, Qt5, слот, пример, сигнал, сигналы слоты Qt5, example

Signale und Slots werden für die Kommunikation zwischen Objekten in Qt verwendet. Der Signal- und Slot-Mechanismus ist ein zentrales Feature in Qt und unterscheidet Qt wahrscheinlich in seiner Funktionalität von anderen Frameworks. Signale und Slots werden ermöglicht durch das meta-object system Qt.

Einführung

Bei der GUI-Programmierung möchten wir oft, dass die anderen Widgets benachrichtigt werden, wenn sich eines der Widgets ändert. Im Allgemeinen möchten wir, dass Objekte miteinander interagieren können. Wenn der Benutzer beispielsweise die Schaltfläche Schließen gedrückt hat, möchten wir wahrscheinlich, dass das Fenster Objekt close () aufruft.

Andere Entwicklungstools bieten ähnliche Funktionen mit Rückruf. callback ist ein Zeiger auf eine Funktion, und wenn Sie eine Funktion ausführen möchten, die Sie über ein Ereignis benachrichtigt, übergeben Sie einen Zeiger an eine andere Funktion, dh callback. Die laufende Funktion ruft callback . auf dann ggf. Es gibt zwar Frameworks, die Rückruffunktionen erfolgreich verwenden, Rückruf ist jedoch eine nicht intuitive Methode, die Probleme verursachen kann, um sicherzustellen, dass die zurückgegebenen Argumente korrekt sind.

Signale und Slots

Qt verwendet eine alternative Technik, das heißt, es verwendet Slots und Signale. Das Signal wird ausgeführt, wenn ein bestimmtes Ereignis eintritt. Qt-Widgets haben viele vordefinierte Signale, aber wir können immer vom Widget erben und unsere eigenen Signale dafür definieren. Ein Slot ist eine Funktion, die als Reaktion auf ein bestimmtes Signal aufgerufen wird. Qt-Widgets haben auch viele vordefinierte Slots, aber es ist gängige Praxis, von Widgets zu erben und eigene Slots hinzuzufügen, damit Sie alle Signale verarbeiten können, an denen Sie interessiert sind.

Signale und Slots in Qt Signale und Slots sind typsichere Mechanismen. Die Signatur des Signals muss mit der Signatur des empfangenden Slots übereinstimmen (obwohl der Slot tatsächlich eine Signatur haben kann, die kürzer als das Signal ist, akzeptiert der Slot das Signal, da er die zusätzlichen Argumente ignoriert). Da die Signaturen kompatibel sind, kann der Compiler helfen, Inkonsistenzen bei der Verwendung einer zeigerbasierten Syntax zu erkennen. Mit der auf den Makros SIGNAL und SLOT basierenden Syntax ist es hingegen nur im Laufzeitprozess möglich, den Typ-Mismatch zu ermitteln. Signale und Slots sind lose gekoppelt: Die Klasse, die das Signal aufruft, kennt nur den Slot, der das Signal empfängt. Der Signal- und Slot-Mechanismus in Qt wird bereitgestellt, wenn Sie ein Signal an einen Slot anschließen, der zum richtigen Zeitpunkt mit den Signalparametern aufgerufen wird. Signale und Slots können mehrere Argumente und Typen haben. Und sie sind absolut typsicher.

Alle Klassen, die von QObject oder seinen Unterklassen (wie QWidget) kann Signale und Slots enthalten. Signale werden von Objekten ausgelöst, die ihren Zustand ändern, was für andere Objekte von Interesse sein kann. Dies ist alles, was das Objekt für die Kommunikation tut. Und dem Objekt ist es egal, wer die Signale empfängt, die es aussendet. Dies ist eine faire Kapselung von Informationen und stellt sicher, dass das Objekt als Softwarekomponente verwendet werden kann.

Slots können zum Empfangen von Signalen verwendet werden, sind aber auch gängige Funktionen. So wie das Objekt nicht weiß, was sein Signal empfangen hat, weiß der Slot nicht, welches Signal an ihm angeschlossen ist. Dies bietet echte Unabhängigkeit für die Komponenten, die mit Qt gebaut werden können.

Sie können mehrere Signale an einen Steckplatz anschließen, oder ein Signal kann an mehrere Steckplätze angeschlossen werden. Und es ist sogar möglich, ein Signal direkt mit einem anderen Signal zu verbinden. (Dies löst einen zweiten Piepton aus, wenn der erste aufgerufen wurde)

Signale und Slots bilden zusammen einen leistungsstarken Mechanismus zur Komponentenprogrammierung.

Signale

Signale werden von einem Objekt ausgesendet, wenn sich sein interner Zustand in eine bestimmte Richtung geändert hat, die für andere Objekte von Interesse sein kann. Signale sind öffentlich zugängliche Funktionen und können überall aufgerufen werden, es wird jedoch empfohlen, sie nur in der Klasse aufzurufen, in der sie definiert wurden und auch in deren Unterklassen.

Beim Auslösen eines Signals wird der damit verbundene Slot in der Regel sofort ausgeführt, wie eine normale Funktion. Dies liegt daran, dass der Signal- und Slot-Mechanismus unabhängig von Schleifen in der GUI ist. Die Ausführung des Codes sollte mit der Direktive emit aufgerufen werden, die alle Slots aufruft. In Situationen, in denen Verbindungswarteschlangen verwendet werden, löst der Code das Signal aus und die Slots werden etwas später ausgeführt.

Wenn mehrere Slots mit dem gleichen Signal verbunden sind, werden die Slots beim Aufruf des Signals nacheinander in der Reihenfolge aufgerufen, in der sie verbunden sind.

Signale werden automatisch in moc generiert und müssen weder in der .cpp-Datei definiert werden, noch geben sie jemals ein Ergebnis zurück.

• Hinweis: * Unserer Erfahrung nach werden Signale und Slots häufiger verwendet, wenn keine speziellen Typen verwendet werden. Wenn QScrollBar :: valueChanged () ein spezieller Typ wie der hypothetische QScrollBar :: Range ist, kann er nur mit dem Slot verbunden werden speziell für [QScrollBar] entwickelt (http://doc.qt.io/qt-5/qscrollbar.html). Das Verbinden verschiedener Widgets ist möglicherweise nicht möglich.

Schlüssel

Ein Slot wird aufgerufen, wenn ein daran angeschlossenes Signal getriggert wurde. Slots sind eine normale C++-Funktion und können aufgerufen werden; sie sind nur dadurch besonders, dass Signale mit ihnen verbunden sind.

Slots können auch wie normale Funktionen ausgeführt werden, sie gehorchen beim direkten Aufruf den üblichen C++-Regeln. Als Slots können sie jedoch von anderen Komponenten unabhängig von ihrer Zugriffsebene über eine Signal-to-Slot-Verbindung aufgerufen werden. Dies bedeutet, dass ein Signal von einer der Klassen ausgesendet wird und an einen privaten Slot übergeben werden kann, der von dieser nicht verwandten Klasse aufgerufen wird.

Sie können Slots auch als virtuell definieren, was wir in der Praxis sehr nützlich finden.

Im Vergleich zu Callback sind Signale und Slots aufgrund der Flexibilität, die sie bieten, etwas langsamer, obwohl die Unterschiede in einer realen Anwendung geringfügig sind. Grundsätzlich ist das Aufrufen eines Signals, das mit mehreren Slots verbunden ist, etwa zehnmal langsamer als das Aufrufen einer nicht virtuellen Funktion. Dies ist ein Overhead, der das Auffinden des Verbindungsobjekts durch Iterieren über alle Slots und Signale und Vergleichen der Signaturen erfordert, um die Slotfunktion sicher aufzurufen. Während zehn nicht-virtuelle Funktionen mit weniger Overhead aufgerufen werden als mehrere Neu- und Löschoperationen. Wenn Sie im Hintergrund eine String-, Vektor- oder Listenoperation ausführen, die neue und Löschoperationen erfordert, ist der Signal- und Slot-Overhead im Vergleich zu den vollen Kosten eines Funktionsaufrufs sehr gering. Dies ist der Fall, wenn Sie einen Systemaufruf an einen Slot tätigen oder mehr als zehn Funktionen indirekt aufrufen. Die Einfachheit und Flexibilität des Signal- und Slot-Mechanismus ist ein unwichtiger Overhead, den Ihre Benutzer nicht bemerken werden.

Beachten Sie, dass andere Bibliotheken Variablen namens Signale und Slots definieren und beim Kompilieren einer Qt-basierten Anwendung Fehler und Warnungen ausgeben können. Die Lösung dieser Probleme ist die Verwendung der #undef-Direktive für den Präprozessor.

Anschließen eines Signals an einen Steckplatz

Vor der fünften Version von Qt wurde das Verbinden eines Signals mit einem Slot mithilfe von Makros geschrieben, während in Version fünf eine zeigerbasierte Notation verwendet wurde.

Aufnahme mit Makros:

connect(button, SIGNAL(clicked()), this, SLOT(slotButton()));

Zeigerbasierte Notation:

connect(button, &QPushButton::clicked, this, &MainWindow::slotButton);

Der Vorteil der zweiten Option besteht darin, dass die Nichtübereinstimmung von Signaturen und der falsche Name des Slots oder Signals bereits während der Kompilierung des Projekts und nicht während des Testens der Anwendung festgestellt werden können.

Beispiel für die Verwendung von Signalen und Slots

Als Beispiel für die Verwendung von Signalen und Slots wurde ein Projekt erstellt, bei dem das Hauptfenster drei Schaltflächen enthält, an die jeweils ein Steckplatz angeschlossen ist und diese Steckplätze das Signal an einen einzelnen Steckplatz mit der Nummer der gedrückten Schaltfläche übertragen.

Projektstruktur

Projektstruktur Der etablierten Unterrichtstradition entsprechend füge ich die Projektstruktur bei, die absolut trivial ist und bis zur Schande vorschwebt, dass ich die darin enthaltenen Klassen und Dateien nicht einmal beschreibe.

mainwindow.h

Die Aktion ist also wie folgt: drei Buttons - drei Slots, ein Signal für alle drei Buttons, das an die Button-Slots gesendet wird und die Button-Nummer an einen gemeinsamen Slot überträgt, der eine Nachricht mit der Button-Nummer ausgibt.

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QPushButton>
#include <QMessageBox>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

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

signals:
    void signalFromButton(int buttonID);    // Сигнал для передачи номер нажатой кнопки

private:
    Ui::MainWindow *ui;

private slots:
    void slotButton1();     // Слоты-обработчики нажатий кнопок
    void slotButton2();
    void slotButton3();

    // Слоты вызывающий сообщение с номеро нажатой кнопки
    void slotMessage(int buttonID);
};

#endif // MAINWINDOW_H

mainwindow.cpp

Und in dieser Datei ist die in den vorherigen Absätzen beschriebene Logik konfiguriert. Überprüfen Sie einfach den Programmcode und fahren Sie mit dem Ansehen des Videos fort. Es zeigt den gesamten Prozess im Detail, demonstriert die Anwendung und zeigt auch, was passiert, wenn Sie Code mit verschiedenen Fehlern schreiben.

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

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

    /* Объявляем и инициализируем кнопки
     * */
    QPushButton *but_1 = new QPushButton(this);
    QPushButton *but_2 = new QPushButton(this);
    QPushButton *but_3 = new QPushButton(this);

    /* Устанавливаем номера кнопок
     * */
    but_1->setText("1");
    but_2->setText("2");
    but_3->setText("3");

    /* Добавляем кнопки на слой с вертикальной ориентацией
     * */
    ui->verticalLayout->addWidget(but_1);
    ui->verticalLayout->addWidget(but_2);
    ui->verticalLayout->addWidget(but_3);

    /* Подключаем к кнопкам индивидуальные слоты
     * */
    connect(but_1, SIGNAL(clicked()), this, SLOT(slotButton1()));
    connect(but_2, SIGNAL(clicked()), this, SLOT(slotButton2()));
    connect(but_3, SIGNAL(clicked()), this, SLOT(slotButton3()));

    /* Подключаем сигнал с передачей номера кнопки к слоту вывода сообщения
     * */
    connect(this, &MainWindow::signalFromButton, this, &MainWindow::slotMessage);
}

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

/* Слоты для обработки нажатия кнопок
 * */
void MainWindow::slotButton1()
{
    emit signalFromButton(1);
}

void MainWindow::slotButton2()
{
    emit signalFromButton(2);
}

void MainWindow::slotButton3()
{
    emit signalFromButton(3);
}

/* Слоты вывода сообщения
 * */
void MainWindow::slotMessage(int buttonID)
{
    QMessageBox::information(this,
                             "Уведомление о нажатой кнопке",
                             "Нажата кнопка под номером " + QString::number(buttonID));
}

Videoanleitung