class singleton { static singleton * m_singleton;singleton(){m_singleton = new singleton;} ... }; singleton d; so I will use singleton::m_singleton->member instead of d->member. so singleton just use class name instead of instance name to access member. singleton just play this role. so am I right?

More-less: yes.

But you have to be carefull about initializing your singleton. It could go like this:


Now, the important thing is that you got to have full control of all data in your program. So implicit construction and initialization is (usually) a bad thing (the code: "singleton(){m_singleton = new singleton;}" is an infinite loop). So if you've got to know where construction and destruction takes place, and in which order, 'cause your singletons usually will have to use each other even in initialization code.

Cheers.
/def

I really see no benefit to singletons except in entirely object-oriented languages like Java, where in, for instance, a server environment, it's likely that multiple clients may be using the same virtual machine and need access to the same object, which must only be instantiated once. (And in this case it can be very useful; we use it at work all the time.)

The purpose of a singleton is to ensure that an object is instantiated once and only once. This is usually because the object represents something that logically only exists once, like the video subsystem or (I still gag thinking of things like "CGameEngine") God forbid the engine.

However, in that instance I think that you're actually misusing the purpose of a class. C++ classes are very good for some things: encapsulation, inheritance, polymorphism, etc. If you're going to use a singleton, then you're not going to be using inheritance, you're not really encapsulating much because in essence you just have a glorified struct that is only being created once, and you can't very well use polymorphism if you don't inherit. So why even bother creating a whole class for something that will be instantiated once?

My preferences; if want to hide information about "singular" objects like the video subsystem or the game engine, declare them static in their own module and keep state information there locally. Then just use standard function calls to do the interaction as you would with any member functions your singleton would have called.

Then you also avoid having to keep pointers around in every single place you want to acccess that information.

Quote:Original post by Omaha
If you're going to use a singleton, then you're not going to be using inheritance...

One of the purposes of a singleton over a static class is so you can use inheritance. Say you have a Renderer class that uses SDL and you want to make a subclass of it that uses Direct3D or OpenGL.
Sure, you can still just a global object, but thats got its own problems.

EDIT: Also, I believe you can override the delete operator and make it private. THat'd solve the problem of accidental deletions of the singleton object.

A very clever Singleton interface I wrote a while back (I got the concept from some article, can't remember the name though):



Example Usage:

class Renderer : public ISingleton<Renderer>{     void Render();};void main(){     new Renderer;     Renderer::Get().Render();}

Quote:Original post by CraZeE
What is to stop someone from accidentally deleting the pointer? I personally use a specific shutdown function to force termination of a singleton, but i neva actually tried deleting it directly (mainly coz i created the functon for a purpose :P ). Can accidental 'delete' be prevented?

You don't have to return a pointer:



Then you just derive any class you want to be a singelton from singleton with the template parameter as itself.

Quote:template<class T>
class singleton
{
public:
static T& getInstance()
{
if(!instance)
{
instance = new T;
}
return *instance;
}
private:
static T* instance;
};


template<class T>
T* singleton<T>::instance = 0;

what is "T* singleton<T>::instance = 0;"?
it is a function? because have return type T*.
it is a memeber of data? because ::instance is static T* instance;