Signal-Slot-Konzept

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 Anwendung des Entwurfsmusters Beobachter betrachten. Es wird als Alternative zu direkten Rückruffunktionen (engl. Callbacks) eingesetzt, wenn sich diese als zu unflexibel oder nicht typsicher erweisen (z.B. bei der Entwicklung komplexer grafischer Anwendungen).

Ü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 dieselbe Funktion bei Auftreten unterschiedlicher Ereignisse aufgerufen wird.

Besonders häufig finden sich Signal-Slot-Mechanismen in Programmbibliotheken zur Erstellung grafischer Benutzeroberflächen. Hier erfüllen sie die Aufgabe, Objekte, insbesondere Steuerelemente 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, bevor sie durch den C++-Präprozessor entfernt werden, dem Qt-eigenen „Meta Object Compiler“ (moc) bei der Erstellung weiteren C++-Codes helfen.

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.

Vorteile

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.

Beispiele mit Qt

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("Fenster sichtbar", 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 der Benutzeroberfläche 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 dem Text „Fenster sichtbar“ 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 SLOT sind Qt-eigene Schlüsselwörter, um Signale und Slots als solche zu kennzeichnen; sie werden vom Meta Object Compiler erkannt.

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

Beispiel für selbsterstellte Signale und Slots

An einer einfachen Klasse wird gezeigt, wie Signale und Slots in der Qt-Bibliothek funktionieren. Die Klasse Zahl speichert einen Wert und hat zwei Funktionen, um diesen Wert zu verändern oder auszulesen:

// Zahl.h
 
#include <QObject>
 
class Zahl : public QObject 
{
    Q_OBJECT
 
private:
    int wert;
 
public:
    Zahl() : wert(0)
    {
    }
 
    int wertLesen() const { return wert; }
 
public slots:
    void setzeWert(int wert)
    {
        if (wert != this->wert)
        {
            this->wert = wert;
            emit wertGeaendert(wert);
        }
    }
 
signals:
    void wertGeaendert(int neuerWert);
};

// main.cpp
 
#include <Zahl.h>
 
int main(void)
{
  Zahl a, b;
  // Nach der Initialisierung gäbe a.wertLesen() ebenso wie b.wertLesen() die Zahl 0 zurück.
 
  a.setzeWert(5);
  // a.wertLesen() ist nun 5, b.wertLesen() ist jedoch weiterhin 0. (Da noch kein Signal verbunden!)
 
  b.setzeWert(48);
  // Nun gäbe b.wertLesen() die Zahl 48 zurück.
 
  QObject::connect(&a, SIGNAL( wertGeaendert(int) ), &b, SLOT( setzeWert(int) ) );
  // Erst ab hier ist das Signal wertGeaendert von a mit dem Slot setzeWert von b verbunden
  //  weshalb ab sofort das setzen des Wertes von a Auswirkungen auf den Wert von b hat.
 
  a.setzeWert(12);
  // Jetzt würde sowohl a.wertLesen() als auch b.wertLesen() die Zahl 12 zurückgeben.
 
  b.setzeWert(23);
  // a.wertLesen() gäbe weiterhin 12 zurück, b.wertLesen() jedoch 23.
}

Die Klasse Zahl wird aus der Klasse QObject abgeleitet, die die notwendigen Funktionen für die Verwendung von Signalen und Slots enthält. Q_OBJECT ist ein Makro, das in allen Klassen enthalten sein muss, in denen Signale oder Slots deklariert werden. Die Funktion setzeWert() ist als Slot deklariert, d. h. sie kann mit Signalen wie wertGeaendert() verbunden werden. Der Meta Object Compiler erzeugt aus dieser Deklaration der Klasse Zahl zusätzlichen Quellcode, der Funktionen zur Verwendung der neu deklarierten Signale und Slots enthält. Für die Signale müssen vom Programmierer keine Funktionen mehr implementiert werden.

Wenn Signale mit emit aktiviert werden, werden alle Slots, die während der Laufzeit des Programms mit diesem Signal verbunden wurden, aufgerufen. Diese Verbindung von Signalen und Slots geschieht mit connect() und kann auch wieder aufgehoben werden. In connect() wird auch geprüft, ob die angegebenen Signale und Slots existieren und ob die Typen der Parameter übereinstimmen. Die verbundenen Signale und Slots (jeweils die Instanz einer Klasse und eine Funktion) werden in einer Liste verwaltet. Einem Signal können beliebig viele Slots zugeordnet werden.

Implementierungen

• das Signals und Slots - Modell von Qt, einer C++ - Klassenbibliothek (zur plattformübergreifenden Oberflächenprogrammierung)
• C++: Boost.Signals bzw. Boost.Signals2
• C++: libsigc++ - Template-basiert.
• C++: sigslot
• C++: XLObject - Template-basiert, Qt-orientiert.
• C++: Signals
• C: libevent - multi-threaded, plattformübergreifend.
• C: libev - minimalistische Alternative zu libevent.
• JavaScript: EventTargetProvider.js, Sprachkern-basiert, typsicher.
• PHP: FLOW3 - application framework mit Signal-Slot-Unterstützung

Weblinks

• Qt-Dokumentation zu Signals und Slots (engl.)
• boost.signals bzw. Boost.Signals2 (engl.)
• A Deeper Look at Signals and Slots (engl.)