imported>Siegbert v2: Boost Weblinks sind oppelt vorhanden; es reicht einmalige Erwähnung unter Implementierungen

2026-04-04T14:40:30Z

Boost Weblinks sind oppelt vorhanden; es reicht einmalige Erwähnung unter Implementierungen

Neue Seite

'''Signale und Slots''' sind ein Konzept aus der [[Programmierung]]. Sie realisieren einen [[Ereignis (Programmierung)|ereignis]]gesteuerten [[Programmfluss]] beziehungsweise eine ereignisgesteuerte Kommunikation zwischen [[Objekt (Programmierung)|Programmobjekten]]. Ursprünglich geprägt wurde der Begriff durch die [[Qt (Bibliothek)|Bibliothek Qt]], wird aber mittlerweile auch von einer Reihe anderer [[Programmbibliothek]]en genutzt. Das Konzept lässt sich als Anwendung des Entwurfsmusters [[Beobachter (Entwurfsmuster)|''Beobachter'']] betrachten. Es wird als Alternative zu direkten [[Rückruffunktion]]en (engl. ''Callbacks'') eingesetzt, wenn sich diese als zu unflexibel oder nicht [[Starke Typisierung|typsicher]] erweisen (z. B. bei der Entwicklung komplexer [[Anwendungssoftware|grafischer Anwendungen]]).

== Überblick ==

''Signale'' sind „Botschaften“, die bei Eintreten eines Ereignisses abgegeben werden (''emittiert''). Ein ''Slot'' ist prinzipiell eine normale [[Unterprogramm|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 [[Grafische Benutzeroberfläche|grafischer Benutzeroberflächen]]. Hier erfüllen sie die Aufgabe, [[Objekt (Programmierung)|Objekte]], insbesondere [[Steuerelement|Steuerelemente]] miteinander zu verknüpfen und so die Kontrollelemente der Oberfläche wie [[Schaltfläche]]n und [[Listenfeld]]er 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 [[generische Programmierung|generischer Programmierung]] ([[Template (C++)|Template]]s) und [[Funktor (Informatik)|Funktor]]en realisieren, wie die Bibliothek [[Boost (C++-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 (Bibliothek)|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.

<syntaxhighlight lang="cpp">#include <QCheckBox>
#include <QObject>
#include <QMainWindow>
#include <QWidget>
#include <Qt>

class MainWindow: QMainWindow {
private:
QWidget w;
QCheckBox c("Fenster sichtbar", this);

public:
MainWindow(QWidget *parent, Qt::WindowFlags flags): QMainWindow(parent, flags) {
ui.setupUi(this);
connect(&c, SIGNAL(clicked(bool)), &w, SLOT(setVisible(bool)));
}
};</syntaxhighlight>

Zu sehen ist der [[Konstruktor]] des Hauptfensters. Die Zeile <code>ui.setupUi(this);</code> 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 (Computer)|Fenster]]-Widgets <code>w</code> und eines mit dem Text „Fenster sichtbar“ beschrifteten [[Checkbox]]-Widgets <code>c</code>, das im Hauptfenster erscheint.

Anschließend wird mittels <code>connect</code> die Verbindung beider Objekte erreicht. Als Signal dient das <code>clicked</code>-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 [[Boolesche Variable|boolescher Parameter]] mit übergeben. <code>setVisible</code> ist ein Slot, über den bei allen Widgets gesteuert werden kann, ob es sichtbar ist oder nicht. <code>SIGNAL</code> und <code>SLOT</code> sind Qt-eigene Schlüsselwörter, um Signale und Slots als solche zu kennzeichnen; sie werden vom [[Qt (Bibliothek)#Meta-Object-Compiler|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 <code>Zahl</code> speichert einen Wert und hat zwei Funktionen, um diesen Wert zu verändern oder auszulesen:

<syntaxhighlight lang="cpp">
// Number.h

#include <QObject>

class Number: QObject {
Q_OBJECT

private:
int value;

public:
Number(): value(0) { }

int getValue() const {
return value;
}

slots:
void setValue(int value) {
if (value != this->value) {
this->value = value;
emit onChange(value);
}
}

signals:
void onChange(int newValue);
};
</syntaxhighlight>

<syntaxhighlight lang="cpp">
// main.cpp

#include <Number.h>
#include <QObject>

int main(void) {
Number a, b; // a.getValue() == 0, b.getValue() == 0

a.setValue(5); // a.getValue() == 5, b.getValue() == 0
b.setValue(48); // a.getValue() == 5, b.getValue() == 48

QObject::connect(&a, SIGNAL(onChange(int)), &b, SLOT(setValue(int)));

a.setValue(12); // a.getValue() == 12, b.getValue() == 12
b.setValue(23); // a.getValue() == 12, b.getValue() == 23
}
</syntaxhighlight>

Die Klasse <code>Number</code> wird aus der Klasse <code>QObject</code> abgeleitet, die die notwendigen Funktionen für die Verwendung von Signalen und Slots enthält. <code>Q_OBJECT</code> ist ein Makro, das in allen Klassen enthalten sein muss, in denen Signale oder Slots deklariert werden. Die Funktion <code>setValue()</code> ist als Slot deklariert, d. h., sie kann mit Signalen wie <code>onChange()</code> verbunden werden. Der Meta-Object-Compiler erzeugt aus dieser Deklaration der Klasse <code>Number</code> 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 <code>emit</code> 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 <code>connect()</code> (siehe zum besseren Verständnis Weblinks: Qt-Dokumentation zu Signals und Slots) und kann auch wieder aufgehoben werden. In <code>connect()</code> 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.

In dem Beispiel erhalten die Instanzen <code>a</code> und <code>b</code> bei der Initialisierung den Wert 0. Mit <code>a.setValue(5);</code> und <code>b.setValue(48);</code> wird der Wert von <code>a</code> und <code>b</code> geändert und jeweils das Signal <code>onChange()</code> aktiviert. Da bei diesen ersten Aufrufen von <code>setValue()</code> noch kein Slot mit den Signalen beider Instanzen verbunden ist, bewirkt die Aktivierung des Signals nichts. Erst nach dem Verbinden des Signals <code>a.onChange()</code> mit dem Slot <code>b.setValue()</code> mittels <code>connect()</code> wird bei einer Änderung des Wertes von <code>a</code> auch die Funktion <code>b.setValue()</code> aufgerufen und damit der Wert von <code>b</code> geändert. Der letzte Aufruf <code>b.setValue(23)</code> hat keine Auswirkung auf <code>a</code>, da mit dem Signal <code>b.onChange()</code> kein Slot verbunden ist.

== Implementierungen ==

* das ''Signals und Slots'' - Modell von [[Qt (Bibliothek)|Qt]], einer C++ - Klassenbibliothek (zur plattformübergreifenden Oberflächenprogrammierung)
* C++: [https://www.boost.org/doc/libs/latest/doc/html/signals2.html Boost.Signals2] bzw. [https://www.boost.org/doc/libs/1_68_0/doc/html/signals.html Boost.Signals] (veraltet; verfügbar bis Version 1.68)
* C++: [[libsigc++]] - Template-basiert.
* C++: [http://sigslot.sourceforge.net/ sigslot]
* C++: [http://xlobject.sourceforge.net/ XLObject] - Template-basiert, Qt-orientiert.
* C++: [http://github.com/pbhogan/Signals Signals]
* C: [http://www.monkey.org/~provos/libevent/ libevent] - multi-threaded, plattformübergreifend.
* C: [http://software.schmorp.de/pkg/libev.html libev] - minimalistische Alternative zu libevent.
* [[JavaScript]]: [https://github.com/petsel/javascript-api-extensions/blob/master/core/SignalsAndSlots/EventTargetProvider.js EventTargetProvider.js], Sprachkern-basiert, typsicher.
* PHP: [http://flow.typo3.org/ TYPO3 Flow] - application framework mit Signal-Slot-Unterstützung
* Java: [https://github.com/retuxx/sig4j sig4j] - multi-threaded, typsicher, basiert auf der in Java 8 eingeführten [https://docs.oracle.com/javase/8/docs/api/java/lang/FunctionalInterface.html FunctionalInterface] Annotation.

== Weblinks ==
* [https://doc.qt.io/qt-5/signalsandslots.html Qt-Dokumentation zu Signals und Slots] (engl.)
* {{Webarchiv | url=http://scottcollins.net/articles/a-deeper-look-at-signals-and-slots.html | wayback=20070703100120 | text=A Deeper Look at Signals and Slots}} (engl.)

[[Kategorie:Programmierung]]

Signal-Slot-Konzept - Versionsgeschichte

imported>Siegbert v2: Boost Weblinks sind oppelt vorhanden; es reicht einmalige Erwähnung unter Implementierungen