Singleton template

/************************************************************************
* Template of Singleton, threads safe.
* by xiuleili 2013-7-5
************************************************************************/
#pragma once
#include <memory>

#ifdef WIN32
#include "ResGuard.hpp"
#else
#include "ResGuard_linux.hpp"
#endif

template <class T>
class Singleton
{
public:
// return instance of the singleton
static inline T* instance(){
if( 0 == _instance.get() )
{
ResGuard::Lock gd(_rs);
if( 0== _instance.get())
{
_instance.reset ( new T);
}
}
return _instance.get();
}

private:
Singleton(void){}
~Singleton(void){}
Singleton(const Singleton&){}
Singleton & operator= (const Singleton &){}

static std::auto_ptr<T> _instance; // auto_ptr used for release the resource.
static ResGuard _rs;               //
};

template <class T>
std::auto_ptr<T> Singleton<T>::_instance;

template <class T>
ResGuard Singleton<T>::_rs;

// use this macro to declare a singleton
#define DECLARE_SINGLETON_CLASS( type ) \
friend class std::auto_ptr< type >;\
friend class Singleton< type >;

// How to use:
// class A{
// private:
//     A(){}
//     A(const A &){}
//     ~A(){}
//     A & operator=(const A &){}
//     DECLARE_SINGLETON_CLASS(A);
// };
//
// declare the singleton:
// typedef Singleton<A> theA;

//
// call it somewhere like this:
// theA::instance()->foo();

/*
* Implementation of ResGuard on Windows.
* see <<windows kernal var cpp>>
* by xiuleili 2013-7-5
*/

#pragma once
#ifndef _UNIX
#include <windows.h>
///////////////////////////////////////////////////////////////////////////////

// Instances of this class will be accessed by multiple threads. So,
// all members of this class (except the constructor and destructor)
// must be thread-safe.
class ResGuard {
public:
ResGuard()  { m_guardcount = 0; InitializeCriticalSection(&m_cs); }
~ResGuard() { DeleteCriticalSection(&m_cs); }

// IsGuarded is used for debugging
bool isgurded() const { return(m_guardcount > 0); }

public:
class Lock {
public:
Lock(ResGuard& rg) : m_rg(rg) { m_rg.Guard(); };
~Lock() { m_rg.Unguard(); }

private:
ResGuard& m_rg;
};

private:
void Guard()   { EnterCriticalSection(&m_cs); m_guardcount++; }
void Unguard() { m_guardcount--; LeaveCriticalSection(&m_cs); }

// Guard/Unguard can only be accessed by the nested CGuard class.
friend class ResGuard::Lock;

private:
CRITICAL_SECTION m_cs;
long m_guardcount;   // # of EnterCriticalSection calls
};
#endif

/*
* implementation of ResGuard.
* See <POSIX Muti-threads programming>
* by xiuleili 2013-7-5
*/

#pragma once
#include <pthread.h>

// Instances of this class will be accessed by multiple threads. So,
// all members of this class (except the constructor and destructor)
// must be thread-safe.
class ResGuard {
public:
ResGuard()  { m_guardcount = 0; pthread_mutex_init(&m_cs, NULL); }
~ResGuard() { pthread_mutex_destroy(&m_cs); }

// IsGuarded is used for debugging
bool isgurded() const { return(m_guardcount > 0); }

public:
class Lock {
public:
Lock(ResGuard& rg) : m_rg(rg) { m_rg.Guard(); };
~Lock() { m_rg.Unguard(); }

private:
ResGuard& m_rg;
};

private:
void Guard()   { pthread_mutex_lock(&m_cs); m_guardcount++; }
void Unguard() { m_guardcount--; pthread_mutex_unlock(&m_cs); }

// Guard/Unguard can only be accessed by the nested Guard class.
friend class ResGuard::Lock;

private:
pthread_mutex_t m_cs;
long m_guardcount;   // # of EnterCriticalSection calls
};