CodeGuru Home VC++ / MFC / C++ .NET / C# Visual Basic VB Forums
Results 1 to 1 of 1
  1. #1
    Join Date
    Sep 2004
    A Planet Called Earth... :-)

    C++ Design Pattern: What is a Singleton class?

    Q: What is a singleton class?

    A: A class whose number of instances that can be instantiated is limited to one is called a singleton class. Thus, at any given time only one instance can exist, no more.

    Q: Can you give me an example, where it is used?

    A: The singleton design pattern is used whenever the design requires only one instance of a class. Some examples:
    • Application classes. There should only be one application class. (Note: Please bear in mind, MFC class 'CWinApp' is not implemented as a singleton class)
    • Logger classes. For logging purposes of an application there is usually one logger instance required.

    Q: How could a singleton class be implemented?

    A: There are several ways of creating a singleton class. The most simple approach is shown below:

    class CMySingleton
      static CMySingleton& Instance()
        static CMySingleton singleton;
        return singleton;
    // Other non-static member functions
      CMySingleton() {};                                 // Private constructor
      CMySingleton(const CMySingleton&);                 // Prevent copy-construction
      CMySingleton& operator=(const CMySingleton&);      // Prevent assignment

    Q: Can I extend the singleton pattern to allow more than one instance?

    A: The general purpose of the singleton design pattern is to limit the number of instances of a class to only one. However, the pattern can be extended by many ways to actually control the number of instances allowed. One way is shown below...

    class CMyClass
      CMyClass() {}                           // Private Constructor
      static int nCount;                      // Current number of instances
      static int nMaxInstance;                // Maximum number of instances
      ~CMyClass();                            // Public Destructor
      static CMyClass* CreateInstance();      // Construct Indirectly
      //Add whatever members you want
    • Here we declare our constructor/s as private, thus denying direct creation of the class.
    • A static function CreateInstance that creates the class indirectly for us.
    • Two static members, one holding the current number of instances, another one the maximum allowed.
    • Note: We have to declare at least one constructor (private - of course), else direct creation will be possible.

    int CMyClass::nCount = 0;
    int CMyClass::nMaxInstance = 1;         // When maxInstance is 1, we have a pure singleton class
      --nCount;                             // Decrement number of instances
    CMyClass* CMyClass::CreateInstance()
      CMyClass* ptr = NULL;
      if(nMaxInstance > nCount)
        ptr = new CMyClass;  
        ++nCount;                           // Increment no of instances
      return ptr;
    • Everytime an instance is created, the count is incremented, and when the object is deleted, the destructor is invoked, and the count is decremented.
    • Since, the objective is to limit the number of instances, we allow direct destruction of object.
    • As a special case, when 'maxInstance' is 1, we have a pure singleton class.

    Now if you want to create an instance of the class:

    CMyClass* pObj = CMyClass::CreateInstance();
      // Success
      // Failed to create, probably because the maximum number of instances has already been created
    Note, that the successfully created instance(s) need(s) to be released to ensure that no memory leak occurs:

    delete pObj;

    Last edited by Andreas Masur; July 24th, 2005 at 05:34 AM.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts

Click Here to Expand Forum to Full Width