Karaniwang ginagamit ang singleton pattern kapag kailangan mong magkaroon ng iisa, nakabahaging mapagkukunan na dapat ma-access sa buong mundo gaya ng koneksyon sa database, logger, o configuration manager. Sa pamamagitan ng pagpapatupad ng isang pagkakataon, pinapayagan nito ang maraming bahagi ng programa na i-access at baguhin ang parehong bagay, na nagpo-promote ng pagkakapare-pareho ng data at binabawasan ang pangangailangan para sa mga pandaigdigang variable. Ang Singleton ay maaaring gamitin bilang isang object cache kung saan ang mga madalas na ginagamit o mahal na gagawing mga bagay ay iniimbak at muling ginagamit sa buong application. Nakakatulong ang diskarteng ito na mapabuti ang pagganap sa pamamagitan ng pag-iwas sa labis na paggawa at pagsisimula ng bagay.
Sa artikulong ito, ipapaliwanag namin ang paglikha ng singleton at magpapakita ng halimbawa ng pag-istilo ng singleton sa isang C++ program.
Halimbawa 1: Paglikha ng Simpleng Singleton na may Sabik na Pagsisimula
Ang isang simpleng singleton na may maagang pagsisimula ay isang pattern ng disenyo na nagsisiguro na isang instance lang ng isang klase ang nalilikha, at ito ay sabik na nilikha sa panahon ng static na pagsisimula.
Ipapakita namin ang pangunahing snippet ng code para sa paggawa ng isang simpleng singleton na may sabik na pagsisimula. Magsimula tayo sa programa:
#include
klaseng Singleton {
pribado :
static Singleton * halimbawa ;
Singleton ( ) { }
pampubliko :
static Singleton * getInstance ( ) {
bumalik halimbawa ;
}
} ;
Singleton * Singleton :: halimbawa = bagong Singleton ( ) ;
int pangunahing ( ) {
Singleton * singletonInstance1 = Singleton :: getInstance ( ) ;
Singleton * singletonInstance2 = Singleton :: getInstance ( ) ;
std :: cout << 'singletonletonInstance1: ' << singletonInstance1 << std :: endl ;
std :: cout << 'singletonletonInstance2: ' << singletonInstance2 << std :: endl ;
bumalik 0 ;
}
Kasama sa code ang
Pagkatapos isama ang header file, tinukoy namin ang klase na 'Singleton' na kumakatawan sa pagpapatupad ng singleton pattern. Mayroon itong pribadong tagabuo at isang pribadong static na variable ng miyembro na pinangalanang 'halimbawa'.
Pagkatapos, ang function na getInstance() ay ipinatupad bilang isang pampublikong static na function ng miyembro ng 'Singleton' na klase. Ibinabalik nito ang instance ng singleton na naka-store sa static na member variable na instance. Ang static na member variable na instance ay tinukoy at sinisimulan sa labas ng klase na may 'Singleton* Singleton::instance = new Singleton();'. Sinisimulan ng linyang ito ang instance ng 'Singleton' na klase nang sabik sa panahon ng static na pagsisimula.
Sa main() function, ipinapahayag namin ang dalawang pointer, 'singletonInstance1' at 'singletonInstance2', at itinalaga ang value na ibinalik sa pamamagitan ng pagtawag sa Singleton::getInstance(). Dahil sabik na nasimulan ang instance, ang parehong pointer ay tumuturo sa parehong instance. Ang mga pahayag na 'std::cout' ay nagpi-print ng mga memory address ng 'singletonInstance1' at 'singletonInstance2' sa console gamit ang '<<' operator at 'std::endl'.
Ang code ay nagtatapos sa isang 'return 0' na nagpapahiwatig ng isang matagumpay na pagpapatupad ng programa.
Kapag pinatakbo mo ang code na ito, ang output ay katulad nito:
Ang output ay nagpapakita ng mga memory address ng 'singletonInstance1' at 'singletonInstance2'. Dahil ang parehong mga pointer ay itinalaga na may parehong instance na nakuha mula sa Singleton::getInstance(), mayroon silang parehong memory address. Ito ay nagpapakita kung paano ginagarantiyahan ng singleton pattern na mayroong isang instance ng klase at na ang hinaharap na mga tawag sa getInstance() ay palaging nagreresulta sa parehong instance.
Halimbawa 2: Pagpapatupad ng Singleton Pattern na may Lazy Initialization
Ipinapaliwanag ng demonstration na ito ang pagpapatupad ng singleton pattern na may tamad na pagsisimula at ipinapakita ang paggamit nito sa main() function. Ang sunud-sunod na paliwanag ng snippet ng code ay ibinigay pagkatapos ng program na ito:
#includeklaseng Singleton {
pribado :
static Singleton * halimbawa ;
Singleton ( ) {
std :: cout << 'Nagawa ang singleton instance.' << std :: endl ;
}
pampubliko :
static Singleton * getInstance ( ) {
kung ( halimbawa == nullptr ) {
halimbawa = bagong Singleton ( ) ;
}
bumalik halimbawa ;
}
walang bisa showMessage ( ) {
std :: cout << 'Hello from Singleton!' << std :: endl ;
}
~Singleton ( ) {
std :: cout << 'Nasira ang singleton instance.' << std :: endl ;
}
} ;
Singleton * Singleton :: halimbawa = nullptr ;
int pangunahing ( ) {
Singleton * singletonInstance1 = Singleton :: getInstance ( ) ;
singletonInstance1 -> showMessage ( ) ;
Singleton * singletonInstance2 = Singleton :: getInstance ( ) ;
singletonInstance2 -> showMessage ( ) ;
bumalik 0 ;
}
Ang programa ay magsisimula sa pamamagitan ng pagdaragdag ng
Sa tuwing tinatawag ang constructor ng klase ng 'Singleton', bumubuo ito ng isang instance ng klase ng 'Singleton'. Inilalabas nito ang mensaheng 'Nalikha ang isang halimbawang single' sa console gamit ang 'std::cout << ... << std::endl;'. Ang constructor ay walang anumang mga parameter dahil ito ay isang default na constructor. Ito ay tinukoy bilang Singleton() nang walang anumang mga argumento. Idineklara namin ito bilang pribado na nangangahulugan na maaari lamang itong i-invoke mula sa loob ng klase. Pinipigilan nito ang isang direktang instantiation ng klase ng 'Singleton' at tinitiyak na ang tanging paraan upang makakuha ng isang instance ay sa pamamagitan ng function na getInstance().
Ang pamamaraang getInstance() ng klase ng 'Singleton' ay idineklara bilang isang pampublikong static na function ng miyembro. Ito ay nasa tungkulin ng pagtatatag at pagbibigay ng accessibility sa singleton instance. Sa loob ng getInstance(), sinusuri nito kung ang instance ay 'nullptr'. Kung ito ay, na nagpapahiwatig na ang instance ay hindi pa naroroon, ito ay gumagamit ng pribadong constructor upang i-instantiate ang isang bagong bagay ng 'Singleton' na klase.
Ang showMessage() function ay isang simpleng function ng miyembro na nagpapakita ng “Hello from Singleton!” mensahe. Ang destructor ng singleton ay tinukoy. Ito ay tinatawag na implicitly kapag ang programa ay nagwakas at nag-print ng 'Singleton instance na nawasak.' mensahe na nagpapahiwatig na ang singleton instance ay nawasak. Ang instance ng variable na static na miyembro ay unang tinukoy bilang 'nullptr'.
Sinisimulan ng int main() ang kahulugan ng main() function. Pagkatapos, ang 'Singleton* singletonInstance1 = Singleton::getInstance();' tinatawag ang getInstance() function ng 'Singleton' class upang makakuha ng pointer sa singleton instance. Itinalaga nito ang pointer na ito sa variable na 'singletonInstance1'.
Pagkatapos nito, ang 'singletonInstance1->showMessage();' gumagamit ng arrow operator (->) para tawagan ang showMessage() function sa pointer na “singletonInstance1”. Ipinapakita ng function na ito ang mensahe na tinukoy dito sa console. Pagkatapos, ang 'Singleton* singletonInstance2 = Singleton::getInstance();' Tinatawag muli ang getInstance() function, na kumukuha ng isa pang pointer sa singleton instance. Sa pagkakataong ito, itinatalaga nito ang pointer sa variable na 'singletonInstance2'. Ang 'singletonInstance2->showMessage();' tinatawag ang showMessage() function sa pointer na 'singletonInstance2'. Ipinapakita ng function na ito ang 'Hello from Singleton!' mensahe muli sa console.
Panghuli, 'ibalik ang 0;' nangangahulugan ng pagtatapos ng pangunahing() function, at ibinabalik ng programa ang halaga ng 0 na nagpapahiwatig ng matagumpay na pagpapatupad ng programa.
Narito ang output ng naunang ipinaliwanag na snippet ng code:
Kinukumpirma ng resultang ito na tinitiyak ng klase ng 'Singleton' ang paglikha ng isang instance lang at ang karagdagang mga tawag sa function na getInstance() ay mapagkakatiwalaang magbubunga ng parehong instance.
Konklusyon
Ang paglikha ng singleton sa C++ ay isang napaka-kapaki-pakinabang na konsepto. Sa post na ito, una naming tinakpan ang seksyon ng pagpapakilala ng singleton. Higit pa rito, dalawang halimbawa ang ginawa upang ipatupad ang singleton sa C++. Ang unang paglalarawan ay nagpapakita ng pagpapatupad ng sabik na singleton initialization. Samantalang ang lazy initialization na pagpapatupad ng singleton pattern ay ibinigay sa pangalawang halimbawa ng artikulong ito. Bukod dito, ang mga snapshot ng ginawang output ay ipinapakita din para sa kaukulang mga programa.