C++ example for Singleton Design Pattern

The Singleton Design Pattern which is widely used ensures that there is a single instance of the object and it also provides a global point of access to it.

I have covered couple of examples on Singletons in past and you are welcome to refer to them as an example for this design pattern. The simple example is here and a more involved one is here.

To learn more about Singletons see:

http://www.dofactory.com/Patterns/PatternSingleton.aspx

http://www.patterndepot.com/put/8/Singleton.PDF

Another Multi-Threading example with Mutex

Here is an example where we combine the previous programs to create a multi-threaded mutex based program. If you havent already seen, then please check out the Singleton class and Multi-Threading with Thread Sync.

We are going to have some .h files in this example.

Lock.h

//Example from http://www.relisoft.com/Win32/active.html
#if !defined _LOCK_H_
#define _LOCK_H_

#include "Mutex.h"

class Lock
{
public:
    // Acquire the state of the semaphore
    Lock ( Mutex & mutex )
        : _mutex(mutex)
    {
        _mutex.Acquire();
    }
    // Release the state of the semaphore
    ~Lock ()
    {
        _mutex.Release();
    }
private:
    Mutex & _mutex;
};

#endif 

Mutex.h

//Example from http://www.relisoft.com/Win32/active.html
#if !defined _MUTEX_H_
#define _MUTEX_H_

class Mutex
{
    friend class Lock;
public:
    Mutex () { InitializeCriticalSection (& _critSection); }
    ~Mutex () { DeleteCriticalSection (& _critSection); }
private:
    void Acquire ()
    {
        EnterCriticalSection (& _critSection);
    }
    void Release ()
    {
        LeaveCriticalSection (& _critSection);
    }

    CRITICAL_SECTION _critSection;
};

#endif 

Singleton.h

#include "Lock.h"
#include "Mutex.h"

class aSingletonClass
{
public:
  //method to get Instance of class
  static aSingletonClass *getInstance( void )
  {
    //Note that the class is only created when this method is called first time
    if(!instance_)
      instance_ = new aSingletonClass;
    return instance_;
  }
  //method to delete Instance of class
  static void deleteInstance( void )
  {
    if(instance_)
      delete instance_;
    instance_ = NULL; //important as this can create dead reference problems
  }
  void printSomething(char *name, int count)
  {
    Lock guard(mutex_);
    std::cout << name << " loop " << count << std::endl;
  }

private:
  //variable to store the instance of singleton
  static aSingletonClass *instance_;
  //default constructor should be private to prevent instantiation
  aSingletonClass() {};
  //destructor should be made private so no one can delete this accidently
  ~aSingletonClass() {};
  //We also need to prevent copy being created of the object
  aSingletonClass(const aSingletonClass&);

  Mutex mutex_;
}; 

Thread.cpp

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//This shows example of Multithreading, thread sync, Mutex
#include <windows.h>
#include <process.h>
#include <iostream>
#include "Singleton.h"

using namespace std;

aSingletonClass* aSingletonClass::instance_ = NULL;

void Func1(void *);
void Func2(void *);

int main()
{
  HANDLE hThreads[2];

  aSingletonClass *someVar = NULL;
  //Create Instance
  someVar = aSingletonClass::getInstance();

  //Create two threads and start them
  hThreads[0] = (HANDLE)_beginthread(Func1, 0, NULL);
  hThreads[1] = (HANDLE)_beginthread(Func2, 0, NULL);

  //Makes sure that both the threads have finished before going further
  WaitForMultipleObjects(2, hThreads, TRUE, INFINITE);

  cout << "Main exit" << endl;
  return 0;
}

void Func1(void *P)
{
  int Count;

  for (Count = 1; Count < 11; Count++)
  {
    aSingletonClass::getInstance()->printSomething("Func1", Count);
  }
  return;
}

void Func2(void *P)
{
  int Count;

  for (Count = 10; Count > 0; Count--)
  {
    aSingletonClass::getInstance()->printSomething("Func2", Count);
  }
  return;
}

The Output is as follows:

The Singleton class

Singletons are not uncommon in large projects. The main advantage being that they act like static class but are not really static. They are only created when being used and can be deleted as well.

Here is an example of Singleton class:

Singleton.h file

class aSingletonClass
{
public:
  //method to get Instance of class
  static aSingletonClass *getInstance( void )
  {
    //Note that the class is only created when this method is called first time
    if(!instance_)
      instance_ = new aSingletonClass;
    return instance_;
  }
  //method to delete Instance of class
  static void deleteInstance( void )
  {
    if(instance_)
      delete instance_;
    instance_ = NULL; //important as this can create dead reference problems
  }

private:
  //variable to store the instance of singleton
  static aSingletonClass *instance_;
  //default constructor should be private to prevent instantiation
  aSingletonClass() {};
  //destructor should be made private so no one can delete this accidently
  ~aSingletonClass() {};
  //We also need to prevent copy being created of the object
  aSingletonClass(const aSingletonClass&);
}; //mandatory or else error in compiling

Singleton.cpp file

/*
Singleton implies that there is only a single instance of this class
In simple terms this looks like a static class but thats not true.
*/
#include <iostream>
#include "Singleton.h"

using namespace std;

aSingletonClass* aSingletonClass::instance_ = NULL;

int main()
{
  aSingletonClass *someVar = NULL;
  //Create Instance
  someVar = aSingletonClass::getInstance();
 
  //aSingletonClass *anotherVar = new aSingletonClass; -- Not possible
  //delete someVar; -- Not possible

  //delete the Singleton class
  aSingletonClass::deleteInstance();

  return 0;
}