Eric said:I created a singleton class as in the example below. The application
sporadically crashes in the second line of the main function as shown.
However, when I change the singleton such that the static pointer is a
class member (defined in the cpp file) and the instance function
creates the object if the pointer is NULL, then it works fine. I would
appreciate any explanations as to why this happens.
I created a singleton class as in the example below. The application
sporadically crashes in the second line of the main function as shown.
However, when I change the singleton such that the static pointer is a
class member (defined in the cpp file) and the instance function
creates the object if the pointer is NULL, then it works fine. I would
appreciate any explanations as to why this happens.
class CTestClass
{
public:
static CTestClass& instance()
{
static CTestClass* m_instance = new CTestClass;
return *m_instance;
}
private:
CTestClass() { /* do some stuff */ }
};
int main()
{
CTestClass::instance(); // initialize singleton here to
avoid future race conditions
// sporadically crashes here when using CTestClass::instance()
}
If not, post a
complete but minimal sample that demonstrates the problem (see FAQ
5.4),
I created a singleton class as in the example below. The application
sporadically crashes in the second line of the main function as shown.
However, when I change the singleton such that the static pointer is a
class member (defined in the cpp file) and the instance function
creates the object if the pointer is NULL, then it works fine. I would
appreciate any explanations as to why this happens.
class CTestClass
{
public:
static CTestClass& instance()
{
static CTestClass* m_instance = new CTestClass;
return *m_instance;
}
private:
CTestClass() { /* do some stuff */ }
};
int main()
{
CTestClass::instance(); // initialize singleton here to
avoid future race conditions
// sporadically crashes here when using CTestClass::instance()
}
I created a singleton class as in the example below. The application
sporadically crashes in the second line of the main function as shown.
However, when I change the singleton such that the static pointer is a
class member (defined in the cpp file) and the instance function
creates the object if the pointer is NULL, then it works fine. I would
appreciate any explanations as to why this happens.
class CTestClass
{
public:
static CTestClass& instance()
{
static CTestClass* m_instance = new CTestClass;
return *m_instance;
}
private:
CTestClass() { /* do some stuff */ }
};
int main()
{
CTestClass::instance(); // initialize singleton here to
avoid future race conditions
// sporadically crashes here when using CTestClass::instance()
}
Eric said:I created a singleton class as in the example below. The application
sporadically crashes in the second line of the main function as shown.
However, when I change the singleton such that the static pointer is a
class member (defined in the cpp file) and the instance function
creates the object if the pointer is NULL, then it works fine. I would
appreciate any explanations as to why this happens.
class CTestClass
{
public:
static CTestClass& instance()
{
static CTestClass* m_instance = new CTestClass;
This doesn't make sense. How can the compiler create this object at
compile time?
Change this to:
static CTestClass& instance()
{
static CTestClass* m_instance;
if(!m_instance) m_instance = new CTestClass;
return m_instance;
}
Salt_Peter said:By 'race conditions', did you think that some local persistant
variable is immune to thread locks because its static?
Eric said:I created a singleton class as in the example below. The application
sporadically crashes in the second line of the main function as shown.
However, when I change the singleton such that the static pointer is a
class member (defined in the cpp file) and the instance function
creates the object if the pointer is NULL, then it works fine. I would
appreciate any explanations as to why this happens.
class CTestClass
{
public:
static CTestClass& instance()
{
static CTestClass* m_instance = new CTestClass;
return *m_instance;
}
private:
CTestClass() { /* do some stuff */ }
};
int main()
{
CTestClass::instance(); // initialize singleton here to
avoid future race conditions
// sporadically crashes here when using CTestClass::instance()
}
Alf said:Fei Liu:
This merely replicates the code generated by the compiler for the
original, but in a more verbose and possibly less efficient way.
And it's still more verbose and possibly less efficient than:
static CTestClass& instance()
{
static CTestClass m_instance;
return m_instance;
}
which also destroys the instance properly and automatically.
And thus introduces order of destruction issues. As a general
rule, it is preferable that the instance of a singleton NOT be
destructed. Ever.
* Fei Liu:
The object is created at run time.
This merely replicates the code generated by the compiler for the
original, but in a more verbose and possibly less efficient way.
See §6.7/4, "is initialized the first time control passes through its
declaration".
You sure about that? Sorry I am moving house and all my reference booksFei said:Ah, so this is the C++ way of doing it...I may be wrong, but in C at
least for plain old datatype, function static variable initialization
happens at compile time.
And thus introduces order of destruction issues. As a general
rule, it is preferable that the instance of a singleton NOT be
destructed. Ever.
Ah, so this is the C++ way of doing it...I may be wrong, but in C at
least for plain old datatype, function static variable initialization
happens at compile time.
The C99 standard does require the initializers of static variables toFrancis Glassborow said:You sure about that? Sorry I am moving house and all my reference books
are packed away, but that would mean that a function static could only
be initialised with a const expression. I thought that functions statics
were initialised the first time the flow of execution passes through them.
Won't the destructor of a static singleton object be called
automatically at program shutdown?
I do not quite understand how you would run into issues whenWon't the destructor of a static singleton object be called
automatically at program shutdown?
Want to reply to this thread or ask your own question?
You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.