Једноструки образац се обично користи када треба да имате један, дељени ресурс коме треба приступити глобално, као што је веза са базом података, логер или менаџер конфигурације. Применом једне инстанце, омогућава више делова програма да приступе и модификују исти објекат, промовишући конзистентност података и смањујући потребу за глобалним варијаблама. Синглетон се може користити као кеш објеката где се често коришћени или скупи за креирање објекти чувају и поново користе у целој апликацији. Овај приступ помаже у побољшању перформанси избегавањем сувишног креирања и иницијализације објеката.
У овом чланку ћемо објаснити креирање синглетона и демонстрирати пример стилизације синглетона у Ц++ програму.
Пример 1: Креирање једноставног синглетона са жељном иницијализацијом
Једноставан синглетон са раном иницијализацијом је образац дизајна који обезбеђује да се креира само једна инстанца класе, и да се креира жељно током статичке иницијализације.
Показаћемо основни исечак кода за креирање једноставног синглетона са жељном иницијализацијом. Почнимо са програмом:
#инцлуде <иостреам>
класа Синглтон {
приватни :
статичне Синглетон * инстанце ;
Синглетон ( ) { }
јавности :
статичне Синглетон * гетИнстанце ( ) {
повратак инстанце ;
}
} ;
Синглетон * Синглетон :: инстанце = нови Синглтон ( ) ;
инт главни ( ) {
Синглетон * синглетонИнстанце1 = Синглетон :: гетИнстанце ( ) ;
Синглетон * синглетонИнстанце2 = Синглетон :: гетИнстанце ( ) ;
стд :: цоут << 'синглетонлетонИнстанце1: ' << синглетонИнстанце1 << стд :: ендл ;
стд :: цоут << 'синглетонлетонИнстанце2: ' << синглетонИнстанце2 << стд :: ендл ;
повратак 0 ;
}
Код укључује заглавље <иостреам> које пружа функционалност за рад са улазним и излазним токовима као што је „стд::цоут“.
Након укључивања датотеке заглавља, дефинишемо класу “Синглетон” која представља имплементацију синглетон шаблона. Има приватни конструктор и приватну статичку променљиву члана под називом „инстанца“.
Затим се функција гетИнстанце() имплементира као јавна статичка функција члана класе „Синглетон“. Враћа инстанцу синглетона која је ускладиштена у инстанци статичке променљиве члана. Инстанца статичке променљиве члана је дефинисана и иницијализована ван класе са „Синглетон* Синглетон::инстанце = нев Синглетон();“. Ова линија жељно иницијализује инстанцу класе „Синглетон“ током статичке иницијализације.
У функцији маин() декларишемо два показивача, “синглетонИнстанце1” и “синглетонИнстанце2”, и додељујемо вредност која се враћа позивом Синглетон::гетИнстанце(). Пошто се инстанца жељно иницијализује, оба показивача указују на исту инстанцу. Наредбе „стд::цоут“ штампају меморијске адресе „синглетонИнстанце1“ и „синглетонИнстанце2“ на конзоли користећи оператор „<<“ и „стд::ендл“.
Код се завршава са „ретурн 0” што указује на успешно извршење програма.
Када покренете овај код, излаз је отприлике овако:
Излаз приказује меморијске адресе „синглетонИнстанце1“ и „синглетонИнстанце2“. Пошто су оба показивача додељена са истом инстанцом која се добија из Синглетон::гетИнстанце(), они имају исту меморијску адресу. Ово показује како синглетон образац гарантује да постоји једна инстанца класе и да будући позиви гетИнстанце() увек резултирају истом инстанцом.
Пример 2: Имплементација једноструког узорка са лењом иницијализацијом
Ова демонстрација објашњава имплементацију синглетон шаблона са лењом иницијализацијом и показује његову употребу у функцији маин(). Корак по корак објашњење исечка кода је дато након овог програма:
#инцлуде<иостреам>класа Синглтон {
приватни :
статичне Синглетон * инстанце ;
Синглетон ( ) {
стд :: цоут << „Синглетон инстанца креирана.“ << стд :: ендл ;
}
јавности :
статичне Синглетон * гетИнстанце ( ) {
ако ( инстанце == нуллптр ) {
инстанце = нови Синглтон ( ) ;
}
повратак инстанце ;
}
празнина сховМессаге ( ) {
стд :: цоут << 'Здраво из Синглтона!' << стд :: ендл ;
}
~Синглтон ( ) {
стд :: цоут << „Синглтон инстанца уништена.“ << стд :: ендл ;
}
} ;
Синглетон * Синглетон :: инстанце = нуллптр ;
инт главни ( ) {
Синглетон * синглетонИнстанце1 = Синглетон :: гетИнстанце ( ) ;
синглетонИнстанце1 -> сховМессаге ( ) ;
Синглетон * синглетонИнстанце2 = Синглетон :: гетИнстанце ( ) ;
синглетонИнстанце2 -> сховМессаге ( ) ;
повратак 0 ;
}
Програм почиње додавањем датотеке заглавља <иостреам> да би извршио улазне/излазне задатке. Затим декларишемо и дефинишемо класу „Синглетон“. Једина инстанца класе се чува унутар приватне статичке променљиве члана под називом „инстанца“.
Кад год се позове конструктор класе „Синглетон“, он генерише инстанцу класе „Синглетон“. Он шаље поруку „Синглетон инстанце цреатед“ на конзолу користећи „стд::цоут << … << стд::ендл;“. Конструктор нема никакве параметре јер је подразумевани конструктор. Дефинисан је као Синглетон() без икаквих аргумената. Проглашавамо га приватним што значи да се може позвати само из класе. Ово спречава директну инстанцију класе „Синглетон“ и осигурава да је једини начин да се добије инстанца преко функције гетИнстанце().
Метод гетИнстанце() класе „Синглетон“ је декларисан као јавна статичка функција члана. Он је у улози успостављања и одобравања приступа појединачној инстанци. Унутар гетИнстанце() проверава да ли је инстанца „нуллптр“. Ако јесте, што значи да инстанца већ није присутна, она користи приватни конструктор за инстанцирање новог објекта класе „Синглетон“.
Функција сховМессаге() је једноставна функција члана која приказује „Здраво из Синглетона!“ порука. Дефинисан је деструктор синглетона. Позива се имплицитно када се програм оконча и одштампа „Синглетон инстанце уништено“. порука која указује да је синглетон инстанца уништена. Инстанца статичке променљиве члана је иницијално дефинисана као „нуллптр“.
Инт маин() започиње дефиницију функције маин(). Затим, „Синглетон* синглетонИнстанце1 = Синглетон::гетИнстанце();“ позива функцију гетИнстанце() класе „Синглетон“ да би добио показивач на инстанцу појединачног типа. Додељује овај показивач променљивој „синглетонИнстанце1“.
Након тога, „синглетонИнстанце1->сховМессаге();“ користи оператор стрелице (->) за позивање функције сховМессаге() на показивачу „синглетонИнстанце1“. Ова функција приказује поруку која је наведена у њој на конзоли. Након тога, „Синглетон* синглетонИнстанце2 = Синглетон::гетИнстанце();“ поново позива функцију гетИнстанце(), добијајући други показивач на појединачну инстанцу. Овог пута, додељује показивач променљивој „синглетонИнстанце2“. „синглетонИнстанце2->сховМессаге();“ позива функцију сховМессаге() на показивачу „синглетонИнстанце2“. Ова функција приказује „Хелло фром Синглетон!“ поново поруку на конзолу.
На крају, „врати 0;“ означава крај функције маин(), а програм враћа вредност 0 која означава успешно извршење програма.
Ево излаза претходно објашњеног исечка кода:
Овај резултат потврђује да класа „Синглетон“ обезбеђује креирање само једне инстанце и да даљи позиви функције гетИнстанце() поуздано дају исту инстанцу.
Закључак
Креирање синглетона у Ц++ је веома користан концепт. У овом посту смо у почетку покрили уводни део синглетон-а. Штавише, направљена су два примера за имплементацију синглетона у Ц++. Прва илустрација показује имплементацију жељне синглетон иницијализације. Док је имплементација лење иницијализације синглетон шаблона дата у другом примеру овог чланка. Штавише, снимци произведеног излаза се такође приказују за одговарајуће програме.