Event-driven Architecture in C++: How to Write Reactive Code

Why do you need event-driven architecture in C++?

Imagine you are an orchestra conductor. You don't play each instrument yourself, but a wave of your baton triggers a chain of reactions: violins begin to sing, drums beat out the rhythm. Event-driven architecture works on the same principle — it is an approach where the system reacts to external or internal events, rather than executing a predetermined linear script.

In the world of C++, this programming style becomes especially valuable when you need to write fast, scalable, and responsive applications. Game engines, graphical interfaces, high-load servers — everywhere where a reaction to user actions or state changes is important, the event-driven approach is indispensable.

In this article, we will not just cover the theory, but write real code that will show how event-driven programming in C++ turns boring sequential code into a living, reactive organism.

What is event-driven architecture in simple terms

Event-driven architecture is an architectural pattern in which system components communicate through events. Instead of actively polling the state of an object (polling), you simply subscribe to the events that interest you and react to them.

Key elements of the event model

\n
• Event — a signal that something has happened (a button was clicked, a packet arrived, the temperature changed)
\n
• Event producer — the one who generates the event
\n
• Event consumer (subscriber) — the one who processes the event
\n
• Event bus — the central router that delivers events to subscribers
\n
• Event loop — an infinite loop that waits for and dispatches events
\n

Imagine a smart home. A motion sensor (producer) generates the event "Motion detected". The event bus passes this event to subscribers: the camera (start recording) and the lamp (turn on the light). No one polls anyone — everything happens automatically.

Why C++ is ideal for event-driven systems

Some might think: "C++ is a low-level language, why use it for reactive programming?" In fact, event-driven programming in C++ offers unique advantages:

\n
• Maximum performance — minimal overhead for event dispatching
\n
• Full memory control — you decide how to manage resources
\n
• Multithreading support — C++ allows building distributed event systems
\n
• Templates and lambdas — powerful tools for flexible event handling
\n

Writing an event-driven system in C++ from scratch

Let's create a simple but working event system. We will use the Observer pattern — the classic way to implement an event model.

Basic implementation: EventBus

Let's start by creating a central event bus that will store subscribers and distribute events.

#include <iostream>\n#include <functional>\n#include <map>\n#include <vector>\n#include <any>\n#include <string>\n\n// Event type — just a string for simplicity\nusing EventType = std::string;\n\n// Handler type — a function taking std::any\nusing EventHandler = std::function<void(const std::any&)>;\n\nclass EventBus {\nprivate:\n    std::map<EventType, std::vector<EventHandler>> handlers_;\n\npublic:\n    // Subscribe to an event\n    void subscribe(const EventType& event, EventHandler handler) {\n        handlers_[event].push_back(handler);\n    }\n\n    // Publ