Het singleton-patroon wordt vaak gebruikt als u één enkele, gedeelde bron nodig heeft die wereldwijd toegankelijk moet zijn, zoals een databaseverbinding, een logger of een configuratiemanager. Door één exemplaar af te dwingen, kunnen meerdere delen van het programma hetzelfde object openen en wijzigen, waardoor de gegevensconsistentie wordt bevorderd en de behoefte aan globale variabelen wordt verminderd. Singleton kan worden gebruikt als objectcache, waarbij de vaak gebruikte of duur te maken objecten worden opgeslagen en hergebruikt in de hele applicatie. Deze aanpak helpt de prestaties te verbeteren door het maken en initialiseren van redundante objecten te voorkomen.
In dit artikel leggen we het maken van een singleton uit en demonstreren we een voorbeeld van het stileren van een singleton in een C++-programma.
Voorbeeld 1: Een eenvoudige Singleton maken met Eager-initialisatie
Een eenvoudige singleton met vroege initialisatie is een ontwerppatroon dat ervoor zorgt dat er slechts één instantie van een klasse wordt gemaakt, en deze wordt gretig gemaakt tijdens statische initialisatie.
We zullen het basiscodefragment demonstreren voor het maken van een eenvoudige singleton met enthousiaste initialisatie. Laten we beginnen met het programma:
#include
klasse Singleton {
privaat :
statisch Singleton * voorbeeld ;
Singleton ( ) { }
openbaar :
statisch Singleton * getInstance ( ) {
opbrengst voorbeeld ;
}
} ;
Singleton * Singleton :: voorbeeld = nieuwe Singleton ( ) ;
int voornaamst ( ) {
Singleton * singletonInstance1 = Singleton :: getInstance ( ) ;
Singleton * singletonInstance2 = Singleton :: getInstance ( ) ;
soa :: uit << 'singletonletonInstance1: ' << singletonInstance1 << soa :: eindl ;
soa :: uit << 'singletonletonInstance2: ' << singletonInstance2 << soa :: eindl ;
opbrengst 0 ;
}
De code bevat de header
Nadat we het headerbestand hebben opgenomen, definiëren we de klasse 'Singleton' die de implementatie van het singleton-patroon vertegenwoordigt. Het heeft een privéconstructor en een privé statische lidvariabele genaamd 'instance'.
Vervolgens wordt de functie getInstance() geïmplementeerd als een openbare statische lidfunctie van de klasse “Singleton”. Het retourneert de instantie van de singleton die is opgeslagen in de instantie van de statische lidvariabele. De instantie van de statische lidvariabele wordt buiten de klasse gedefinieerd en geïnitialiseerd met “Singleton* Singleton::instance = new Singleton();”. Deze regel initialiseert de instantie van de klasse “Singleton” gretig tijdens statische initialisatie.
In de functie main() declareren we twee pointers, “singletonInstance1” en “singletonInstance2”, en wijzen we de waarde toe die wordt geretourneerd door de Singleton::getInstance() aan te roepen. Omdat de instantie gretig wordt geïnitialiseerd, wijzen beide verwijzingen naar dezelfde instantie. De “std::cout”-instructies drukken de geheugenadressen van “singletonInstance1” en “singletonInstance2” af naar de console met behulp van de “<<” operator en “std::endl”.
De code eindigt met een “return 0”, wat aangeeft dat het programma succesvol is uitgevoerd.
Wanneer u deze code uitvoert, is de uitvoer ongeveer als volgt:
De uitvoer toont de geheugenadressen van “singletonInstance1” en “singletonInstance2”. Omdat beide pointers zijn toegewezen aan dezelfde instantie die zijn verkregen van Singleton::getInstance(), hebben ze hetzelfde geheugenadres. Dit laat zien hoe het singleton-patroon garandeert dat er één exemplaar van de klasse is en dat de toekomstige aanroepen van getInstance() altijd in hetzelfde exemplaar resulteren.
Voorbeeld 2: Implementatie van Singleton-patronen met luie initialisatie
Deze demonstratie legt de implementatie van het singleton-patroon uit met luie initialisatie en toont het gebruik ervan in de functie main(). De stapsgewijze uitleg van het codefragment vindt u na dit programma:
#includeklasse Singleton {
privaat :
statisch Singleton * voorbeeld ;
Singleton ( ) {
soa :: uit << 'Singleton-instantie gemaakt.' << soa :: eindl ;
}
openbaar :
statisch Singleton * getInstance ( ) {
als ( voorbeeld == nulptr ) {
voorbeeld = nieuwe Singleton ( ) ;
}
opbrengst voorbeeld ;
}
leegte toon bericht ( ) {
soa :: uit << 'Hallo vanuit Singleton!' << soa :: eindl ;
}
~Singleton ( ) {
soa :: uit << 'Singleton-instantie vernietigd.' << soa :: eindl ;
}
} ;
Singleton * Singleton :: voorbeeld = nulptr ;
int voornaamst ( ) {
Singleton * singletonInstance1 = Singleton :: getInstance ( ) ;
singletonInstance1 -> toon bericht ( ) ;
Singleton * singletonInstance2 = Singleton :: getInstance ( ) ;
singletonInstance2 -> toon bericht ( ) ;
opbrengst 0 ;
}
Het programma begint met het toevoegen van het
Telkens wanneer de constructor van de klasse “Singleton” wordt aangeroepen, genereert deze een instantie van de klasse “Singleton”. Het stuurt het bericht “Singleton instance create” naar de console met behulp van de opdracht “std::cout << … << std::endl;”. De constructor heeft geen parameters omdat het een standaardconstructor is. Het wordt gedefinieerd als Singleton() zonder argumenten. We verklaren het als privé, wat betekent dat het alleen vanuit de klasse kan worden aangeroepen. Dit voorkomt een directe instantiatie van de klasse “Singleton” en zorgt ervoor dat de enige manier om een instantie te verkrijgen is via de functie getInstance().
De methode getInstance() van de klasse “Singleton” wordt gedeclareerd als een openbare statische lidfunctie. Het is de rol van het tot stand brengen en verlenen van toegankelijkheid tot de singleton-instantie. Binnen getInstance() wordt gecontroleerd of de instantie “nullptr” is. Als dit het geval is, wat aangeeft dat de instantie nog niet aanwezig is, gebruikt deze de privéconstructor om een nieuw object van de klasse “Singleton” te instantiëren.
De functie showMessage() is een eenvoudige lidfunctie die de melding 'Hallo van Singleton!' bericht. De vernietiger van singleton is gedefinieerd. Het wordt impliciet aangeroepen wanneer het programma wordt beëindigd en de 'Singleton-instance vernietigd' wordt afgedrukt. bericht dat aangeeft dat de singleton-instantie is vernietigd. De instantie van de statische lidvariabele wordt aanvankelijk gedefinieerd als “nullptr”.
De int main() start de definitie van de functie main(). Vervolgens wordt de tekst 'Singleton* singletonInstance1 = Singleton::getInstance();' roept de functie getInstance() van de klasse “Singleton” aan om een verwijzing naar de singleton-instantie te verkrijgen. Het wijst deze pointer toe aan de variabele “singletonInstance1”.
Daarna verschijnt de opdracht “singletonInstance1->showMessage();” gebruikt de pijloperator (->) om de functie showMessage() op de “singletonInstance1”-aanwijzer aan te roepen. Met deze functie wordt het bericht dat daarin is opgegeven, weergegeven op de console. Daarna de “Singleton* singletonInstance2 = Singleton::getInstance();” roept de functie getInstance() opnieuw aan, waardoor een nieuwe verwijzing naar de singleton-instantie wordt verkregen. Deze keer wijst het de pointer toe aan de variabele “singletonInstance2”. De “singletonInstance2->showMessage();” roept de functie showMessage() aan op de “singletonInstance2”-aanwijzer. Deze functie geeft het bericht 'Hallo van Singleton!' bericht opnieuw naar de console.
Ten slotte: 'retourneer 0;' betekent het einde van de functie main() en het programma retourneert de waarde 0, wat een succesvolle programma-uitvoering aangeeft.
Hier is de uitvoer van het eerder uitgelegde codefragment:
Dit resultaat bevestigt dat de klasse “Singleton” de creatie van slechts één instantie verzekert en dat verdere aanroepen van de functie getInstance() op betrouwbare wijze dezelfde instantie opleveren.
Conclusie
Het maken van een singleton in C++ is een zeer nuttig concept. In dit bericht hebben we aanvankelijk het introductiegedeelte van singleton besproken. Verder zijn er twee voorbeelden gemaakt om de singleton in C++ te implementeren. De eerste illustratie toont de implementatie van de enthousiaste singleton-initialisatie. Terwijl de luie initialisatie-implementatie van het singleton-patroon wordt gegeven in het tweede voorbeeld van dit artikel. Bovendien worden voor de betreffende programma's ook de momentopnamen van de geproduceerde output weergegeven.