Programación reactiva en C++: bibliotecas y práctica

Programación reactiva en C++: un enfoque moderno para el manejo de eventos

La programación reactiva (Reactive Programming) es un paradigma orientado a flujos de datos asíncronos y la propagación de cambios. En C++, este concepto permite construir aplicaciones flexibles, receptivas y fáciles de mantener, especialmente en áreas como GUI, interacción en red y procesamiento de señales. A diferencia del enfoque imperativo tradicional, donde se especifica explícitamente una secuencia de acciones, la programación reactiva describe dependencias entre datos: cuando un elemento cambia, todos los que dependen de él se actualizan automáticamente.

Conceptos principales de la programación reactiva

• Observable (Observable) — fuente de datos que genera eventos.
• Observer (Observador) — suscriptor que reacciona a los eventos.
• Subscription (Suscripción) — vínculo entre Observable y Observer.
• Operadores — funciones para transformar, filtrar y combinar flujos (map, filter, merge, switch_on_next).

En C++, la programación reactiva se implementa a través de bibliotecas que proporcionan estas abstracciones. Veamos las tres herramientas más populares.

1. RxCpp — biblioteca Reactive Extensions para C++

RxCpp es un puerto del popular modelo ReactiveX (Rx) a C++. Proporciona un potente conjunto de operadores para trabajar con flujos asíncronos. La biblioteca utiliza C++17/20 moderno, plantillas y expresiones lambda.

Ejemplo: suscripción simple a un flujo de números

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

int main() {    // Creamos un flujo observable de números    auto observable = rxcpp::observable<>::range(1, 5);

    // Nos suscribimos    observable.subscribe(        [](int v) { std::cout << "Recibido: " << v << std::endl; }, // on_next        []() { std::cout << "¡Completado!" << std::endl; }            // on_completed    );

    return 0;}

Ejemplo: filtrado y transformación

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

int main() {    auto values = rxcpp::observable<>::range(1, 10)        .filter([](int x) { return x % 2 == 0; })  // solo pares        .map([](int x) { return x * x; });         // elevamos al cuadrado

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

    return 0;}

Características de RxCpp:

• Soporte para multitarea y planificadores (schedulers).
• Amplio conjunto de operadores (merge, zip, combine_latest, debounce, throttle).
• Integración con std::future y operaciones asíncronas.
• Compatibilidad con CMake y vcpkg.

2. Boost.Signals2 — señales y slots sin dependencias externas

Boost.Signals2 es una biblioteca del conjunto Boost que implementa el mecanismo de señales y slots. Es una evolución segura para subprocesos de la Boost.Signals original. Es ideal para arquitecturas orientadas a eventos, especialmente en GUI y motores de juegos.

Ejemplo: señal simple con dos slots

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

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

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

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

    sig();  // Llamada a la señal — invocará ambos slots    // Salida: Hola, ¡mundo!

    return 0;}

Ejemplo: señal con parámetros y valor de retorno

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