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äufig auftretende Probleme im Softwaredesign. Sie sind kein Code, den man direkt kopiert – sie sind Vorlagen oder Blaupausen, die beschreiben, wie Klassen und Objekte strukturiert werden sollten, um spezifische Herausforderungen elegant zu lösen.

Das Konzept wurde durch die „Gang of Four“ (GoF) in ihrem Buch von 1994 bekannt gemacht, das 23 grundlegende Muster katalogisierte. Diese Muster werden normalerweise in drei Kategorien unterteilt:

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

Warum sollte man Design Patterns lernen? Sie bieten ein gemeinsames Vokabular unter Entwicklern – zu sagen „verwende hier eine Factory“ kommuniziert sofort eine komplexe Idee. Sie helfen Ihnen auch dabei, Lösungen nicht neu erfinden zu müssen, und machen Ihren Code flexibler und wartbarer.

In C++ nutzen Design Patterns die OOP-Funktionen, die Sie bereits gelernt haben: Vererbung, Polymorphismus, abstrakte Klassen und Templates. In den nächsten Lektionen werden Sie mehrere wesentliche Muster implementieren und verstehen, wann jedes einzelne das richtige Werkzeug für die jeweilige Aufgabe ist.

Aufgabe

Einfach

Lassen Sie uns einen einfachen Muster-Klassifizierer erstellen, der Ihr Verständnis der drei Entwurfsmuster-Kategorien demonstriert. Sie werden ein System erstellen, das einen Musternamen entgegennimmt und identifiziert, zu welcher Kategorie er gehört – Creational, Structural oder Behavioral – zusammen mit einer kurzen Beschreibung des Zwecks dieser Kategorie.

Sie werden Ihren Code über drei Dateien organisieren:

PatternCategory.h: Definieren Sie eine abstrakte Basisklasse namens PatternCategory, die eine Entwurfsmuster-Kategorie repräsentiert. Sie sollte Folgendes haben:
- Eine rein virtuelle Methode getName(), die den Kategorienamen als String zurückgibt
- Eine rein virtuelle Methode getPurpose(), die eine Beschreibung dessen zurückgibt, was Muster in dieser Kategorie tun
- Einen virtuellen Destruktor
Erstellen Sie dann 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: Erstellen Sie eine Klasse PatternClassifier, die identifizieren kann, zu welcher Kategorie ein gegebenes Muster gehört.
Ihr Klassifizierer sollte eine Methode classify haben, die einen Musternamen (String) entgegennimmt und einen Pointer auf die entsprechende PatternCategory zurückgibt. Verwenden Sie Smart Pointer (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, geben Sie nullptr zurück.
main.cpp: Lesen Sie eine einzelne Eingabe ein – den Namen eines Entwurfsmusters.
Erstellen Sie einen PatternClassifier und verwenden Sie ihn, um das eingegebene Muster zu klassifizieren. Wenn das Muster erkannt wird, geben Sie Folgendes aus:
```
[PatternName] is a [CategoryName] pattern
Purpose: [CategoryPurpose]
```
Wenn das Muster nicht erkannt wird, geben Sie 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, während Sie Vererbung, Polymorphismus und Smart Pointer üben – alles Konzepte, die Sie bereits beherrschen. Die Struktur mit mehreren Dateien spiegelt wider, wie reale Projekte verwandte Klassen organisieren.

Spickzettel

Design-Patterns (Entwurfsmuster) sind wiederverwendbare Lösungen für häufig auftretende Probleme im Softwaredesign. Sie dienen als Vorlagen für die Strukturierung von Klassen und Objekten, nicht als direkt kopierbarer Code.

Design-Patterns werden in drei Hauptkategorien unterteilt:

Kategorie	Zweck	Beispiele
Erzeugungsmuster (Creational)	Mechanismen zur Objekterzeugung	Singleton, Factory, Builder
Strukturmuster (Structural)	Zusammensetzung von Klassen und Objekten	Adapter, Decorator, Composite
Verhaltensmuster (Behavioral)	Interaktion und Verantwortlichkeit von Objekten	Observer, Strategy, Command

Vorteile von Design-Patterns:

Bieten ein gemeinsames Vokabular für Entwickler
Vermeiden das Neuerfinden von Lösungen für gängige Probleme
Machen Code flexibler und wartbarer

In C++ nutzen Design-Patterns OOP-Funktionen wie Vererbung, Polymorphie, abstrakte Klassen und Templates.

Probier es selbst

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

int main() {
    // Lies den Musternamen 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;
}