Singleton Class The class of which only one object can be created is known as a singleton class.

The following program defines a singleton class. #include<process.h> #include<iostream.h> class single { static int count; public; sample() { If(count==1) exit(0); count++; } }; int sample::count=0; void main() { sample s1; sample s2; } There are times, when you need to have a class which can be instantiated once only. The Singleton Design Pattern provides a solution for such a situation. There are several possible ways to implement a singleton pattern, but it all pretty much comes down to a classthat has a private constructor and a static member function to create and retrieve an instance of the class. My implementation does not differ much from this scenario, with the exception that I created a singleton templateclass. So, why a template class? Well I have searched the Internet for an elegant implementation of a singleton class but I did not really find a solution to my satisfaction. Most classes I found consist of a Singleton base class that you can use to derive your own singleton class from. The problem with most of these classes is the fact that you still have to override the GetInstance function to return a pointer to your derived class. A template base class does not have this limitation as I can return any type of pointer. How it works To prevent outside source from creating (or copying) an instance of our singleton class, we need to shield the constructor and copy constructor of the singleton class. Further we need to provide a method to create and retrieve a reference to the singleton object: Collapse | Copy Code static T* Instance()

{ if (m_instance == NULL) m_instance = new T; ASSERT(m_instance != NULL); return m_instance; }; When this method is called for the first time, it creates an instance of the singleton class, any sequential calls will return a reference to the created class instance. To get a reference to the singleton object, all we have to do is call this method as following: Collapse | Copy Code CMySingleton* mySingleton = CMySingleton::Instance(); That is almost all that there is to it. Next to shielding the constructors, I also shielded the destructor, so thesingleton class cannot be deleted by accident. Just call the DestroyInstance() method to destroy thesingleton object. However, be careful when to call this method, because after you have called this method, all your class data will be destroyed and a sequential to the Instance() method will create a new instance. So how do you create a class derived from the singleton template class? Again there is nothing to it. Just include the attached header file and create your object as following: Collapse | Copy Code class CMySingleton : public CSingleton<CMySingleton> { friend CSingleton<CMySingleton>; private: CMySingleton(); ~CMySingleton(); ... } Conclusion This implementation of the Singleton Pattern makes creating your own singleton class incredibly easy. But you do have to be careful when to destroy the singleton class instance. If you find this to be a problem you could consider adding (automatic) reference counting.