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. Es ist kein Code, den du direkt kopierst – sie sind Vorlagen oder Baupläne, 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 üblicherweise 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 solltest du Entwurfsmuster lernen? Sie schaffen ein gemeinsames Vokabular unter Entwicklern – die Aussage „Verwende hier eine Factory“ vermittelt sofort eine komplexe Idee. Außerdem helfen sie dir, das Rad nicht neu zu erfinden, und machen deinen Code flexibler und einfacher zu warten.

In C++ nutzen Entwurfsmuster die OOP-Funktionen, die du bereits kennengelernt hast: Vererbung, Polymorphismus, abstrakte Klassen und Templates. In den nächsten Lektionen wirst du mehrere grundlegende Muster implementieren und verstehen, wann welches Muster das richtige Werkzeug ist.

Aufgabe

Einfach

Erstellen wir einen einfachen Musterklassifizierer, der dein Verständnis der drei Entwurfsmusterkategorien demonstriert. Du erstellst ein System, das einen Musternamen entgegennimmt und bestimmt, zu welcher Kategorie er gehört: Creational, Structural oder Behavioral. Dazu kommt eine kurze Beschreibung des Zwecks dieser Kategorie.

Du organisierst deinen Code auf drei Dateien:

PatternCategory.h: Definiere eine abstrakte Basisklasse namens PatternCategory, die eine Entwurfsmusterkategorie repräsentiert. Sie sollte Folgendes haben:
- Eine rein virtuelle Methode getName(), die den Kategorienamen als Zeichenfolge zurückgibt
- Eine rein virtuelle Methode getPurpose(), die eine Beschreibung dessen zurückgibt, was Muster dieser Kategorie bewirken
- Einen virtuellen Destruktor
Erstelle anschließend drei abgeleitete Klassen, die von PatternCategory erben:
- CreationalCategory: Gibt als Namen "Creational" und als Zweck "Object creation mechanisms" zurück
- StructuralCategory: Gibt als Namen "Structural" und als Zweck "Class and object composition" zurück
- BehavioralCategory: Gibt als Namen "Behavioral" und als Zweck "Object interaction and responsibility" zurück
PatternClassifier.h: Erstelle eine Klasse PatternClassifier, die bestimmen kann, zu welcher Kategorie ein bestimmtes Muster gehört.
Dein Klassifizierer sollte eine Methode classify besitzen, die einen Musternamen (Zeichenfolge) entgegennimmt und einen Zeiger auf die passende PatternCategory zurückgibt. Verwende Smart Pointer (std::unique_ptr) zur 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]
```

Zum 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 Herausforderung festigt die drei Kategorien von Entwurfsmustern und bietet zugleich Übung mit Vererbung, Polymorphie und Smart Pointern: alles Konzepte, die du bereits beherrschst. Die Struktur mit mehreren Dateien spiegelt wider, wie in realen Projekten zusammengehörige Klassen organisiert werden.

Probier es selbst

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

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