CareerCup

exception safe and thread-safe

template <typename T>
class Singleton
{
public:
T* Instance()
{
if(!instance)
{
Lock lock(m_dataMutex); // RAII object which aquires mutex lock

if(!instance) // Double check
{
try
{
instance = new T;
}
catch(...)
{
cout<<"Exception encountered in Singleton::MyInstance"<<endl;
}
}
}

return instance;
}
private:
Singleton(){}
Singleton(const Singleton&){}
Singleton& operator=(const Singleton&){}
~Singleton(){}
static T *instance;
static Mutex m_dataMutex;
};

i think they expect a double checking lock

@Vinit
would you mind explaining your code a bit...would be nice. thank you.

template <typename T>
class Singleton
{
public:
T* Instance()
{
if(!instance)
{
Lock mutex; // RAII object which aquires mutex lock

if(!instance) // Double check
{
instance = new T;
}
}

return instance;
}
private:
Singleton(){}
~Singleton(){}
static T *instance;
};

In .cpp

static Singleton<T>::instance = 0

and you should also make the operator= private for this class.

I don't understand, why do you need a double check?

template<class C>
class Singleton
{
private:
static C * obj;
Mutex lock;

public:
static C * getSingleton()
{
if(C==NULL)
{
lock.lock();
if(C==NULL)
{
obj=new C();
}
lock.unlock();
}

return obj;
};
};

class foo
{
public:
static foo* instance();
private:
foo() {}
~foo() {}
static foo* smInstance;
static Lock smMutex;
};



foo* foo::smInstance = NULL;
Lock foo::smMutex;

foo* foo::instance()
{
LockLocker lock(&smMutex);

if (smInstance == NULL)
smInstance = new foo();

return smInstance;
}