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 design de software. Eles não são códigos que você copia diretamente — são modelos ou plantas que descrevem como estruturar classes e objetos para resolver desafios específicos de forma elegante.

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

Categoria	Propósito	Exemplos
Criacional	Mecanismos de criação de objetos	Singleton, Factory, Builder
Estrutural	Composição de classes e objetos	Adapter, Decorator, Composite
Comportamental	Interação e responsabilidade de objetos	Observer, Strategy, Command

Por que aprender padrões de projeto? Eles fornecem um vocabulário compartilhado entre 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 POO que você já aprendeu: herança, polimorfismo, classes abstratas e templates. Ao longo das próximas lições, você implementará diversos padrões essenciais e entenderá quando cada um é a ferramenta certa para o trabalho.

Desafio

Fácil

Vamos construir um classificador de padrões simples 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—junto com uma breve descrição do propósito dessa categoria.

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

PatternCategory.h: Defina uma classe base abstrata chamada PatternCategory que representa uma categoria de padrão de projeto. Ela deve ter:
- Um método virtual puro getName() que retorna o nome da categoria como uma string
- Um método virtual puro getPurpose() que retorna uma descrição do que os padrões nesta categoria fazem
- Um destrutor virtual
Em seguida, crie três classes derivadas que herdam de PatternCategory:
- CreationalCategory — retorna o nome "Creational" e o propósito "Object creation mechanisms"
- StructuralCategory — retorna o nome "Structural" e o propósito "Class and object composition"
- BehavioralCategory — retorna o nome "Behavioral" e o propósito "Object interaction and responsibility"
PatternClassifier.h: Crie uma classe PatternClassifier que possa identificar a qual categoria um determinado padrão pertence.
Seu classificador deve ter um método classify que recebe o nome de um padrão (string) e retorna um ponteiro para a PatternCategory apropriada. 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 de entrada. 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á domina. A estrutura de múltiplos arquivos reflete como projetos reais organizam classes relacionadas.

Experimente você mesmo

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

int main() {
    // Ler o nome do padrão
    std::string patternName;
    std::cin >> patternName;
    
    // TODO: Criar uma instância de PatternClassifier
    
    // TODO: Usar 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;
}