Signal-Slot-Konzept

aus Wikipedia, der freien Enzyklopädie

Signale und Slots sind ein Konzept aus der Programmierung. Sie realisieren einen ereignisgesteuerten Programmfluss beziehungsweise eine ereignisgesteuerte Kommunikation zwischen Programmobjekten. Ursprünglich geprägt wurde der Begriff durch die Bibliothek Qt, wird aber mittlerweile auch von einer Reihe anderer Programmbibliotheken genutzt. Das Konzept lässt sich als spezielle Form des Beobachterprinzips betrachten und stellt eine Alternative zu den häufiger verwendeten Rückruffunktionen (engl. Callbacks) dar.

Das Signal-Slot-Konzept ist insbesondere in der Programmiersprache C++ verbreitet. Hier kann durch konzeptionell einfachere Rückrufmechanismen oftmals keine ausreichende Flexibilität erreicht werden, ohne dabei das Paradigma der starken Typsicherheit zu verletzen.

Inhaltsverzeichnis 1 Überblick 2 Vor- und Nachteile 3 Beispiele mit Qt 3.1 Vordefinierte Signale und Slots 3.2 Selbsterstellte Signale und Slots 4 Weblinks

[Bearbeiten] Überblick

Signale sind „Botschaften“, die bei Eintreten eines Ereignisses abgegeben werden (emittiert). Ein Slot ist prinzipiell eine normale Funktion, die auf eine bestimmte Weise mit einem Signal verknüpft werden kann. Slots und Signale „wissen“ zunächst nichts voneinander. Erst durch die Verknüpfung entsteht die eigentliche Programmlogik: Jedes Mal, wenn das Signal abgegeben wird, wird anschließend der verbundene Slot aufgerufen. Ein Signal kann auch mit mehreren Slots verbunden werden, so dass bei Eintreten eines Ereignisses mehrere Funktionen aufgerufen werden. Ebenso kann ein Slot mit mehreren Signalen verbunden werden, wodurch die selbe Funktion bei Auftreten unterschiedlicher Ereignisse aufgerufen wird.

Besonders häufig finden sich Signal-Slot-Mechanismen in Programmbibliotheken zur Erstellung graphischer Benutzeroberflächen. Hier erfüllen sie die Aufgabe, Objekte, insbesondere Widgets miteinander zu verknüpfen und so die Kontrollelemente der Oberfläche wie Schaltflächen und Listenfelder mit Funktionalität zu füllen.

Die C++-Bibliothek Qt ist wohl das bekannteste Beispiel für die Verwendung von Signalen und Slots. Realisiert werden sie dort durch neu in C++ eingeführte Schlüsselwörter wie signal, slot und emit, die beim Kompilieren von dem Programm „Meta Object Compiler“ (moc) in einer Vorkompilierung aufgelöst werden.

Weiterhin gibt es verschiedene Programmbibliotheken, welche Signal-Slot-Mechanismen mittels generischer Programmierung (Templates) und Funktoren realisieren, wie die Bibliothek Boost oder libsigc++, eine Signal-Slot-Bibliothek welche beispielsweise von der gtkmm-Bibliothek verwendet wird.

[Bearbeiten] Vor- und Nachteile

Signale und Slots sind bei Einhaltung der Typsicherheit einfacher und flexibler zu verwenden als Callbacks, allerdings geht dies wegen des Overheads geringfügig auf Kosten der Geschwindigkeit. Der Unterschied ist jedoch in der Praxis kaum relevant.

Die Syntax von Signalen und Slots kann oftmals einfacher erscheinen als die für Callbacks beziehungsweise Methodenzeiger notwendige.

[Bearbeiten] Beispiele mit Qt

[Bearbeiten] Vordefinierte Signale und Slots

Bei Qt verfügen viele mitgelieferte Klassen bereits über diverse vordefinierte Signale und Slots, die man verwenden kann. Im folgenden Beispiel soll gezeigt werden, wie man diese benutzen kann, um Basisfunktionalitäten in ein GUI zu programmieren.

MainWindow::MainWindow(QWidget *parent, Qt::WFlags flags)
    :   QMainWindow(parent, flags)
{
        ui.setupUi(this);

        QWidget* w = new QWidget();
        QCheckBox* c = new QCheckBox("Text", this);

        connect(c, SIGNAL(clicked(bool)), w, SLOT(setVisible(bool)));
}

Zu sehen ist der Konstruktor des Hauptfensters. Die Zeile ui.setupUi(this); dient zur Generierung des UIs und sei hier nicht näher erläutert (siehe Qt-Dokumentation). Die folgenden zwei Zeilen dienen der Erstellung eines leeren Fenster-Widgets w und eines mit „Text“ beschrifteten Checkbox-Widgets c, das im Hauptfenster erscheint.

Anschließend wird mittels connect die Verbindung beider Objekte erreicht. Als Signal dient das clicked-Signal der Checkbox, das dann abgegeben wird, wenn der Benutzer die Box anklickt. Der Status nach dem Anklicken, also ob die Box angekreuzt ist oder nicht, wird als boolescher Parameter mit übergeben. setVisible ist ein Slot, über den bei allen Widgets gesteuert werden kann, ob es sichtbar ist oder nicht. signal und slots sind Qt-eigene Schlüsselwörter, um Signale und Slots als solche zu kennzeichnen.

Nach dem Start des Programmes würde nun das zweite Fenster bei jedem Klick auf die Checkbox jeweils erscheinen oder verschwinden.

[Bearbeiten] Selbsterstellte Signale und Slots

Eine einfache Klasse, die einen Wert speichert und zwei Funktionen anbietet um diesen zu verändern oder auszulesen:

class Zahl
{
private:
    int wert;
   
public:
    Zahl() : wert(0) {}

    int wert() const { return wert; }

    void setzeWert(int wert)
    {
        if(wert!=this->wert)
            this->wert=wert;
    }
};

Die selbe Klasse mit Signals und Slots:

#include <QObject>

class Zahl : public QObject
{
    Q_OBJECT

private:
    int wert;
   
public:
    Zahl() : wert(0) {}

    int wert() const { return wert; }

public slots:
    void setzeWert(int wert)
    {
        if(wert!=this->wert)
        {
            this->wert=wert;
            emit wertGeaendert(wert);
        }
    }
 
signals:
    void wertGeaendert(int neuerWert);
};

Verwendung der Klasse in einem Programm:

Zahl a, b;           // a.wert() == 0, b.wert() == 0

a.setzeWert(5);      // a.wert() == 5, b.wert() == 0
b.setzeWert(48);     // a.wert() == 5, b.wert() == 48

QObject::connect(&a, SIGNAL(wertGeaendert(int)), &b, SLOT(setzeWert(int)));

a.setzeWert(12);     // a.wert() == 12, b.wert() == 12
b.setzeWert(23);     // a.wert() == 12, b.wert() == 23

[Bearbeiten] Weblinks

• Qt-Dokumentation zu Signalen und Slots (engl.)
• libsigc++ Homepage (engl.)
• boost.signals (engl.)