Introdução aos Padrões de Projeto

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 90 de 104.

Padrões de projeto são soluções comprovadas e reutilizáveis para problemas comuns que surgem no projeto de software. Eles não são códigos que você copia diretamente — são modelos ou projetos que descrevem como estruturar classes e objetos para resolver desafios específicos de maneira elegante.

O conceito foi popularizado pela "Gang of Four" (GoF) em seu livro de 1994, que catalogou 23 padrões fundamentais. Esses padrões normalmente são agrupados em três categorias:

Categoria	Finalidade	Exemplos
Creational	Mecanismos de criação de objetos	Singleton, Factory, Builder
Structural	Composição de classes e objetos	Adapter, Decorator, Composite
Behavioral	Interação e responsabilidades dos objetos	Observer, Strategy, Command

Por que aprender padrões de projeto? Eles fornecem um vocabulário compartilhado entre os desenvolvedores — dizer "use uma Factory aqui" comunica instantaneamente uma ideia complexa. Eles também ajudam você a evitar reinventar soluções e tornam seu código mais flexível e fácil de manter.

Em C++, os padrões de projeto aproveitam os recursos de OOP que você já aprendeu: herança, polimorfismo, classes abstratas e templates. Nas próximas lições, você implementará vários padrões essenciais e entenderá quando cada um é a ferramenta certa para o trabalho.

Desafio

Fácil

Vamos criar um classificador simples de padrões que demonstre sua compreensão das três categorias de padrões de projeto. Você criará um sistema que recebe o nome de um padrão e identifica a qual categoria ele pertence — Creational, Structural ou Behavioral — juntamente com uma breve descrição da finalidade dessa categoria.

Você organizará seu código em três arquivos:

PatternCategory.h: defina uma classe base abstrata chamada PatternCategory que represente uma categoria de padrão de projeto. Ela deve ter:
- Um método virtual puro getName() que retorne o nome da categoria como uma string
- Um método virtual puro getPurpose() que retorne uma descrição do que os padrões nessa categoria fazem
- Um destrutor virtual
Em seguida, crie três classes derivadas que herdem de PatternCategory:
- CreationalCategory: retorna o nome "Creational" e a finalidade "Object creation mechanisms"
- StructuralCategory: retorna o nome "Structural" e a finalidade "Class and object composition"
- BehavioralCategory: retorna o nome "Behavioral" e a finalidade "Object interaction and responsibility"
PatternClassifier.h: crie uma classe PatternClassifier que possa identificar a qual categoria pertence um determinado padrão.
Seu classificador deve ter um método classify que receba o nome de um padrão (string) e retorne um ponteiro para o PatternCategory apropriado. Use ponteiros inteligentes (std::unique_ptr) para o gerenciamento de memória.

O classificador deve reconhecer estes padrões:
- Creational: Singleton, Factory, Builder
- Structural: Adapter, Decorator, Composite
- Behavioral: Observer, Strategy, Command
Se o nome do padrão não for reconhecido, retorne nullptr.
main.cpp: leia uma única entrada: o nome de um padrão de projeto.
Crie um PatternClassifier e use-o para classificar o padrão informado. Se o padrão for reconhecido, imprima:
```
[PatternName] is a [CategoryName] pattern
Purpose: [CategoryPurpose]
```
Se o padrão não for reconhecido, imprima:
```
Unknown pattern: [PatternName]
```

Por exemplo, com a entrada Singleton:

Singleton is a Creational pattern
Purpose: Object creation mechanisms

Com a entrada Observer:

Observer is a Behavioral pattern
Purpose: Object interaction and responsibility

Com a entrada Proxy:

Unknown pattern: Proxy

Este desafio reforça as três categorias de padrões de projeto enquanto pratica herança, polimorfismo e ponteiros inteligentes: todos conceitos que você já dominou. A estrutura em vários arquivos reproduz a forma como projetos reais organizam classes relacionadas.

Experimente você mesmo

#include <iostream>
#include <string>
#include "PatternClassifier.h"

int main() {
    // Leia o nome do padrão
    std::string patternName;
    std::cin >> patternName;
    
    // TODO: Crie uma instância de PatternClassifier
    
    // TODO: Use o classificador para classificar o padrão de entrada
    
    // TODO: Se o padrão for reconhecido, imprima:
    // "[PatternName] is a [CategoryName] pattern"
    // "Purpose: [CategoryPurpose]"
    
    // TODO: Se o padrão não for reconhecido (nullptr), imprima:
    // "Unknown pattern: [PatternName]"
    
    return 0;
}