Tags:    c++ En Singleton er et objekt der kun kan have en lovlig instans ad gangen, dette betyder at man kun kan have en enkelt singleton klasse ad gangen mens programmet kører. Hvis der forsøges at oprette en ny instans af klassen vil programmet generere en fejl, hvis det er i debug mode. Singleton klasser er meget nyttige i specielt computerspil til brug når man laver for eksempel fjender, lydadministratorer, objektadministratorer og så videre. De tilbyder adgang fra hele dit program via statiske members på klassen. Singletons er baseret på statiske pointere til klasser. Ved at holde en statisk pointer til instansen af klassen og ved at have en statisk klasse funktion der returnerer denne pointer, kan man altid vide om der er en aktiv instans af objektet, hvis det er tilfældet kan man så bruge denne instans, ellers melder programmet fejl. Nedenstående er en komplet implementation af en simpel singleton klasse.

#include<iostream>
#include<assert.h>

using namespace std;

/*Klasse definition*/
class CSingleton
{
private:
	static CSingleton * m_Singleton;
public:
	CSingleton();
	virtual ~CSingleton();
	static CSingleton * getSingleton(void);
};

CSingleton * CSingleton::m_Singleton;

CSingleton::CSingleton()
{
	assert (!m_Singleton);
	m_Singleton=this;
}

CSingleton * CSingleton::getSingleton()
{
	assert (m_Singleton);
	return m_Singleton;
}

CSingleton::~CSingleton()
{
assert(m_singleton);
m_singleton=NULL;
}

Ovenstående er implementationen af CSingleton klassen, der er en meget simple singleton klasse. Vi vil nu gennemgå koden trin for trin således man også forstår hvad der sker og ikke bare hovedløst implementerer en Singleton klasse på baggrund af ovenstående. Den første #include statement kommer vel næppe bag på nogen, det er input-output stream vi inkluderer, således vi blandt andet kan skrive til vores konsol. Anden linie (#include<assert.h>
) er måske ny for nogle. Vi inkluderer denne header i vores program således vi kan bruge kommandoen assert(BOOL), den vil jeg gennemgå når vi når til den linie. I Tredje kodelinie angiver vi at det er det namespace der hedder std vi vil bruge gennem vores kode, dette gør blandt andet at vi har fuld adgang til de funktioner der findes i dette namespace uden at skulle skrive eksempelvis std foran vores funktioner (std::cout<<”test”<<endl. Dette namespace hjælper egentligt ikke i dette lille program vi udvikler, men jeg kan godt lide atltid at have det med, således min kode er nemmere at tilpasse til andre namespaces senere hen. De næste 10 linier er vores klasse definition af Singleton klassen, bemærk at klassen hedder Csingleton i stedet for Singleton, dette er en almindelig navngivningsregel, at klasser bliver skrevet med et stort C foran således man kan se at det er en klasse man taler om. Det mest interessante i denne klasse definition er at der findes et statisk member /attribut i ’private’ scope der er en pointer til typen Csingleton, det vi lsige sig selv. Desuden indeholder klassedefinitionen en statisk metode til at returnere dette member/attribut. Da vores attribut m_singleton er erklæret statisk vil den have samme værdi alle de gange den bliver erklæret, det er rent faktisk dette vi bruger til at bygge vores singleton klasse ud fra. Alle andre metoder på denne klasse er constructor og destructor. Går vi videre fra klasse definitionen kommer vi til selve implementationen af vores klasse. Det første vi gør er at lave en ny instans af vores statiske variabel m_singleton (igen ser vi navngivningsreglen, denne gang sætter vi et m foran en variabel, for at vise at det er et member/attribut). Det der kan virke lidt tricky ved dette er at det rent faktisk er memberet fra klassen selv der er lavet som en pointer til objektet. At lave denne pointer til objektet Singleton kan gøres med følgende kode:

CSingleton * CSingleton::m_Singleton;

Når dette er gjort skal vi implementere vores constructor, dette er relativt simpelt. Vi vil dog tage højde for at det ikke er muligt at lave mere end een instans af vores singleton. Dette gør vi med brugen af headerfilen assert.h. Først et par ord om assert.h headerfilen. Header filen assert.h indeholder en funktion der hedder assert(BOOL) den tager en bool variabel (altså true eller false) som parameter. Hvis værdien der står i funktionen er false blever der lavet i breakpoint i debuggeren på denne linie, dette gør det nemmere bagefter at dianosticere dette problem. Reelt vil det virke på den måde at så snart man forsøger at lave en anden instans af denne singleton klasse i sit program vil man få en fejl (i debug mode), programmet vil gå ned og man kan fejlfinde. Det er vigtigt at programmet går ned og giver besked om hvor der er sket en fejl (assert laver jo et breakpoint vi senere kan finde igen) da vi i vores program netop ikke ønsker at lve en anden instans af vores Singleton klasse. Kigger vi på koden til constructoren ser den ud som følger:

CSingleton::CSingleton()
{
	assert (!m_Singleton);
	m_Singleton=this;
}

Det første der sker i constructoren er at vi lige kontrollerer at der ikke eksisterer en instans af denne klasse i forvejen, dette gøres ved at spørge med !-tegn foran vores pointer til en klasse, hvis der eksisterer en i forvejen bliver dette tjek false og vores program brager ned (hvilket er godt, da vi så ikke må lave en ny instans). Hvis ikke der i forvejen findes en instans af denne klasse bliver resultatet af vores assert til assert(!false) og not-false er som bekendt true, dette gør at vi får lov til at lave en ny instans af denne klasse. Efter dette hurtige tjek, der er alpha og omega i vores singleton klasse, er det tid til at oprette en ny instans af denne klasse, dette gøres ved at føje pointeren til klassen til den klasse vi er ved at definere (lyder lidt kryptisk, men det er rent faktisk det der sker):

m_singleton=this;

Denne kode laver den ny instans af klassen Csingleton. Denne instans er den eneste vi ønsker i vores program, så alt virker som det skal. De to sidste funktioner er relativt hurtige at løbe igennem når vi forstår hvordan funktionen assert virker. Den første er metoden til at hente instansen af vores Csingleton klasse:

CSingleton * CSingleton::getSingleton()
{
	assert (m_Singleton);
	return m_Singleton;
}

Det første vi gør er lige at teste om der findes en instans af klassen inden vi returnerer den til metoden, hvis ikke dette er tilfældet (det vil sige vi ikke har kaldt constructoren og fået oprettet en ny instans) fejler vores program. Hvis vi har husket at kalde constructoren og dermed have en lovlig instans af vores Csingleton klasse kan vi herefter returnere den til metoden. Rimeligt simpelt. Den næste metode er destructoren, den er lidt mere tricky, da vi kun har statiske værdier, er vi nødt til selv at fortælle at instansen af klassen nu er nedlagt. Dette kan gøres ved at sætte vores pointer til at pege på NULL.

CSingleton::~CSingleton()
{
assert(m_singleton);
m_singleton=NULL;
}

Igen tester vi lige at der findes en instans af klassen ved at bruge vores assert metode, det giver ingen mening at nedlægge et objekt der ikke eksisterer, derfor dette tjek. Går det godt (det vil sige at m_singleton memberet er true, og at der eksisterer en instans, så vi kan nedlægge den) sætter vi pointeren til NULL og objektet er nedlagt.

Det næste vi vil gøre er at teste vores Singleton klasse med en main metode (denne kan bare skrives i bunden af alt det andet kode og kompileres med, jeg har skilt det ud for overskuelighedens skyld).

int main()
{
CSingleton singleton();
CSingleton *pointer_til_singleton;
pointer_til_singleton=CSingleton::getSingleton();

return 0;
}

Det første vi laver i main metoden er at lave en instans af vores objekt, dette gøres ved at kalde constructoren. Det næste vi vil gøre er at lave en pointer til vores CSingleton objekt (for god ordens skyld er et objekt en klasse der er lavet en instans af) således vi kan tilgå de andre metoder vi senere hen ville kunne lave derpå, som fx playSound(), loadObjects() og så videre. Når denne pointer er på plads sætter vi pointeren til at pege på vores nyligt kreerede Csingleton klasse, til dette formål bruger vi vores metode getSingleton(), der jo som bekendt returnerer en pointer til det objekt der lige er oprettet (derfor er den lidt speciel nede i vores implementation af metoden). Hvis vi nu compiler det og kører det ser vi ingen fejl, men hvis vi derimod laver en ny instans:

int main()
{
CSingleton singleton();
CSingleton *pointer_til_singleton;
pointer_til_singleton=CSingleton::getSingleton();

/*Hvis nedenstående linie ikke udkommenteres, vil
den generere en fejl, da vi prøver at lave en ny instans af objektet*/

CSingleton andensingleton;
return 0;
}

Når vi kører denne mode i debug mode vil den få programmet til at gå ned og der vil komme en fejlmeddelelse, der fortæller i hvilken linie det gik galt og at det ikke var muligt at lave en assertion (assertion betyder påstand på engelsk, så det giver rent faktisk mening at det ikke var muligt at lave en påstand når programmer fejler).

Afrunding
Singleton klasser benyttes meget i spiludvikling, hvor det er ønskeligt kun at have een instans af en given fjende, eller kun een instans af den klasse der loader og afspiller lydfiler. Måden vi har gjort det på er ved at lave vores program i debug mode hvor assert vil fejle, i dette tilfælge går man ud fra at hele programmet kodes og testes i alle leder og kanter i debug mode. Dette gør at man kan se hvor i ens kode man forsøger at oprette nye instanser af de Singletonklasser man har erklæret, herefter kan man så rette i sin kode til alt dette er fjernet. Så kan man compile den til release og frigive sin splinter nye applikation med Singleton klasser. Dette program er udviklet og testet i Visual Studio 6.0 jeg ved ikke hvordan det vil virke i andre miljøer.



Hvad synes du om denne artikel? Giv din mening til kende ved at stemme via pilene til venstre og/eller lægge en kommentar herunder.

Del også gerne artiklen med dine Facebook venner:  

Karma barometer (30 dage)

IT jobs | Kontakt | Om Udvikleren.dk | Om karma | IT nyheds arkiv | Annoncering

X