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.
Aufgabe
EinfachErstellen 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
Documentmit einer rein virtuellen Methodegenerate(), 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ückHTMLReport:generate()gibt"Generating HTML Report"zurückPDFInvoice:generate()gibt"Generating PDF Invoice"zurückHTMLInvoice: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 einenstd::unique_ptr<Document>zurückgeben, der auf das passende konkrete Dokument verweist. Gib bei ungültigen Kombinationennullptrzurück.Erstelle anschließend eine abstrakte Fabrikklasse namens
DocumentFactorymit zwei rein virtuellen Methoden:createReport(): gibt einstd::unique_ptr<Document>zurückcreateInvoice(): gibt einstd::unique_ptr<Document>zurück
Implementiere zwei konkrete Fabriken:
PDFFactory: erstelltPDFReportundPDFInvoiceHTMLFactory: erstelltHTMLReportundHTMLInvoice
DocumentService.h: Erstelle einen Dienst, der die abstrakte Fabrik verwendet.Definiere eine Klasse
DocumentService, die in ihrem Konstruktor einstd::unique_ptr<DocumentFactory>entgegennimmt. Sie soll eine Methode namensgenerateAllDocuments()enthalten, die mithilfe der Fabrik sowohl einen Bericht als auch eine Rechnung erstellt und anschließend das Ergebnis des Aufrufs vongenerate()für jedes Dokument ausgibt, jeweils in einer eigenen Zeile.main.cpp: Führe beide Fabrikansätze vor.Lies zwei Eingaben ein:
- Einen Dokumenttyp (
reportoderinvoice) - Ein Format (
pdfoderhtml)
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
DocumentServicemit der passenden Fabrik, abhängig von der Formateingabe (verwendePDFFactoryfürpdf,HTMLFactoryfürhtml). RufegenerateAllDocuments()auf, um zu zeigen, wie die abstrakte Fabrik eine Familie verwandter Dokumente erstellt.- Einen Dokumenttyp (
Zum Beispiel mit den Eingaben report und pdf:
Generating PDF Report
Generating PDF Report
Generating PDF InvoiceMit den Eingaben invoice und html:
Generating HTML Invoice
Generating HTML Report
Generating HTML InvoiceBeachte, 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;
}
Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.
Alle Lektionen in Objektorientierte Programmierung
1Grundlagen der OOP
Externe DateienC++ Build & KompilierungHeader-Dateien & QuelldateienNamespaces & GültigkeitsbereichEinführung in OOP mit C++Klassen vs. ObjekteDer „this“-ZeigerMethoden (Member-Funktionen)Attribute (Datenmember)Grundlagen zu Ctors & DtorsRückblick – Einfacher Taschenrechner4Klassenattribute
Instanz- vs. statische MemberGetter und SetterConst-MemberfunktionenMutable-SchlüsselwortStatische Methoden und VariablenFriend-Funktionen und -KlassenZusammenfassung – Bankkontoverwaltung7Vererbung
Grundlagen der VererbungZugriffsebenen bei der VererbungAufrufreihenfolge von Ctor & DtorÜberschreiben von MethodenVirtuelle Funktionen & VTableMehrfachvererbungVirtuelle VererbungRückblick – Mitarbeiterhierarchie10STL-Übersicht
STL-Übersicht & PhilosophieSTL-ContainerIteratorenSTL-AlgorithmenFunktoren & Lambda-AusdrückeRückblick – Worthäufigkeit13Entwurfsmuster Teil 1
Einführung in EntwurfsmusterSingleton-MusterFactory und Abstract FactoryBuilder-MusterBeobachter-MusterStrategie-Muster2Speicherverwaltung
Stack- vs. Heap-SpeicherZeiger und ReferenzenDynamischer Speicher (new/delete)Intelligente Zeiger in C++RAII in C++Rückblick – Dynamischer Array-Manager5Kapselung
Zugriffsbezeichner in C++Zugriffsbezeichner im DetailInformationsverbergungStruct vs. KlasseVerschachtelte und innere KlassenWiederholung – Studierendenverwaltungssystem8Polymorphie
Polymorphie zur Compilezeit vs. LaufzeitFunktionsüberladungVirtuelle Funktionen erneut betrachtetRein virtuelle FunktionenAbstrakte KlassenInterface-Design in C++Dynamic Casting & RTTIRückblick – Shape-Calculator3Konstruktoren & Destruktoren
StandardkonstruktorParametrisierter KonstruktorKopierkonstruktorMove-KonstruktorKonstruktor-InitialisierungslistenDelegierende KonstruktorenDestruktor im DetailDrei-/Fünf-/Null-RegelZusammenfassung – String-Klasse6Operatorüberladung
Einführung in die OperatorüberladungArithmetische OperatorüberladungVergleichsoperatorüberladungStream-OperatorenZuweisungsoperatorüberladungÜberladung der Operatoren [] und ()TypkonvertierungsoperatorenWiederholung – Matrix-Klasse9Templates
FunktionstemplatesKlassen-TemplatesTemplate-SpezialisierungVariadische TemplatesGrundlagen zu SFINAE und Type TraitsRückblick – Generischer ContainerÜbe selbstständig: Online-C++-Compiler