Event-System

Teil des Abschnitts Objektorientierte Programmierung der C-Journey von Coddy. Lektion 61 von 61.

Aufgabe

Einfach

Erstellen wir ein Benachrichtigungssystem: eine ereignisgesteuerte Architektur, bei der mehrere Handler ein Ereignis abonnieren und reagieren können, wenn es ausgelöst wird. Dieses Muster bildet das Rückgrat der reaktiven Programmierung und von GUI-Frameworks.

Du organisierst deinen Code über drei Dateien:

event.h: Definiere den Funktionszeigertyp Handler, der eine Nachricht vom Typ const char* entgegennimmt. Erstelle eine Event-Struktur, die ein Array mit bis zu 5 Handlern und die Anzahl der registrierten Handler enthält. Deklariere Funktionen zum Initialisieren eines Ereignisses, zum Abonnieren eines Handlers und zum Auslösen des Ereignisses, um alle Abonnenten zu benachrichtigen.
event.c: Implementiere dein Ereignissystem:
- init_event: nimmt einen Event-Zeiger entgegen und setzt die Anzahl der Handler auf 0
- subscribe: nimmt einen Event-Zeiger und einen Handler entgegen, fügt den Handler dem Array hinzu, wenn noch Platz vorhanden ist (Anzahl kleiner als 5), und erhöht die Anzahl
- fire: nimmt einen Event-Zeiger und eine Nachrichtenzeichenkette entgegen und ruft anschließend jeden registrierten Handler mit dieser Nachricht in der Reihenfolge auf, in der sie abonniert wurden
main.c: Erstelle drei verschiedene Handler-Funktionen, die auf einzigartige Weise auf Ereignisse reagieren:
- logger: gibt [LOG] gefolgt von der Nachricht aus
- alert: gibt [ALERT] gefolgt von der Nachricht aus
- counter: verwendet eine statische Variable, um zu zählen, wie oft die Funktion aufgerufen wurde, und gibt anschließend [COUNT] X aus, wobei X die aktuelle Anzahl ist
Lies eine Ganzzahl ein, die angibt, wie viele Handler abonniert werden sollen (1, 2 oder 3). Abonniere diese Anzahl von Handlern in der folgenden Reihenfolge: zuerst logger, dann alert (falls 2+), anschließend counter (falls 3). Lies eine Nachrichtenzeichenkette ein und löse dann das Ereignis mit dieser Nachricht aus.

Dein Programm erhält:

Die Anzahl der zu abonnierenden Handler (1, 2 oder 3)
Die zu übertragende Nachricht

Beispielausgabe bei den Eingaben 3 und System started:

[LOG] System started
[ALERT] System started
[COUNT] 1

Beispielausgabe bei den Eingaben 2 und Warning detected:

[LOG] Warning detected
[ALERT] Warning detected

Beispielausgabe bei den Eingaben 1 und Hello:

[LOG] Hello

Dies veranschaulicht Polymorphismus durch Funktionszeiger: Derselbe Aufruf von fire löst je nach den abonnierten Handlern völlig unterschiedliche Verhaltensweisen aus. Jeder Handler reagiert auf seine eigene Weise auf dasselbe Ereignis und verdeutlicht damit die entkoppelte Natur eines ereignisgesteuerten Designs.

Probier es selbst

#include <stdio.h>
#include <string.h>
#include "event.h"

// TODO: Logger-Handler implementieren
// Gibt "[LOG] " gefolgt von der Nachricht aus
void logger(const char* message) {
    // TODO: Implementieren
}

// TODO: Alert-Handler implementieren
// Gibt "[ALERT] " gefolgt von der Nachricht aus
void alert(const char* message) {
    // TODO: Implementieren
}

// TODO: Counter-Handler implementieren
// Verwendet eine statische Variable, um Aufrufe zu zählen
// Gibt "[COUNT] X" aus, wobei X der aktuelle Zählerstand ist
void counter(const char* message) {
    // TODO: Mit statischer Variable implementieren
}

int main() {
    // Lies die Anzahl der zu abonnierenden Handler
    int num_handlers;
    scanf("%d", &num_handlers);
    getchar(); // Zeilenumbruch verbrauchen
    
    // Lies die Nachricht
    char message[256];
    fgets(message, sizeof(message), stdin);
    message[strcspn(message, "\n")] = '\0'; // Zeilenumbruch entfernen
    
    // TODO: Event erstellen und initialisieren
    
    // TODO: Handler basierend auf num_handlers abonnieren
    // 1 Handler: logger
    // 2 Handler: logger, alert
    // 3 Handler: logger, alert, counter
    
    // TODO: Event mit der Nachricht auslösen
    
    return 0;
}