Introduktion till fabriksmönstret
Ett designmönster är en metod för att lösa återkommande problem inom mjukvarudesign. Factory Pattern är ett av designmönstren som hjälper till att skapa objekt på ett flexibelt och frikopplat sätt.
Factory Pattern är ett kreativt designmönster i C++ som gör det möjligt att skapa objekt utan att explicit känna till objektets klass. Det ger ett sätt att kapsla in komplex objektskapande logik inom en separat fabriksklass. Detta görs genom att definiera ett gemensamt gränssnitt för att skapa objekt, där den specifika klassen för objektet bestäms vid körning.
Istället för att skapa ett objekt direkt använder vi fabriksmetoden för att ge oss en instans av objektet vi vill ha. På så sätt kan vi dölja de komplicerade stegen som är involverade i att skapa objektet och göra det enklare att ändra eller modifiera objektet i framtiden.
Varför använda Factory Pattern?
Det finns flera anledningar till att vi kanske vill använda fabriksmönstret. En anledning är att den tillåter frikoppling av kod från specifika klasser. Genom att använda en fabriksmetod kan vi enkelt byta ut en klass mot en annan utan att behöva ändra någon annan kod och göra den mer effektiv.
En annan anledning att använda fabriksmönstret är att det kan göra koden mer testbar. Fabriksmönster tillåter oss att testa kod genom att skapa skenobjekt.
Här är några av de fler anledningarna till att fabriksmönstret används i C++:
- Factory Method-mönstret används när en klass inte i förväg vet vilka objekt den behöver skapa.
- Mönstret används när en klass förlitar sig på sina underklasser för att specificera de objekt den skapar.
- Det är användbart när du vill kapsla in logiken för att skapa ett komplext objekt på ett ställe.
Exempel på fabriksmönster i C++
I C++ kan vi implementera fabriksmönstret genom att definiera en abstrakt basklass med en virtuell fabriksmetod. Denna metod bör returnera en pekare till den önskade klassinstansen. Efter det kan vi härleda konkreta klasser från denna basklass och åsidosätta fabriksmetoden för att returnera en instans av lämplig klass.
Här är ett exempel på hur vi kan använda den här implementeringen av fabriksmönstret:
#includeanvänder namnutrymme std ;
klass Form {
offentlig :
virtuell tomhet dra ( ) = 0 ;
statisk Form * skapa form ( int typ ) ;
} ;
klass Cirkel : offentlig form {
offentlig :
tomhet dra ( ) {
cout << 'Rita en cirkel.' << endl ;
}
} ;
klass rektangel : offentlig form {
offentlig :
tomhet dra ( ) {
cout << 'Rita en rektangel.' << endl ;
}
} ;
Form * Form :: skapa form ( int typ ) {
om ( typ == 1 ) {
lämna tillbaka ny cirkel ( ) ;
} annan om ( typ == 2 ) {
lämna tillbaka ny rektangel ( ) ;
} annan {
lämna tillbaka nullptr ;
}
}
int huvud ( ) {
Form * cirkel = Form :: skapa form ( 1 ) ;
cirkel -> dra ( ) ;
Form * rektangel = Form :: skapa form ( 2 ) ;
rektangel -> dra ( ) ;
lämna tillbaka 0 ;
}
I det här exemplet har vi en Shape-klass med två härledda klasser: Circle och Rectangle. Shape-klassen har en ren virtuell funktion draw(), som implementeras av de härledda klasserna. Klassen Shape har också en statisk funktion createShape(int type), som fungerar som en fabriksmetod för att skapa instanser av de härledda klasserna baserat på den angivna typen. Draw()-funktionen anropas på de skapade objekten för att visa deras specifika beteende.
Slutsats
Factory Pattern är ett kreativt designmönster i C++ som gör det möjligt att skapa objekt utan att explicit känna till objektets klass. Det ger ett förenklat gränssnitt för att skapa objekt genom att dölja den komplexa skapande logiken bakom en fabriksklass. Detta görs genom att definiera ett gemensamt gränssnitt för att skapa objekt, där den specifika klassen för objektet bestäms vid körning. Läs mer om fabriksmönster i den här artikeln.