Programación Reactiva en C++: RxCpp y Boost.Signals2 |…

Programación Reactiva en C++: visión general de las bibliotecas RxCpp y Boost.Signals2

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 paradigma se implementa a través de bibliotecas que permiten manejar eventos, señales y secuencias de datos asíncronas de forma declarativa. En este artículo, analizaremos dos bibliotecas clave para la programación reactiva en C++: RxCpp (Reactive Extensions for C++) y Boost.Signals2. Ambas bibliotecas resuelven la tarea de manejo de eventos, pero con diferentes niveles de complejidad y funcionalidad.

¿Por qué es necesaria la programación reactiva en C++?

El código imperativo tradicional a menudo resulta complejo al trabajar con eventos asíncronos, entrada de usuario, solicitudes de red o multitarea. La programación reactiva ofrece:

Enfoque declarativo: Usted describe "qué" debe suceder, no "cómo".
Composición de flujos: Es fácil combinar, filtrar y transformar flujos de datos.
Gestión de multitarea: Mecanismos integrados para cambiar de contexto y sincronizar.
Manejo de errores: Un único canal para datos y excepciones.

Biblioteca RxCpp

RxCpp es un puerto de las extensiones reactivas (Rx) para C++. Proporciona un potente conjunto de operadores para trabajar con secuencias de datos asíncronas. Los conceptos principales son: observable (fuente de datos) y observer (suscriptor).

Instalación

RxCpp es una biblioteca header-only. Basta con clonar el repositorio e incluir los archivos de cabecera:

#include <rxcpp/rx.hpp>using namespace rxcpp;using namespace rxcpp::sources;using namespace rxcpp::operators;

Ejemplo 1: Suscripción simple a un flujo de números

Creemos un observable que genere números del 1 al 5 y nos suscribamos a él:

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

int main() {    auto values = range(1, 5); // observable: 1,2,3,4,5

    values.        subscribe([](int v) {            std::cout << "Recibido: " << v << std::endl;        },        []() {            std::cout << "Flujo completado" << std::endl;        });

    return 0;}

Ejemplo 2: Filtrado y transformación

Los operadores reactivos permiten manipular datos fácilmente. Filtremos los números pares y multiplíquelos por 10:

auto values = range(1, 10);

values    .filter([](int v) { return v % 2 == 0; }) // solo pares    .map([](int v) { return v * 10; })        // multiplicar por 10    .subscribe([](int v) {        std::cout << "Resultado: " << v << std::endl;    });// Salida: 20, 40, 60, 80, 100

Ejemplo 3: Combinación de flujos

Combinemos dos flujos con el operador merge:

auto stream1 = interval(std::chrono::milliseconds(100)).take(3);auto stream2 = interval(std::chrono::milliseconds(150)).take(3);

stream1.merge(stream2)    .subscribe([](long v) {        std::cout << v << " ";    });// Posible salida: 0 0 1 2 1 2 (el orden puede variar)

Biblioteca Boost.Signals2

Boost.Signals2 es una biblioteca para implementar señales y slots (signals & slots). Forma parte de las bibliotecas Boost y proporciona un mecanismo de devolución de llamada con seguridad de tipos. A diferencia de RxCpp, Signals2 no está diseñada para trabajar con flujos de datos, sino más bien para el manejo de eventos discretos.

Conceptos principales

Señal (signal): un objeto que puede ser "invocado" y notificará a todos sus suscriptores.
Slot: una función u objeto funcional que se conecta a una señal.