Sistema de eventos

Parte de la sección Object Oriented Programming del Journey de C de Coddy — lección 61 de 61.

Desafío

Fácil

Vamos a construir un Sistema de Notificaciones — una arquitectura dirigida por eventos donde múltiples manejadores pueden suscribirse a un evento y responder cuando este se dispara. Este patrón es la columna vertebral de la programación reactiva y de los frameworks de GUI.

Organizarás tu código en tres archivos:

event.h: Define el tipo de puntero a función Handler que recibe un mensaje const char*. Crea una estructura Event que contenga un arreglo de hasta 5 manejadores y un contador de manejadores registrados. Declara funciones para inicializar un evento, suscribir un manejador y disparar el evento para notificar a todos los suscriptores.
event.c: Implementa tu sistema de eventos:
- init_event — recibe un puntero a Event y establece el contador de manejadores en 0
- subscribe — recibe un puntero a Event y un Handler, añade el manejador al arreglo si hay espacio (contador menor que 5) e incrementa el contador
- fire — recibe un puntero a Event y una cadena de mensaje, luego llama a cada manejador registrado con ese mensaje en el orden en que fueron suscritos
main.c: Crea tres funciones manejadoras diferentes que respondan a los eventos de formas únicas:
- logger — imprime [LOG] seguido del mensaje
- alert — imprime [ALERT] seguido del mensaje
- counter — utiliza una variable estática para contar cuántas veces ha sido llamada, luego imprime [COUNT] X donde X es el conteo actual
Lee un entero que indique cuántos manejadores suscribir (1, 2 o 3). Suscribe esa cantidad de manejadores en orden: primero logger, luego alert (si son 2+) y después counter (si son 3). Lee una cadena de mensaje y luego dispara el evento con ese mensaje.

Tu programa recibirá:

El número de manejadores a suscribir (1, 2 o 3)
El mensaje a transmitir

Ejemplo de salida cuando las entradas son 3 y System started:

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

Ejemplo de salida cuando las entradas son 2 y Warning detected:

[LOG] Warning detected
[ALERT] Warning detected

Ejemplo de salida cuando las entradas son 1 y Hello:

[LOG] Hello

Esto demuestra el polimorfismo a través de punteros a funciones — la misma llamada a fire activa comportamientos completamente diferentes dependiendo de qué manejadores estén suscritos. Cada manejador responde a su manera al mismo evento, mostrando la naturaleza desacoplada del diseño dirigido por eventos.

Pruébalo tú mismo

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

// TODO: Implementar el manejador logger
// Imprime "[LOG] " seguido del mensaje
void logger(const char* message) {
    // TODO: Implementar
}

// TODO: Implementar el manejador alert
// Imprime "[ALERT] " seguido del mensaje
void alert(const char* message) {
    // TODO: Implementar
}

// TODO: Implementar el manejador counter
// Usa una variable static para contar las llamadas
// Imprime "[COUNT] X" donde X es el conteo actual
void counter(const char* message) {
    // TODO: Implementar con una variable static
}

int main() {
    // Leer el número de manejadores a suscribir
    int num_handlers;
    scanf("%d", &num_handlers);
    getchar(); // consumir el salto de línea
    
    // Leer el mensaje
    char message[256];
    fgets(message, sizeof(message), stdin);
    message[strcspn(message, "\n")] = '\0'; // eliminar el salto de línea
    
    // TODO: Crear e inicializar un Event
    
    // TODO: Suscribir manejadores basados en num_handlers
    // 1 manejador: logger
    // 2 manejadores: logger, alert
    // 3 manejadores: logger, alert, counter
    
    // TODO: Disparar el evento con el mensaje
    
    return 0;
}