Inleiding tot het fabriekspatroon
Een ontwerppatroon is een methode om terugkerende problemen bij het ontwerpen van software op te lossen. Het Factory Pattern is een van de ontwerppatronen die helpen om objecten op een flexibele en ontkoppelde manier te creëren.
Het fabriekspatroon is een creatief ontwerppatroon in C ++ waarmee objecten kunnen worden gemaakt zonder de klasse van het object expliciet te kennen. Het biedt een manier om complexe logica voor het maken van objecten in een afzonderlijke fabrieksklasse in te kapselen. Dit wordt gedaan door een gemeenschappelijke interface te definiëren voor het maken van objecten, waarbij de specifieke klasse van het object tijdens runtime wordt bepaald.
In plaats van direct een object te maken, gebruiken we de fabrieksmethode om ons een instantie te geven van het object dat we willen. Op deze manier kunnen we de gecompliceerde stappen die betrokken zijn bij het maken van het object verbergen en het eenvoudiger maken om het object in de toekomst te wijzigen of aan te passen.
Waarom het fabriekspatroon gebruiken?
Er zijn verschillende redenen waarom we het fabriekspatroon zouden willen gebruiken. Een reden is dat het ontkoppeling van code van specifieke klassen mogelijk maakt. Door een fabrieksmethode te gebruiken, kunnen we eenvoudig de ene klasse vervangen door de andere zonder enige andere code te hoeven wijzigen en deze efficiënter te maken.
Een andere reden om het fabriekspatroon te gebruiken, is dat het de code testbaarder kan maken. Met fabriekspatronen kunnen we code testen door namaakobjecten te maken.
Hier zijn enkele van de meer redenen waarom het fabriekspatroon wordt gebruikt in C ++:
- Het Factory Method-patroon wordt gebruikt wanneer een klasse niet van tevoren weet welke objecten hij moet maken.
- Het patroon wordt gebruikt wanneer een klasse afhankelijk is van zijn subklassen om de objecten te specificeren die hij maakt.
- Het is handig wanneer u de logica voor het maken van een complex object op één plaats wilt inkapselen.
Voorbeeld van fabriekspatroon in C ++
In C++ kunnen we het fabriekspatroon implementeren door een abstracte basisklasse te definiëren met een virtuele fabrieksmethode. Deze methode zou een verwijzing naar de gewenste klasse-instantie moeten teruggeven. Daarna kunnen we concrete klassen afleiden uit deze basisklasse en de fabrieksmethode overschrijven om een instantie van de juiste klasse te retourneren.
Hier is een voorbeeld van hoe we deze implementatie van het fabriekspatroon zouden kunnen gebruiken:
#includenamespace std; gebruiken ;
klasse Vorm {
openbaar :
virtueel leegte tekenen ( ) = 0 ;
statisch Vorm * creëerVorm ( int type ) ;
} ;
klasse Cirkel : openbare vorm {
openbaar :
leegte tekenen ( ) {
cout << 'Een cirkel tekenen.' << eindel ;
}
} ;
klasse Rechthoek : openbare vorm {
openbaar :
leegte tekenen ( ) {
cout << 'Een rechthoek tekenen.' << eindel ;
}
} ;
Vorm * Vorm :: creëerVorm ( int type ) {
als ( type == 1 ) {
opbrengst nieuwe Cirkel ( ) ;
} anders als ( type == 2 ) {
opbrengst nieuwe rechthoek ( ) ;
} anders {
opbrengst nulptr ;
}
}
int voornaamst ( ) {
Vorm * cirkel = Vorm :: creëerVorm ( 1 ) ;
cirkel -> tekenen ( ) ;
Vorm * rechthoek = Vorm :: creëerVorm ( 2 ) ;
rechthoek -> tekenen ( ) ;
opbrengst 0 ;
}
In dit voorbeeld hebben we een Shape-klasse met twee afgeleide klassen: Circle en Rectangle. De Shape-klasse heeft een pure virtuele functie draw(), die wordt geïmplementeerd door de afgeleide klassen. De Shape-klasse heeft ook een statische functie createShape(int type), die fungeert als een fabrieksmethode om instanties van de afgeleide klassen te maken op basis van het opgegeven type. De functie draw() wordt aangeroepen op de gemaakte objecten om hun specifieke gedrag te demonstreren.
Conclusie
Het fabriekspatroon is een creatief ontwerppatroon in C ++ waarmee objecten kunnen worden gemaakt zonder de klasse van het object expliciet te kennen. Het biedt een vereenvoudigde interface voor het maken van objecten door de complexe aanmaaklogica achter een fabrieksklasse te verbergen. Dit wordt gedaan door een gemeenschappelijke interface te definiëren voor het maken van objecten, waarbij de specifieke klasse van het object tijdens runtime wordt bepaald. Lees meer over fabriekspatronen in dit artikel.