Reactive Programming in C++: Libraries and Practice

Reactive Programming in C++: A Modern Approach to Event Handling

Reactive Programming is a paradigm focused on asynchronous data streams and the propagation of changes. In C++, this concept allows you to build flexible, responsive, and easily maintainable applications, especially in the areas of GUI, network communication, and signal processing. Unlike the traditional imperative approach, where you explicitly specify a sequence of actions, reactive programming describes dependencies between data: when one element changes, all those dependent on it are automatically updated.

Core Concepts of Reactive Programming

• Observable — a data source that generates events.
• Observer — a subscriber that reacts to events.
• Subscription — the connection between an Observable and an Observer.
• Operators — functions for transforming, filtering, and combining streams (map, filter, merge, switch_on_next).

In C++, reactive programming is implemented through libraries that provide these abstractions. Let's look at three of the most popular tools.

1. RxCpp — Reactive Extensions Library for C++

RxCpp is a port of the popular ReactiveX (Rx) model to C++. It provides a powerful set of operators for working with asynchronous streams. The library uses modern C++17/20, templates, and lambda expressions.

Example: Simple subscription to a number stream

#include <rxcpp/rx.hpp>#include <iostream>

int main() {    // Create an observable stream of numbers    auto observable = rxcpp::observable<>::range(1, 5);

    // Subscribe    observable.subscribe(        [](int v) { std::cout << "Received: " << v << std::endl; }, // on_next        []() { std::cout << "Completed!" << std::endl; }            // on_completed    );

    return 0;}

Example: Filtering and transformation

#include <rxcpp/rx.hpp>#include <iostream>

int main() {    auto values = rxcpp::observable<>::range(1, 10)        .filter([](int x) { return x % 2 == 0; })  // only even numbers        .map([](int x) { return x * x; });         // square them

    values.subscribe([](int v) { std::cout << v << " "; });    // Output: 4 16 36 64 100

    return 0;}

Features of RxCpp:

• Support for multithreading and schedulers.
• Rich set of operators (merge, zip, combine_latest, debounce, throttle).
• Integration with std::future and asynchronous operations.
• Compatibility with CMake and vcpkg.

2. Boost.Signals2 — Signals and Slots Without External Dependencies

Boost.Signals2 is a library from the Boost collection that implements the signals and slots mechanism. It is a thread-safe evolution of the original Boost.Signals. It is ideal for event-driven architecture, especially in GUI and game engines.

Example: Simple signal with two slots

#include <boost/signals2.hpp>#include <iostream>

void hello() { std::cout << "Hello, "; }void world() { std::cout << "world!" << std::endl; }

int main() {    boost::signals2::signal<void()> sig;

    sig.connect(&hello);    sig.connect(&world);

    sig();  // Calling the signal — will call both slots    // Output: Hello, world!

    return 0;}

Example: Signal with parameters and return value

#include <boost/signals2.hpp>#include <iostream>#include <string>