# CodeGuru Technical FAQs > CodeGuru Individual FAQs >  C++ Design Pattern: What is a Singleton class?

## Vedam Shashank

*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
{
public:
  static CMySingleton& Instance()
  {
    static CMySingleton singleton;
    return singleton;
  }

// Other non-static member functions
private:
  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
{
private:
  CMyClass() {}                           // Private Constructor

  static int nCount;                      // Current number of instances
  static int nMaxInstance;                // Maximum number of instances

public:
  ~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

CMyClass::~CMyClass()
{
  --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();
if(pObj)
{
  // Success
}
else
{
  // 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;
```

----------

