singleton question

[tarmat]

I have a singleton class that looks a little like this:

class MyClass
{
private:

//data

MyClass()
{
Create();
}

void Create(); //initialization stuff

public:

static MyClass* Instance()
{
static MyClass instance;

return &instance;
}

//interface
};

This singleton class is used within multiple cpp files within my
project. It works fine in debug build but when I compile a release
build the MyClass ctor is called multiple times, one time for each
different cpp file it is called from.

Do you know why this is happening? I don't understand what's going on
at all. Surely it is only possible for the ctor to be called once
given this code.

Thanks for any enlightenment.

[Ralf]

Hi,

if you are defining your static Instance() method inside a header file, this
should result in an behaviour as you described. Because you have more than
only one static instance of your singleton class.
If you are defining the Instance() method outside of the class in a cpp
file, it should work correctly.

Ralf

www.cplusplus-kurse.de
"tarmat" <ta****@btopenw orld.com> schrieb im Newsbeitrag
news:43******** *************** *********@4ax.c om...

I have a singleton class that looks a little like this:

class MyClass
{
private:

//data

MyClass()
{
Create();
}

void Create(); //initialization stuff

public:

static MyClass* Instance()
{
static MyClass instance;

return &instance;
}

//interface
};

This singleton class is used within multiple cpp files within my
project. It works fine in debug build but when I compile a release
build the MyClass ctor is called multiple times, one time for each
different cpp file it is called from.

Do you know why this is happening? I don't understand what's going on
at all. Surely it is only possible for the ctor to be called once
given this code.

Thanks for any enlightenment.

[Tim Clacy]

tarmat wrote:

I have a singleton class that looks a little like this:

class MyClass
{
private:

//data

MyClass()
{
Create();
}

void Create(); //initialization stuff

public:

static MyClass* Instance()
{
static MyClass instance;

return &instance;
}

//interface
};

This singleton class is used within multiple cpp files within my
project. It works fine in debug build but when I compile a release
build the MyClass ctor is called multiple times, one time for each
different cpp file it is called from.

Do you know why this is happening? I don't understand what's going on
at all. Surely it is only possible for the ctor to be called once
given this code.

Thanks for any enlightenment.

If you move the definition of MyClass::Instan ce() into a '.cpp' file, and
that works, then the problem is that your compiler doesn't make static data
defined in inline member functions refer to the same item; I only know this
through similar experience with two different compilers. On older compilers,
if static class data is defined in headers, then every module that includes
that header gets its own unique static data; newer compilers ensure that
there is only one instance if the data.

Tim

[tarmat]

thanks guys, I didn't know that

[stephan beal]

tarmat wrote:

static MyClass* Instance()
{
static MyClass instance;

return &instance;
}
IMO a pointer is the wrong thing to return there. Passing a non-const
pointer often implies to the client that the caller owns the returned
pointer. Passing a reference gives the clear message that the object is not
to be deleted by clients.
This singleton class is used within multiple cpp files within my
project. It works fine in debug build but when I compile a release
build the MyClass ctor is called multiple times, one time for each
different cpp file it is called from.

Remove the 'static' part if you compile this inline. (i learned this lesson
only a few weeks ago, in a case almost identical to yours.)
--
----- stephan beal
http://s11.net/
Registered Linux User #71917 http://counter.li.org
I speak for myself, not my employer. Contents may
be hot. Slippery when wet. Reading disclaimers makes
you go blind. Writing them is worse. You have been Warned.

[Tim Clacy]

stephan beal wrote:

tarmat wrote:

static MyClass* Instance()
{
static MyClass instance;

return &instance;
}

IMO a pointer is the wrong thing to return there. Passing a non-const
pointer often implies to the client that the caller owns the returned
pointer. Passing a reference gives the clear message that the object
is not to be deleted by clients.

This singleton class is used within multiple cpp files within my
project. It works fine in debug build but when I compile a release
build the MyClass ctor is called multiple times, one time for each
different cpp file it is called from.

Remove the 'static' part if you compile this inline. (i learned this
lesson only a few weeks ago, in a case almost identical to yours.)

Stephan,

Hi. The poster can't simply remove 'static'; to do so would mean that
instance is a temporary object and Instance() would be returning a pointer
to that temporary object. Also the singleton would be constructed and
destructed every time someone tried to get a handle to it... which is
probably not what's wanted.

The options are:

1) move MyClass::Instan ce() to a '.cpp' file
2) move 'instance' out of Instance() and into MyClass (keeping it static) an
define it in a '.cpp' file
3) find one of these trendy compilers that knows what to do

Personally, I like 3) since it gets rid of the need for '.cpp' files that
contain one function :-)
Tim

[jeffc]

"tarmat" <ta****@btopenw orld.com> wrote in message
news:43******** *************** *********@4ax.c om...

I have a singleton class that looks a little like this:

class MyClass
{
private:

//data

MyClass()
{
Create();
}

void Create(); //initialization stuff

public:

static MyClass* Instance()
{
static MyClass instance;

return &instance;
}

//interface
};

This singleton class is used within multiple cpp files within my
project. It works fine in debug build but when I compile a release
build the MyClass ctor is called multiple times, one time for each
different cpp file it is called from.

Do you know why this is happening? I don't understand what's going on
at all. Surely it is only possible for the ctor to be called once
given this code.

No, I don't think this is a standard approach. You're creating a static
instance in your *header* file. You want one instance per application, not
one per inclusion of header file. (By the way, just because you have a
singleton class doesn't necessarily mean you *have* to have an instance.
Are you sure you don't want to create that instance somewhere else, if and
when you need it?)

[stephan beal]

Tim Clacy wrote:

Hi. The poster can't simply remove 'static'; to do so would mean that
instance is a temporary object and Instance() would be returning a pointer
to that temporary object. Also the singleton would be constructed and

Sorry, you misunderstood (and i was ambiguous): i meant the static qualifier
from the function, not the internal static variable.

--
----- stephan beal
http://s11n.net/
Registered Linux User #71917 http://counter.li.org
I speak for myself, not my employer. Contents may
be hot. Slippery when wet. Reading disclaimers makes
you go blind. Writing them is worse. You have been Warned.

[Tim Clacy]

stephan beal wrote:

Tim Clacy wrote:

Hi. The poster can't simply remove 'static'; to do so would mean that
instance is a temporary object and Instance() would be returning a
pointer to that temporary object. Also the singleton would be
constructed and

Sorry, you misunderstood (and i was ambiguous): i meant the static
qualifier from the function, not the internal static variable.

Stephan,

....but if you remove the static qualifier from 'Instance()', you will need
an instance of the class to get to the the 'Instance()' member function;
it's not a singleton anymore.

Tim

[stephan beal]

Tim Clacy wrote:

Stephan,

...but if you remove the static qualifier from 'Instance()', you will need
an instance of the class to get to the the 'Instance()' member function;
it's not a singleton anymore.

Oh, doh.
/slap forehead.

--
----- stephan beal
http://s11n.net/
Registered Linux User #71917 http://counter.li.org
I speak for myself, not my employer. Contents may
be hot. Slippery when wet. Reading disclaimers makes
you go blind. Writing them is worse. You have been Warned.
*