Singleton class memory management

[aayu09]

I have a question about the singleton class. The following is a typical application singleton c++ application.

#include <iostream>

using namespace std;

class Singleton
{
private:
    static bool instanceFlag;
    static Singleton *single;
    Singleton()
    {
        //private constructor
    }
public:
    static Singleton* getInstance();
    void method();
    ~Singleton()
    {
        instanceFlag = false;
    }
};

bool Singleton::instanceFlag = false;
Singleton* Singleton::single = NULL;
Singleton* Singleton::getInstance()
{
    if(! instanceFlag)
    {
        single = new Singleton();
        instanceFlag = true;
        return single;
    }
    else
    {
        return single;
    }
}

void Singleton::method()
{
    cout << "Method of the singleton class" << endl;
}

int main()
{
    Singleton *sc1,*sc2;
    sc1 = Singleton::getInstance();
    sc1->method();
    sc2 = Singleton::getInstance();
    sc2->method();

    return 0;
}

My question is when the heap is allocated using: single = new Singleton(), where does the heap get releaed? Should we add delete single in destructor ~Singleton(), please help.

[jsmith]

It does not get deallocated ever.

Certainly you cannot free it in the destructor for two reasons: 1) the destructor will never run, and 2) if it did, you'd end up with an infinite loop.

If you want the object's destructor to run when the program exits, then implement it this way:

class Singleton {
   Singleton() {}
   Singleton& operator=( const Singleton& );  // Leave unimplemented
   Singleton( const Singleton& );  // Leave unimplemented
  public:
    static Singleton& GetInstance() {
        static Singleton singleton;
        return singleton;
    }
};

(Note: your implementation of the Singleton pattern was incomplete in
that it allowed copy constructor and assignment, both of which break
the singleton pattern. My code above also fixes that).

[aayu09]

Thanks a lot.

[Denis]

It's easy to free memory

class Singleton
{
public:
//here all your staff
//please don't call this method, it was called automatically
static void terminate()
{
    delete single;
    single = 0;
}
};

class SingletonDeletor
{
public:
    ~SingletonDeletor()
      {
           Singleton::terminate();
      }
};


//in some cpp file you need to declare static variable of SingletonDeletor
static SingletonDeletor sSingletonDeletor;

[Denis]

And once more comment, if your global or static variables are used this singleton then my solution is not acceptable

[moorecm]

jsmith's solution is what I suggest. It doesn't instantiate the instance until you use it and it cleans it up when the program exits. What's not to like about that?

[Denis]

There is a small difference. It's memory usage, in my case I use heap, in jsmith's case data segment is used. The difference may be not sensitive for desktops, but for embedded systems it's prefer to use heap.