Hello,

I have the following Singleton code :-

#include <iostream>

using namespace std;

class Singleton
{
private:
static bool instanceFlag;
static Singleton *single;

Singleton()
{
//private constructor
}
public:
static Singleton* getInstance()
{
cout << "instanceFlag = " << instanceFlag << endl;
if(!instanceFlag)
{
single = new Singleton();
instanceFlag = true;
return single;
}
else
{
return single;
}
}

void method()
{
cout << "\tMethod of the singleton class" << endl << endl;
}

~Singleton()
{
instanceFlag = false;
}
};

bool Singleton::instanceFlag = false;
Singleton* Singleton::single = NULL;

int main()
{
Singleton *sc1,*sc2;

sc1 = Singleton::getInstance();
sc1->method();
sc2 = Singleton::getInstance();
sc2->method();
return 0;
}

I understand most of the code, however, can someone please explain the highlited lines ? Is this a C++ way to initialise static private members without having a setValues() function ?
Can we write a setValues() function for static members ?
Also, why do we need to have static members here ? The Java implementation also uses static but much more stright forward to understand :-

public class Singleton {
/**
* The constructor could be made private
* to prevent others from instantiating this class.
* But this would also make it impossible to
* create instances of Singleton subclasses.
*/
protected Singleton() {
// ...
}


/**
* A handle to the unique Singleton instance.
*/
static private Singleton _instance = null;

/**
* @return The unique instance of this class.
*/
static public Singleton instance() {
if(null == _instance) {
_instance = new Singleton();
}
return _instance;
}


/. ...additional methods omitted...
}

The other thing, Singleton means I can only create one instance of. How can I prove that this works ?