Patrones arquitectónicos en C++: cómo escribir código que no dé vergüenza mostrar

Por qué C++ sin arquitectura es un dolor

Si alguna vez has abierto un proyecto de C++ ajeno (o tuyo antiguo) y has sentido que los ojos se te empiezan a llenar de lágrimas por miles de líneas en un solo archivo, y la compilación se convierte en un ritual con una taza de café — no estás solo. C++ da una libertad enorme: puedes mezclar estilos, sobrecargar operadores, hacer magia con plantillas. Pero la libertad sin disciplina lleva al caos.

Los patrones arquitectónicos en C++ no son teoría aburrida de conferencias universitarias. Son recetas de combate probadas que salvan un proyecto cuando crece de "juguete" a industrial. En este artículo analizaremos patrones arquitectónicos de C++ que realmente simplifican la vida: desde MVC hasta Observer. Y sí, habrá mucho código.

Qué es un patrón arquitectónico (y en qué se diferencia de un "simple patrón")

Muchos confunden los patrones de diseño de C++ (GoF: Singleton, Factory, Adapter) con los arquitectónicos. La diferencia es simple:

\n
• Patrones de diseño — micro-soluciones a nivel de clase o módulo (por ejemplo, cómo crear un objeto).
\n
• Patrones arquitectónicos — macro-soluciones a nivel de toda la aplicación (cómo se comunican los componentes, cómo están separadas las capas).
\n

La arquitectura determina si tu proyecto se convertirá en un "gran montón de barro" (Big Ball of Mud) en seis meses. Por eso, veamos los tres patrones más útiles para C++.

1. MVC (Model-View-Controller) en C++: divide y vencerás

MVC es un clásico. Divide la aplicación en tres partes: datos (Model), visualización (View) y lógica de control (Controller). En C++ esto es especialmente relevante para aplicaciones GUI (Qt, wxWidgets) o incluso utilidades de consola.

Cómo se ve en código

Imaginemos una calculadora muy simple. El Modelo almacena el resultado, la Vista lo muestra, el Controlador procesa la entrada.

#include <iostream>\n#include <string>\n\n// Model: no sabe nada de la GUI\nclass CalculatorModel {\npublic:\n    double add(double a, double b) {\n        result_ = a + b;\n        return result_;\n    }\n    double getResult() const { return result_; }\nprivate:\n    double result_ = 0;\n};\n\n// View: solo visualización\nclass CalculatorView {\npublic:\n    void showResult(double value) {\n        std::cout << "Resultado: " << value << std::endl;\n    }\n    void showError(const std::string& msg) {\n        std::cerr << "Error: " << msg << std::endl;\n    }\n};\n\n// Controller: conecta Model y View\nclass CalculatorController {\npublic:\n    CalculatorController(CalculatorModel& model, CalculatorView& view)\n        : model_(model), view_(view) {}\n\n    void handleAdd(double a, double b) {\n        double res = model_.add(a, b);\n        view_.showResult(res);\n    }\nprivate:\n    CalculatorModel& model_;\n    CalculatorView& view_;\n};\n\nint main() {\n    CalculatorModel model;\n    CalculatorView view;\n    CalculatorController controller(model, view);\n\n    controller.handleAdd(5, 3); // Salida: Resultado: 8\n    return 0;\n}

¿Por qué es genial? Puedes reemplazar la Vista de consola por un widget de Qt sin tocar el Modelo. O agregar pruebas unitarias para el Modelo sin ejecutar la GUI. Esta es la base del diseño de aplicaciones C++ desde cero.

2. Observer (Observador): cuando los cambios deben ser visibles para todos

Imagina: tienes un sensor de temperatura, y varios paneles deben actualizarse cuando la temperatura cambia. En lugar de consultar el sensor cada segundo (polling), el Observer mismo notifica a los suscriptores. Este es un patrón arquitectónico de C++ que hace que el código esté orientado a eventos.

Implementación en C++11 y posteriores

Usamos punteros inteligentes y std::function para flexibilidad.

#include <iostream>\n#include <vector>\n#include <memory>\n#include <functional>\n\n// Interfaz del observador\nclass IObserv