Sistema de Eventos

Parte da seção Object Oriented Programming do Journey de C da Coddy — lição 61 de 61.

Desafio

Fácil

Vamos construir um Sistema de Notificação — uma arquitetura orientada a eventos onde múltiplos manipuladores (handlers) podem se inscrever em um evento e responder quando ele for disparado. Este padrão é a base da programação reativa e de frameworks de interface gráfica (GUI).

Você organizará seu código em três arquivos:

event.h: Defina o tipo de ponteiro de função Handler que recebe uma mensagem const char*. Crie uma struct Event que contém um array de até 5 handlers e uma contagem de handlers registrados. Declare funções para inicializar um evento, inscrever um handler e disparar o evento para notificar todos os inscritos.
event.c: Implemente seu sistema de eventos:
- init_event — recebe um ponteiro para Event e define a contagem de handlers como 0
- subscribe — recebe um ponteiro para Event e um Handler, adiciona o handler ao array se houver espaço (contagem menor que 5) e incrementa a contagem
- fire — recebe um ponteiro para Event e uma string de mensagem, então chama cada handler registrado com essa mensagem na ordem em que foram inscritos
main.c: Crie três funções de handler diferentes que respondem aos eventos de maneiras únicas:
- logger — imprime [LOG] seguido pela mensagem
- alert — imprime [ALERT] seguido pela mensagem
- counter — usa uma variável estática para contar quantas vezes foi chamada, então imprime [COUNT] X onde X é a contagem atual
Leia um número inteiro indicando quantos handlers devem ser inscritos (1, 2 ou 3). Inscreva essa quantidade de handlers na ordem: primeiro logger, depois alert (se 2+), depois counter (se 3). Leia uma string de mensagem e, em seguida, dispare o evento com essa mensagem.

Seu programa receberá:

O número de handlers para inscrever (1, 2 ou 3)
A mensagem a ser transmitida

Exemplo de saída quando as entradas são 3 e System started:

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

Exemplo de saída quando as entradas são 2 e Warning detected:

[LOG] Warning detected
[ALERT] Warning detected

Exemplo de saída quando as entradas são 1 e Hello:

[LOG] Hello

Isso demonstra o polimorfismo através de ponteiros de função — a mesma chamada fire aciona comportamentos completamente diferentes dependendo de quais handlers estão inscritos. Cada handler responde à sua maneira ao mesmo evento, demonstrando a natureza desacoplada do design orientado a eventos.

Experimente você mesmo

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

// TODO: Implementar o manipulador logger
// Imprime "[LOG] " seguido pela mensagem
void logger(const char* message) {
    // TODO: Implementar
}

// TODO: Implementar o manipulador alert
// Imprime "[ALERT] " seguido pela mensagem
void alert(const char* message) {
    // TODO: Implementar
}

// TODO: Implementar o manipulador counter
// Usa uma variável static para contar as chamadas
// Imprime "[COUNT] X" onde X é a contagem atual
void counter(const char* message) {
    // TODO: Implementar com uma variável static
}

int main() {
    // Lê o número de manipuladores para se inscrever
    int num_handlers;
    scanf("%d", &num_handlers);
    getchar(); // consome a nova linha
    
    // Lê a mensagem
    char message[256];
    fgets(message, sizeof(message), stdin);
    message[strcspn(message, "\n")] = '\0'; // remove a nova linha
    
    // TODO: Criar e inicializar um Event
    
    // TODO: Inscrever os manipuladores com base em num_handlers
    // 1 manipulador: logger
    // 2 manipuladores: logger, alert
    // 3 manipuladores: logger, alert, counter
    
    // TODO: Disparar o evento com a mensagem
    
    return 0;
}