Singleton-mønsteret brukes ofte når du trenger å ha en enkelt, delt ressurs som bør nås globalt, for eksempel en databasetilkobling, en logger eller en konfigurasjonsbehandling. Ved å håndheve en enkelt forekomst, lar det flere deler av programmet få tilgang til og endre det samme objektet, noe som fremmer datakonsistens og reduserer behovet for globale variabler. Singleton kan brukes som en objektbuffer der ofte brukte eller dyre å lage objekter lagres og gjenbrukes gjennom hele applikasjonen. Denne tilnærmingen bidrar til å forbedre ytelsen ved å unngå redundant objektoppretting og initialisering.
I denne artikkelen vil vi forklare opprettelsen av en singleton og demonstrere et eksempel på stilisering av en singleton i et C++-program.
Eksempel 1: Opprette en enkel singleton med ivrig initialisering
En enkel singleton med tidlig initialisering er et designmønster som sikrer at bare én forekomst av en klasse blir opprettet, og den lages ivrig under statisk initialisering.
Vi vil demonstrere den grunnleggende kodebiten for å lage en enkel singleton med ivrig initialisering. La oss starte med programmet:
#include
klasse Singleton {
privat :
statisk Singleton * forekomst ;
Singleton ( ) { }
offentlig :
statisk Singleton * getInstance ( ) {
komme tilbake forekomst ;
}
} ;
Singleton * Singleton :: forekomst = nye Singleton ( ) ;
int hoved- ( ) {
Singleton * singletonInstance1 = Singleton :: getInstance ( ) ;
Singleton * singletonInstance2 = Singleton :: getInstance ( ) ;
std :: cout << 'singletonletonInstance1: ' << singletonInstance1 << std :: endl ;
std :: cout << 'singletonletonInstance2: ' << singletonInstance2 << std :: endl ;
komme tilbake 0 ;
}
Koden inkluderer
Etter å ha inkludert header-filen, definerer vi 'Singleton'-klassen som representerer singleton-mønsterimplementeringen. Den har en privat konstruktør og en privat statisk medlemsvariabel kalt 'forekomst'.
Deretter implementeres getInstance()-funksjonen som en offentlig statisk medlemsfunksjon av 'Singleton'-klassen. Den returnerer forekomsten av singletonen som er lagret i den statiske medlemsvariabelforekomsten. Den statiske medlemsvariabelforekomsten er definert og initialisert utenfor klassen med 'Singleton* Singleton::instance = new Singleton();'. Denne linjen initialiserer forekomsten av 'Singleton'-klassen ivrig under statisk initialisering.
I main()-funksjonen erklærer vi to pekere, 'singletonInstance1' og 'singletonInstance2', og tildeler verdien som returneres ved å kalle Singleton::getInstance(). Siden forekomsten er ivrig initialisert, peker begge pekerne til samme forekomst. 'std::cout'-setningene skriver ut minneadressene til 'singletonInstance1' og 'singletonInstance2' til konsollen ved å bruke '<<'-operatoren og 'std::endl'.
Koden avsluttes med en 'retur 0' som indikerer en vellykket programkjøring.
Når du kjører denne koden, er utdataene noe sånt som dette:
Utgangen viser minneadressene til 'singletonInstance1' og 'singletonInstance2'. Siden begge pekerne er tilordnet den samme forekomsten som er hentet fra Singleton::getInstance(), har de samme minneadresse. Dette demonstrerer hvordan singleton-mønsteret garanterer at det er en enkelt forekomst av klassen og at fremtidige kall til getInstance() alltid resulterer i samme forekomst.
Eksempel 2: Singleton Pattern Implementation med Lazy Initialization
Denne demonstrasjonen forklarer singleton-mønsterimplementeringen med lat initialisering og viser bruken i hoved()-funksjonen. Den trinnvise forklaringen av kodebiten er gitt etter dette programmet:
#includeklasse Singleton {
privat :
statisk Singleton * forekomst ;
Singleton ( ) {
std :: cout << 'Singleton forekomst opprettet.' << std :: endl ;
}
offentlig :
statisk Singleton * getInstance ( ) {
hvis ( forekomst == nullptr ) {
forekomst = nye Singleton ( ) ;
}
komme tilbake forekomst ;
}
tomrom Vis melding ( ) {
std :: cout << 'Hei fra Singleton!' << std :: endl ;
}
~Singleton ( ) {
std :: cout << 'Singleton instans ødelagt.' << std :: endl ;
}
} ;
Singleton * Singleton :: forekomst = nullptr ;
int hoved- ( ) {
Singleton * singletonInstance1 = Singleton :: getInstance ( ) ;
singletonInstance1 -> Vis melding ( ) ;
Singleton * singletonInstance2 = Singleton :: getInstance ( ) ;
singletonInstance2 -> Vis melding ( ) ;
komme tilbake 0 ;
}
Programmet starter med å legge til
Hver gang 'Singleton'-klassens konstruktør kalles, genererer den en forekomst av 'Singleton'-klassen. Den sender ut meldingen 'Singleton instans opprettet' til konsollen ved å bruke 'std::cout << … << std::endl;'. Konstruktøren har ingen parametere da den er en standard konstruktør. Den er definert som Singleton() uten noen argumenter. Vi erklærer den som privat, noe som betyr at den kun kan påberopes fra klassen. Dette forhindrer en direkte instansiering av 'Singleton'-klassen og sikrer at den eneste måten å få tak i en forekomst på er gjennom getInstance()-funksjonen.
'Singleton'-klassens getInstance()-metode er erklært som en offentlig statisk medlemsfunksjon. Det er i rollen som å etablere og gi tilgjengelighet til singleton-forekomsten. Inne i getInstance() sjekker den om forekomsten er 'nullptr'. Hvis den er det, noe som betyr at forekomsten ikke allerede er til stede, bruker den den private konstruktøren til å instansiere et nytt objekt av 'Singleton'-klassen.
ShowMessage()-funksjonen er en enkel medlemsfunksjon som viser 'Hei fra Singleton!' beskjed. Destruktoren til singleton er definert. Det kalles implisitt når programmet avsluttes og skriver ut 'Singleton-forekomsten ødelagt.' melding som indikerer at singleton-forekomsten er ødelagt. Den statiske medlemsvariabelforekomsten er i utgangspunktet definert som 'nullptr'.
Int main() starter definisjonen av main()-funksjonen. Deretter 'Singleton* singletonInstance1 = Singleton::getInstance();' kaller getInstance()-funksjonen til 'Singleton'-klassen for å få en peker til singleton-forekomsten. Den tildeler denne pekeren til variabelen 'singletonInstance1'.
Etter det, 'singletonInstance1->showMessage();' bruker piloperatoren (->) for å kalle opp showMessage()-funksjonen på 'singletonInstance1'-pekeren. Denne funksjonen viser meldingen som er spesifisert i den til konsollen. Etterpå, 'Singleton* singletonInstance2 = Singleton::getInstance();' kaller opp getInstance()-funksjonen igjen, og får en annen peker til singleton-forekomsten. Denne gangen tildeler den pekeren til variabelen 'singletonInstance2'. 'singletonInstance2->showMessage();' kaller opp showMessage()-funksjonen på 'singletonInstance2'-pekeren. Denne funksjonen viser 'Hei fra Singleton!' melding på nytt til konsollen.
Til slutt, 'retur 0;' angir slutten på hoved()-funksjonen, og programmet returnerer verdien av 0 som angir en vellykket programkjøring.
Her er resultatet av den tidligere forklarte kodebiten:
Dette resultatet bekrefter at 'Singleton'-klassen sikrer opprettelsen av bare én forekomst, og at ytterligere kall til getInstance()-funksjonen pålitelig gir den samme forekomsten.
Konklusjon
Å lage en singleton i C++ er et veldig nyttig konsept. I dette innlegget dekket vi innledningsvis introduksjonsdelen av singleton. Videre er det produsert to eksempler for å implementere singletonen i C++. Den første illustrasjonen viser implementeringen av den ivrige singleton-initialiseringen. Mens den late initialiseringsimplementeringen av singleton-mønsteret er gitt i det andre eksemplet i denne artikkelen. I tillegg vises øyeblikksbildene av det produserte resultatet også for de tilsvarende programmene.