CODEWITHSUNDEEP
c++design-patternssingleton
sasikala
sasikala

Reputation: 539

what is the exact use and implementation of singleton class?

I know the singleton class does not allow to create more than one object. but as per my below code i can create as many objects as possible.

class Singleton
{
  private :
   static Singleton *m_Instance;
   Singleton()
   {
     cout<<"In defailt constructor"<<endl;
   }
   Singleton(int x)
   {
      i = x;
      cout<<"in param const"<<endl;
   }
 public:
   static int i;
   static Singleton* createInstance()
   {
      if(!m_Instance)
        m_Instance = new Singleton(20);
      Singleton sing;
      return m_Instance;
   }
};
int Singleton::i=0;
Singleton* Singleton::m_Instance = NULL;
int main()
{

    Singleton *pt = Singleton::createInstance();
    return 1;
}

Here I am able to create an object in the static function (as i can access constructor within the class) then where is the concept of Single object?

Upvotes: 0

Views: 109

Answers (2)

Tirma
Tirma

Reputation: 674

The concept of single object comes when in your code, every time you need an instance of your Object, instead of using:

Singleton *myOwnSingleton=  new Singleton(20);

You should always use:

Singleton *pt = Singleton::createInstance();

As the constructor is inaccesible outside of the class, the only way to create a Singleton is by Singleton::createInstance(), and if you read the code, only the first time that we call Singleton::createInstance() a new instance is created.
All subsequent calls to this method will return the already created object. So in all your execution you will only have one instance created.

But of course... you should delete the line 

Singleton sing;

because it is a wrong utilization of Singleton. If you create a class called CAR but without wheels... it is not a car. And you make a class called singleton, but... with two objects of the same type. It's not beauty!

Upvotes: 1

Mike Seymour
Mike Seymour

Reputation: 254751

This isn't a singleton for the simple reason that you deliberately wrote something that isn't a singleton.

The idea is that you write the instance function so that it will only create one instance, and write other members so that they don't create any. Then, since they're the only functions that could create any instances, there will only be one.

If you remove the dodgy Singleton sing;, then you'll have a singleton implementation - only one instance will be created, the first time someone calls the function.

As with all attempts to implement this anti-pattern in C++, there are problems: the object is never destroyed, and the initialisation isn't thread-safe. There are various other approaches, each with their own drawbacks. I suggest you avoid global variables altogether, whether or not you dress them up as singletons or other anti-patterns.

Upvotes: 3

Related Questions