Panimula sa Pattern ng Pabrika
Ang pattern ng disenyo ay isang paraan ng paglutas ng mga umuulit na problema sa disenyo ng software. Ang Factory Pattern ay isa sa mga pattern ng disenyo na tumutulong upang lumikha ng mga bagay sa isang flexible at decoupled na paraan.
Ang Factory Pattern ay isang creational design pattern sa C++ na nagbibigay-daan para sa paggawa ng object nang hindi malinaw na nalalaman ang klase ng object. Nagbibigay ito ng paraan upang i-encapsulate ang kumplikadong lohika ng paglikha ng bagay sa loob ng isang hiwalay na klase ng pabrika. Ginagawa ito sa pamamagitan ng pagtukoy ng isang karaniwang interface para sa paglikha ng mga bagay, kung saan ang partikular na klase ng bagay ay tinutukoy sa runtime.
Sa halip na direktang gumawa ng object, ginagamit namin ang factory method para bigyan kami ng instance ng object na gusto namin. Sa ganitong paraan, maaari nating itago ang mga kumplikadong hakbang na kasangkot sa paglikha ng bagay at gawing mas simple ang pagbabago o pagbabago ng bagay sa hinaharap.
Bakit gagamitin ang Factory Pattern?
Mayroong ilang mga dahilan kung bakit maaaring gusto naming gamitin ang factory pattern. Ang isang dahilan ay pinapayagan nito ang pag-decoupling ng code mula sa mga partikular na klase. Sa pamamagitan ng paggamit ng factory method, madali nating mailipat ang isang klase para sa isa pa nang hindi kinakailangang baguhin ang anumang code at gawin itong mas mahusay.
Ang isa pang dahilan para gamitin ang factory pattern ay na maaari nitong gawing mas masusubok ang code. Nagbibigay-daan sa amin ang mga pattern ng factory na subukan ang code sa pamamagitan ng paggawa ng mga mock object.
Narito ang ilan sa higit pang mga dahilan kung bakit ginagamit ang pattern ng factory sa C++:
- Ginagamit ang pattern ng Factory Method kapag hindi alam ng isang klase nang maaga kung anong mga bagay ang kailangan nitong gawin.
- Ginagamit ang pattern kapag umaasa ang isang klase sa mga subclass nito upang tukuyin ang mga bagay na nilikha nito.
- Ito ay kapaki-pakinabang kapag nais mong i-encapsulate ang lohika para sa paglikha ng isang kumplikadong bagay sa isang lugar.
Halimbawa ng Factory Pattern sa C++
Sa C++, maaari nating ipatupad ang factory pattern sa pamamagitan ng pagtukoy ng abstract base class na may virtual factory method. Ang pamamaraang ito ay dapat magbalik ng isang pointer sa nais na halimbawa ng klase. Pagkatapos nito, maaari tayong kumuha ng mga kongkretong klase mula sa base class na ito at i-override ang factory method upang maibalik ang isang instance ng naaangkop na klase.
Narito ang isang halimbawa kung paano namin magagamit ang pagpapatupad na ito ng pattern ng factory:
#includegamit ang namespace std ;
klase Hugis {
pampubliko :
virtual walang bisa gumuhit ( ) = 0 ;
static Hugis * createShape ( int uri ) ;
} ;
bilog ng klase : pampublikong Hugis {
pampubliko :
walang bisa gumuhit ( ) {
cout << 'Pagguhit ng bilog.' << endl ;
}
} ;
parihaba ng klase : pampublikong Hugis {
pampubliko :
walang bisa gumuhit ( ) {
cout << 'Pagguhit ng isang parihaba.' << endl ;
}
} ;
Hugis * Hugis :: createShape ( int uri ) {
kung ( uri == 1 ) {
bumalik bagong Circle ( ) ;
} iba pa kung ( uri == 2 ) {
bumalik bagong Parihaba ( ) ;
} iba pa {
bumalik nullptr ;
}
}
int pangunahing ( ) {
Hugis * bilog = Hugis :: createShape ( 1 ) ;
bilog -> gumuhit ( ) ;
Hugis * parihaba = Hugis :: createShape ( 2 ) ;
parihaba -> gumuhit ( ) ;
bumalik 0 ;
}
Sa halimbawang ito, mayroon kaming klase ng Shape na may dalawang nagmula na klase: Circle at Rectangle. Ang klase ng Shape ay may purong virtual function na draw(), na ipinapatupad ng mga nagmula na klase. Ang klase ng Shape ay mayroon ding static na function na createShape(int type), na gumaganap bilang isang factory method upang lumikha ng mga pagkakataon ng mga nagmula na klase batay sa tinukoy na uri. Ang draw() function ay tinatawag sa mga nilikhang bagay upang ipakita ang kanilang partikular na pag-uugali.
Konklusyon
Ang Factory Pattern ay isang creational design pattern sa C++ na nagbibigay-daan para sa paggawa ng object nang hindi malinaw na nalalaman ang klase ng object. Nagbibigay ito ng pinasimple na interface para sa paglikha ng mga bagay sa pamamagitan ng pagtatago ng kumplikadong lohika ng paglikha sa likod ng isang factory class. Ginagawa ito sa pamamagitan ng pagtukoy ng isang karaniwang interface para sa paglikha ng mga bagay, kung saan ang partikular na klase ng bagay ay tinutukoy sa runtime. Magbasa nang higit pa tungkol sa mga pattern ng pabrika sa artikulong ito.