Padrões Arquiteturais em C++: como escrever código que não envergonha mostrar

Por que C++ sem arquitetura é uma dor

Se você já abriu um projeto C++ de outra pessoa (ou o seu próprio antigo) e sentiu seus olhos começarem a lacrimejar por milhares de linhas em um único arquivo, e a compilação se transformar em um ritual com uma xícara de café — você não está sozinho. C++ oferece uma liberdade enorme: você pode misturar estilos, sobrecarregar operadores, fazer magia com templates. Mas liberdade sem disciplina leva ao caos.

Padrões arquiteturais em C++ não são teoria chata de palestras universitárias. São receitas comprovadas de batalha que salvam um projeto quando ele cresce de "brinquedo" para industrial. Neste artigo, vamos analisar os padrões arquiteturais C++ que realmente simplificam a vida: de MVC a Observer. E sim, terá muito código.

O que é um padrão arquitetural (e como ele difere de "apenas um padrão")

Muitos confundem padrões de design C++ (GoF: Singleton, Factory, Adapter) com os arquiteturais. A diferença é simples:

\n
• Padrões de design — microssoluções no nível de classe ou módulo (por exemplo, como criar um objeto).
\n
• Padrões arquiteturais — macrossoluções no nível de toda a aplicação (como os componentes se comunicam, como as camadas são divididas).
\n

A arquitetura determina se seu projeto vai se transformar em uma "grande bola de lama" (Big Ball of Mud) depois de seis meses. Portanto, vamos ver os três padrões mais úteis para C++.

1. MVC (Model-View-Controller) em C++: dividir para conquistar

MVC é um clássico. Ele divide a aplicação em três partes: dados (Model), exibição (View) e lógica de controle (Controller). Em C++, isso é especialmente relevante para aplicações GUI (Qt, wxWidgets) ou até mesmo utilitários de console.

Como fica no código

Vamos imaginar uma calculadora simples. O Model armazena o resultado, a View o exibe, o Controller processa a entrada.

#include <iostream>\n#include <string>\n\n// Model: não sabe nada sobre 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: apenas exibição\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 << "Erro: " << msg << std::endl;\n    }\n};\n\n// Controller: liga Model e 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); // Saída: Resultado: 8\n    return 0;\n}

Por que isso é legal? Você pode substituir a View de console por um widget Qt sem tocar no Model. Ou adicionar testes unitários para o Model sem executar a GUI. Essa é a base do design de aplicações C++ do zero.

2. Observer (Observador): quando as mudanças devem ser visíveis para todos

Imagine: você tem um sensor de temperatura, e vários painéis precisam ser atualizados quando a temperatura muda. Em vez de consultar o sensor a cada segundo (polling), o Observer notifica os assinantes por conta própria. Este é um padrão arquitetural C++ que torna o código orientado a eventos.

Implementação em C++11 e superior

Usamos ponteiros inteligentes e std::function para flexibilidade.

#include <iostream>\n#include <vector>\n#include <memory>\n#include <functional>\n\n// Interface do observador\nclass IObserv