Quote:Original post by derek7

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;

Quote:Original post by CraZeE
i'm not really contributing to the topic but i DO have a related question. Been using singleton's on several occasions and they were handy. But it just crossed my mind that although instantiation is only ONCE, how do you prevent accidental deletion?

a singleton instantiates itself on first reference: easy to do by protecting the constructors and allowing a GetInstance-kind of function. But by that, you will get back a pointer.

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?

class Singleton{public:   static Singleton &instance(void)   {      static Singleton rv;      return rv;   }};

Quote:Original post by Omaha
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?