Einführung in Entwurfsmuster

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy. Lektion 90 von 104.

Entwurfsmuster sind bewährte, wiederverwendbare Lösungen für häufige Probleme, die beim Softwareentwurf auftreten. Sie sind kein Code, den du direkt kopierst – sie sind Vorlagen oder Blaupausen, die beschreiben, wie Klassen und Objekte strukturiert werden, um bestimmte Herausforderungen elegant zu lösen.

Das Konzept wurde durch die „Gang of Four“ (GoF) in ihrem 1994 erschienenen Buch populär gemacht, in dem 23 grundlegende Muster katalogisiert wurden. Diese Muster werden typischerweise in drei Kategorien eingeteilt:

Kategorie	Zweck	Beispiele
Erzeugungsmuster	Mechanismen zur Objekterzeugung	Singleton, Factory, Builder
Strukturmuster	Zusammensetzung von Klassen und Objekten	Adapter, Decorator, Composite
Verhaltensmuster	Interaktion und Zuständigkeit von Objekten	Observer, Strategy, Command

Warum Entwurfsmuster lernen? Sie bieten ein gemeinsames Vokabular unter Entwicklern – wenn man sagt „verwende hier eine Factory“, vermittelt das sofort eine komplexe Idee. Sie helfen dir außerdem, das Rad nicht neu zu erfinden, und machen deinen Code flexibler und wartbarer.

In C++ nutzen Entwurfsmuster die OOP-Funktionen, die du bereits kennengelernt hast: Vererbung, Polymorphie, abstrakte Klassen und Templates. In den nächsten Lektionen wirst du mehrere wesentliche Muster implementieren und verstehen, wann jedes davon das richtige Werkzeug für die jeweilige Aufgabe ist.

Aufgabe

Einfach

Erstellen wir einen einfachen Musterklassifizierer, der dein Verständnis der drei Kategorien von Entwurfsmustern demonstriert. Du erstellst ein System, das einen Musternamen entgegennimmt und ermittelt, zu welcher Kategorie er gehört – Creational, Structural oder Behavioral – zusammen mit einer kurzen Beschreibung des Zwecks dieser Kategorie.

Du organisierst deinen Code über drei Dateien:

PatternCategory.h: Definiere eine abstrakte Basisklasse namens PatternCategory, die eine Kategorie von Entwurfsmustern repräsentiert. Sie sollte Folgendes enthalten:
- Eine rein virtuelle Methode getName(), die den Namen der Kategorie als String zurückgibt
- Eine rein virtuelle Methode getPurpose(), die eine Beschreibung dessen zurückgibt, was Muster in dieser Kategorie leisten
- Einen virtuellen Destruktor
Erstelle anschließend drei abgeleitete Klassen, die von PatternCategory erben:
- CreationalCategory: gibt den Namen "Creational" und den Zweck "Object creation mechanisms" zurück
- StructuralCategory: gibt den Namen "Structural" und den Zweck "Class and object composition" zurück
- BehavioralCategory: gibt den Namen "Behavioral" und den Zweck "Object interaction and responsibility" zurück
PatternClassifier.h: Erstelle eine Klasse PatternClassifier, die ermitteln kann, zu welcher Kategorie ein bestimmtes Muster gehört.
Dein Klassifizierer sollte eine Methode classify besitzen, die einen Musternamen (String) entgegennimmt und einen Zeiger auf die entsprechende PatternCategory zurückgibt. Verwende intelligente Zeiger (std::unique_ptr) für die Speicherverwaltung.

Der Klassifizierer sollte diese Muster erkennen:
- Creational: Singleton, Factory, Builder
- Structural: Adapter, Decorator, Composite
- Behavioral: Observer, Strategy, Command
Wenn der Mustername nicht erkannt wird, gib nullptr zurück.
main.cpp: Lies eine einzelne Eingabe ein: den Namen eines Entwurfsmusters.
Erstelle einen PatternClassifier und verwende ihn, um das eingegebene Muster zu klassifizieren. Wenn das Muster erkannt wird, gib Folgendes aus:
```
[PatternName] is a [CategoryName] pattern
Purpose: [CategoryPurpose]
```
Wenn das Muster nicht erkannt wird, gib Folgendes aus:
```
Unknown pattern: [PatternName]
```

Beispiel bei der Eingabe Singleton:

Singleton is a Creational pattern
Purpose: Object creation mechanisms

Bei der Eingabe Observer:

Observer is a Behavioral pattern
Purpose: Object interaction and responsibility

Bei der Eingabe Proxy:

Unknown pattern: Proxy

Diese Aufgabe festigt die drei Kategorien von Entwurfsmustern und vermittelt gleichzeitig praktische Erfahrung mit Vererbung, Polymorphie und intelligenten Zeigern – alles Konzepte, die du bereits beherrschst. Die Struktur mit mehreren Dateien entspricht der Organisation verwandter Klassen in echten Projekten.

Probier es selbst

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

int main() {
    // Lies den Pattern-Namen
    std::string patternName;
    std::cin >> patternName;
    
    // TODO: Erstelle eine PatternClassifier-Instanz
    
    // TODO: Verwende den Classifier, um das Eingabe-Pattern zu klassifizieren
    
    // TODO: Wenn das Pattern erkannt wird, gib aus:
    // "[PatternName] is a [CategoryName] pattern"
    // "Purpose: [CategoryPurpose]"
    
    // TODO: Wenn das Pattern nicht erkannt wird (nullptr), gib aus:
    // "Unknown pattern: [PatternName]"
    
    return 0;
}