Singleton-mønsteret bruges ofte, når du skal have en enkelt, delt ressource, der skal tilgås globalt, såsom en databaseforbindelse, en logger eller en konfigurationsmanager. Ved at håndhæve en enkelt instans giver det flere dele af programmet adgang til og ændre det samme objekt, hvilket fremmer datakonsistens og reducerer behovet for globale variabler. Singleton kan bruges som en objektcache, hvor de ofte brugte eller dyrt at oprette objekter gemmes og genbruges i hele applikationen. Denne tilgang hjælper med at forbedre ydeevnen ved at undgå oprettelse og initialisering af overflødige objekter.
I denne artikel vil vi forklare oprettelsen af en singleton og demonstrere et eksempel på stilisering af en singleton i et C++-program.
Eksempel 1: Oprettelse af en simpel singleton med ivrig initialisering
En simpel singleton med tidlig initialisering er et designmønster, der sikrer, at der kun oprettes én forekomst af en klasse, og den skabes ivrigt under statisk initialisering.
Vi vil demonstrere det grundlæggende kodestykke til at skabe en simpel singleton med ivrig initialisering. Lad os starte med programmet:
#include
klasse Singleton {
privat :
statisk Singleton * eksempel ;
Singleton ( ) { }
offentlig :
statisk Singleton * getInstance ( ) {
Vend tilbage eksempel ;
}
} ;
Singleton * Singleton :: eksempel = ny Singleton ( ) ;
int vigtigste ( ) {
Singleton * singletonInstance1 = Singleton :: getInstance ( ) ;
Singleton * singletonInstance2 = Singleton :: getInstance ( ) ;
std :: cout << 'singletonletonInstance1: ' << singletonInstance1 << std :: endl ;
std :: cout << 'singletonletonInstance2: ' << singletonInstance2 << std :: endl ;
Vend tilbage 0 ;
}
Koden inkluderer
Efter at have inkluderet header-filen, definerer vi 'Singleton'-klassen, som repræsenterer singleton-mønsterimplementeringen. Den har en privat konstruktør og en privat statisk medlemsvariabel ved navn 'instans'.
Derefter implementeres getInstance()-funktionen som en offentlig statisk medlemsfunktion af klassen 'Singleton'. Det returnerer forekomsten af den singleton, der er gemt i den statiske medlemsvariable forekomst. Den statiske medlemsvariabelinstans er defineret og initialiseret uden for klassen med 'Singleton* Singleton::instance = new Singleton();'. Denne linje initialiserer forekomsten af 'Singleton'-klassen ivrigt under statisk initialisering.
I main()-funktionen erklærer vi to pointere, 'singletonInstance1' og 'singletonInstance2', og tildeler den værdi, der returneres ved at kalde Singleton::getInstance(). Da instansen ivrigt initialiseres, peger begge pointere på den samme instans. 'std::cout'-sætningerne udskriver hukommelsesadresserne for 'singletonInstance1' og 'singletonInstance2' til konsollen ved hjælp af '<<'-operatoren og 'std::endl'.
Koden slutter med et 'retur 0', hvilket indikerer en vellykket programafvikling.
Når du kører denne kode, er outputtet noget som dette:
Udgangen viser hukommelsesadresserne for 'singletonInstance1' og 'singletonInstance2'. Da begge pointere er tildelt den samme instans, som er hentet fra Singleton::getInstance(), har de den samme hukommelsesadresse. Dette viser, hvordan singleton-mønsteret garanterer, at der er en enkelt forekomst af klassen, og at fremtidige kald til getInstance() altid resulterer i den samme forekomst.
Eksempel 2: Singleton-mønsterimplementering med doven initialisering
Denne demonstration forklarer singleton-mønsterimplementeringen med doven initialisering og viser dens brug i main()-funktionen. Trin-for-trin forklaringen af kodestykket findes efter dette program:
#includeklasse Singleton {
privat :
statisk Singleton * eksempel ;
Singleton ( ) {
std :: cout << 'Singleton instans oprettet.' << std :: endl ;
}
offentlig :
statisk Singleton * getInstance ( ) {
hvis ( eksempel == nullptr ) {
eksempel = ny Singleton ( ) ;
}
Vend tilbage eksempel ;
}
ugyldig showMessage ( ) {
std :: cout << 'Hej fra Singleton!' << std :: endl ;
}
~Singleton ( ) {
std :: cout << 'Singleton instans ødelagt.' << std :: endl ;
}
} ;
Singleton * Singleton :: eksempel = nullptr ;
int vigtigste ( ) {
Singleton * singletonInstance1 = Singleton :: getInstance ( ) ;
singletonInstance1 -> showMessage ( ) ;
Singleton * singletonInstance2 = Singleton :: getInstance ( ) ;
singletonInstance2 -> showMessage ( ) ;
Vend tilbage 0 ;
}
Programmet starter med at tilføje
Hver gang 'Singleton'-klassens konstruktør kaldes, genererer den en forekomst af 'Singleton'-klassen. Den udsender meddelelsen 'Singleton instans oprettet' til konsollen ved hjælp af 'std::cout << … << std::endl;'. Konstruktøren har ingen parametre, da den er en standardkonstruktør. Den er defineret som Singleton() uden nogen argumenter. Vi erklærer det som privat, hvilket betyder, at det kun kan påberåbes inde fra klassen. Dette forhindrer en direkte instansiering af 'Singleton'-klassen og sikrer, at den eneste måde at opnå en instans på er gennem getInstance()-funktionen.
'Singleton'-klassens getInstance()-metode er erklæret som en offentlig statisk medlemsfunktion. Det er i rollen med at etablere og give tilgængelighed til singleton-instansen. Inde i getInstance() tjekker den, om instansen er 'nullptr'. Hvis det er, hvilket betyder, at instansen ikke allerede er til stede, bruger den den private konstruktør til at instansiere et nyt objekt af klassen 'Singleton'.
ShowMessage()-funktionen er en simpel medlemsfunktion, der viser 'Hej fra Singleton!' besked. Destruktoren af singleton er defineret. Det kaldes implicit, når programmet afsluttes og udskriver 'Singleton-instansen ødelagt.' meddelelse, der angiver, at singleton-instansen er ødelagt. Den statiske medlemsvariabelinstans er oprindeligt defineret som 'nullptr'.
Int main() starter definitionen af main()-funktionen. Derefter 'Singleton* singletonInstance1 = Singleton::getInstance();' kalder getInstance()-funktionen i 'Singleton'-klassen for at få en pointer til singleton-forekomsten. Den tildeler denne markør til variablen 'singletonInstance1'.
Derefter vises 'singletonInstance1->showMessage();' bruger piloperatoren (->) til at kalde funktionen showMessage() på 'singletonInstance1'-markøren. Denne funktion viser den meddelelse, der er angivet i den, til konsollen. Bagefter vises 'Singleton* singletonInstance2 = Singleton::getInstance();' kalder funktionen getInstance() igen og henter endnu en pointer til singleton-instansen. Denne gang tildeler den markøren til variablen 'singletonInstance2'. 'singletonInstance2->showMessage();' kalder showMessage()-funktionen på 'singletonInstance2'-markøren. Denne funktion viser 'Hej fra Singleton!' besked igen til konsollen.
Til sidst, 'retur 0;' angiver slutningen af main()-funktionen, og programmet returnerer værdien 0, som angiver en vellykket programudførelse.
Her er outputtet af det tidligere forklarede kodestykke:
Dette resultat bekræfter, at klassen 'Singleton' sikrer oprettelsen af kun én instans, og at yderligere kald til funktionen getInstance() pålideligt giver den samme instans.
Konklusion
Oprettelse af en singleton i C++ er et meget nyttigt koncept. I dette indlæg dækkede vi indledningsvis introduktionssektionen af singleton. Ydermere er der produceret to eksempler for at implementere singletonen i C++. Den første illustration viser implementeringen af den ivrige singleton-initialisering. Mens den dovne initialiseringsimplementering af singleton-mønsteret er tilvejebragt i det andet eksempel i denne artikel. Desuden vises snapshots af det producerede output også for de tilsvarende programmer.