Menu
CoddyTech

Factory und Abstract Factory

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

Das Factory-Muster delegiert die Objekterstellung an eine separate Methode oder Klasse und ermöglicht es dir, Objekte zu erstellen, ohne ihre genaue Klasse anzugeben. Das ist nützlich, wenn die Erstellungslogik komplex ist oder wenn du den Client-Code von konkreten Implementierungen entkoppeln möchtest.

Eine einfache Factory verwendet eine Methode, die je nach Eingabe unterschiedliche abgeleitete Typen zurückgibt:

#include <iostream>
#include <memory>

class Button {
public:
    virtual void render() = 0;
    virtual ~Button() = default;
};

class WindowsButton : public Button {
public:
    void render() override { std::cout << "Windows button\n"; }
};

class MacButton : public Button {
public:
    void render() override { std::cout << "Mac button\n"; }
};

// Fabrikfunktion
std::unique_ptr<Button> createButton(const std::string& os) {
    if (os == "windows") return std::make_unique<WindowsButton>();
    if (os == "mac") return std::make_unique<MacButton>();
    return nullptr;
}

Die Abstract Factory geht noch einen Schritt weiter, indem sie Familien zusammengehöriger Objekte erstellt. Anstelle einer einzelnen Factory-Methode hast du eine Factory-Schnittstelle mit mehreren Erstellungsmethoden:

class Checkbox {
public:
    virtual void check() = 0;
    virtual ~Checkbox() = default;
};

class WindowsCheckbox : public Checkbox {
public:
    void check() override { std::cout << "Windows checkbox\n"; }
};

class MacCheckbox : public Checkbox {
public:
    void check() override { std::cout << "Mac checkbox\n"; }
};

// Abstrakte Fabrik
class GUIFactory {
public:
    virtual std::unique_ptr<Button> createButton() = 0;
    virtual std::unique_ptr<Checkbox> createCheckbox() = 0;
    virtual ~GUIFactory() = default;
};

class WindowsFactory : public GUIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<WindowsButton>();
    }
    std::unique_ptr<Checkbox> createCheckbox() override {
        return std::make_unique<WindowsCheckbox>();
    }
};

Verwende Factory, wenn du eine flexible Objekterstellung brauchst, und Abstract Factory, wenn du sicherstellen musst, dass zusammengehörige Objekte konsistent zusammenarbeiten.

challenge icon

Aufgabe

Einfach

Erstellen wir ein Dokumentgenerierungssystem mit den Mustern Fabrik und Abstrakte Fabrik. Du erstellst ein System, das verschiedene Arten von Dokumenten (Berichte und Rechnungen) in unterschiedlichen Ausgabeformaten (PDF und HTML) generieren kann. Dabei wird gezeigt, wie Fabriken die Objekterstellung vom Client-Code entkoppeln.

Du organisierst deinen Code auf vier Dateien:

  • Document.h: Definiere die Produkthierarchie für Dokumente.

    Erstelle eine abstrakte Basisklasse Document mit einer rein virtuellen Methode generate(), die eine Zeichenkette zurückgibt, welche das generierte Dokument beschreibt, sowie einem virtuellen Destruktor.

    Erstelle anschließend vier konkrete Dokumentklassen:

    • PDFReport: generate() gibt "Generating PDF Report" zurück
    • HTMLReport: generate() gibt "Generating HTML Report" zurück
    • PDFInvoice: generate() gibt "Generating PDF Invoice" zurück
    • HTMLInvoice: generate() gibt "Generating HTML Invoice" zurück
  • DocumentFactory.h: Implementiere sowohl eine einfache Fabrikfunktion als auch eine abstrakte Fabrik.

    Erstelle zuerst eine einfache Fabrikfunktion namens createDocument, die zwei Zeichenketten entgegennimmt: einen Dokumenttyp ("report" oder "invoice") und ein Format ("pdf" oder "html"). Sie soll einen std::unique_ptr<Document> zurückgeben, der auf das passende konkrete Dokument verweist. Gib bei ungültigen Kombinationen nullptr zurück.

    Erstelle anschließend eine abstrakte Fabrikklasse namens DocumentFactory mit zwei rein virtuellen Methoden:

    • createReport(): gibt ein std::unique_ptr<Document> zurück
    • createInvoice(): gibt ein std::unique_ptr<Document> zurück

    Implementiere zwei konkrete Fabriken:

    • PDFFactory: erstellt PDFReport und PDFInvoice
    • HTMLFactory: erstellt HTMLReport und HTMLInvoice
  • DocumentService.h: Erstelle einen Dienst, der die abstrakte Fabrik verwendet.

    Definiere eine Klasse DocumentService, die in ihrem Konstruktor ein std::unique_ptr<DocumentFactory> entgegennimmt. Sie soll eine Methode namens generateAllDocuments() enthalten, die mithilfe der Fabrik sowohl einen Bericht als auch eine Rechnung erstellt und anschließend das Ergebnis des Aufrufs von generate() für jedes Dokument ausgibt, jeweils in einer eigenen Zeile.

  • main.cpp: Führe beide Fabrikansätze vor.

    Lies zwei Eingaben ein:

    1. Einen Dokumenttyp (report oder invoice)
    2. Ein Format (pdf oder html)

    Verwende zuerst die einfache Fabrikfunktion, um anhand der Eingaben ein Dokument zu erstellen. Gib das Ergebnis des Aufrufs von generate() für dieses Dokument aus.

    Gib dann eine Leerzeile aus.

    Erstelle als Nächstes ein DocumentService mit der passenden Fabrik, abhängig von der Formateingabe (verwende PDFFactory für pdf, HTMLFactory für html). Rufe generateAllDocuments() auf, um zu zeigen, wie die abstrakte Fabrik eine Familie verwandter Dokumente erstellt.

Zum Beispiel mit den Eingaben report und pdf:

Generating PDF Report

Generating PDF Report
Generating PDF Invoice

Mit den Eingaben invoice und html:

Generating HTML Invoice

Generating HTML Report
Generating HTML Invoice

Beachte, dass die einfache Fabrik anhand beider Parameter ein einzelnes Dokument erstellt, während die abstrakte Fabrik sicherstellt, dass alle von einem Dienst erstellten Dokumente dasselbe Format haben. Das ist der entscheidende Vorteil der Abstrakten Fabrik, wenn du Familien verwandter Objekte benötigst, die konsistent zusammenarbeiten.

Probier es selbst

#include <iostream>
#include <string>
#include <memory>
#include "Document.h"
#include "DocumentFactory.h"
#include "DocumentService.h"

using namespace std;

int main() {
    // Eingaben einlesen
    string documentType;
    string format;
    cin >> documentType;
    cin >> format;
    
    // TODO: Die einfache Factory-Funktion verwenden, um ein Dokument zu erstellen
    // basierend auf den Eingaben documentType und format
    // Das Ergebnis des Aufrufs von generate() für dieses Dokument ausgeben
    
    // Eine Leerzeile ausgeben
    cout << endl;
    
    // TODO: Einen DocumentService mit der passenden Factory erstellen
    // basierend auf der Eingabe format (PDFFactory für "pdf", HTMLFactory für "html")
    // generateAllDocuments() aufrufen, um die abstrakte Factory zu demonstrieren
    
    return 0;
}
quiz iconTeste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Objektorientierte Programmierung

Übe selbstständig: Online-C++-Compiler