Singleton question

[JFR]

i found this code sample on the net that i wanted to use:


class CUniqueObject
{
private:
CUniqueObject( void ) : m_iValue(0) { }
~CUniqueObject( void ) { }
public:
void SetValue( int iValue ) { m_iValue = iValue; }
int GetValue( void ) { return m_iValue; }

static CUniqueObject *GetInstance( void )
{
if( m_pSingleton == 0 )
{
std::cout << "creating singleton." << std::endl;
m_pSingleton = new CUniqueObject;
}
else
{
std::cout << "singleton already created!" << std::endl;
}

return m_pSingleton;
}

static void Kill( void )
{
if( m_pSingleton != 0 )
{
delete m_pSingleton;
m_pSingleton = 0;
}
}
private:
int m_iValue;
static CUniqueObject *m_pSingleton;
};
CUniqueObject *CUniqueObject: :m_pSingleton = 0;
int main( int argc, char *argv[] )
{

CUniqueObject *pObj1, *pObj2;
pObj1 = CUniqueObject:: GetInstance();
pObj2 = CUniqueObject:: GetInstance();
pObj1->SetValue( 11 );
std::cout << "pObj1::m_iValu e = " << pObj1->GetValue() << std::endl;
std::cout << "pObj2::m_iValu e = " << pObj2->GetValue() << std::endl;
pObj1->Kill();

return 0;
}
when i run the above code and debug it, the pObj1 shows that it
contains 2 things, a m_iValue and a m_pSingleton. However, the
m_pSingleton contains a CUniqueObject* which in turns also contains a
m_iValue and a m_pSingleton, and this goes on and on. I can expand the
object trees in the debugger infinitely.
At first i thought there was a problem with the code, but i think it's
just the debugger's way of showing objects.

Is this behavior "normal"?

[Lionel]

Lionel wrote:

Torsten Mueller wrote:

In my experience the singleton pattern is normally enforced by people
having found this just a really gorgeous idea and not knowing real
problems.

I have had some very good uses for the Singleton pattern in the past.
Admittedly they were in Java which does have some consequences.

I can't think of a situation where you would use the Singleton pattern
and would want to have subclasses, that just sounds crazy IMHO. The idea
generally is that you only want one instance of some set of data that is
operated on by everyone, this way it stays consistent.

I have also never gone looking to just apply a design patter for the fun
of it, I have always started with a problem and just discovered that a
particular pattern is suitable for purpose.

Actually, I possibly didn't read your post carefully enough,
particularly your discussion of protected instead of private. I would
agree on that!